NdbOperation(aNdb, aType),

m_transConnection(NULL)

{

theParallelism = 0;

m_allocated_receivers = 0;

m_prepared_receivers = 0;

m_api_receivers = 0;

m_conf_receivers = 0;

m_sent_receivers = 0;

m_receivers = 0;

m_array = new Uint32[1]; // skip if on delete in fix_receivers

theSCAN_TABREQ = 0;

m_executed = false;

m_scan_buffer= NULL;

m_scanUsingOldApi= true;

m_readTuplesCalled= false;

m_interpretedCodeOldApi= NULL;

{

NdbScanOperation *pnonConstThis=const_cast<NdbScanOperation *>(this);

NdbTransaction* tmp = theNdbCon;

pnonConstThis->theNdbCon = m_transConnection;

NdbOperation::setErrorCode(aErrorCode);

pnonConstThis->theNdbCon = tmp;

{

NdbScanOperation *pnonConstThis=const_cast<NdbScanOperation *>(this);

NdbTransaction* tmp = theNdbCon;

pnonConstThis->theNdbCon = m_transConnection;

NdbOperation::setErrorCodeAbort(aErrorCode);

pnonConstThis->theNdbCon = tmp;

{

m_transConnection = myConnection;

if (NdbOperation::init(tab, myConnection, false) != 0)

return -1;

theNdb->theRemainingStartTransactions++; // will be checked in hupp...

NdbTransaction* aScanConnection = theNdb->hupp(myConnection);

if (!aScanConnection){

theNdb->theRemainingStartTransactions--;

setErrorCodeAbort(theNdb->getNdbError().code);

return -1;

}

// NOTE! The hupped trans becomes the owner of the operation

theNdbCon= aScanConnection;

initInterpreter();

theStatus = GetValue;

theOperationType = OpenScanRequest;

theNdbCon->theMagicNumber = 0xFE11DF;

theNoOfTupKeyLeft = tab->m_noOfDistributionKeys;

m_ordered= false;

m_descending= false;

m_read_range_no = 0;

m_executed = false;

m_scanUsingOldApi= true;

m_readTuplesCalled= false;

m_interpretedCodeOldApi= NULL;

m_pruneState= SPS_UNKNOWN;

m_api_receivers_count = 0;

m_current_api_receiver = 0;

m_sent_receivers_count = 0;

m_conf_receivers_count = 0;

return 0;

{

/* Handle old API-defined scan getValue(s) */

assert(m_scanUsingOldApi);

if (theReceiver.theFirstRecAttr != NULL)

{

/* theReceiver has a list of RecAttrs which the user

const NdbRecAttr* recAttrToRead = theReceiver.theFirstRecAttr;

while(recAttrToRead != NULL)

{

int res;

res= insertATTRINFOHdr_NdbRecord(recAttrToRead->theAttrId, 0);

if (unlikely(res == -1))

return -1;

recAttrToRead= recAttrToRead->next();

}

theInitialReadSize= theTotalCurrAI_Len - AttrInfo::SectionSizeInfoLength;

}

return 0;

{

Uint32 mainProgramWords= 0;

Uint32 subroutineWords= 0;

const NdbInterpretedCode* code= m_interpreted_code;

/* Any disk access? */

if (code->m_flags & NdbInterpretedCode::UsesDisk)

{

m_flags &= ~Uint8(OF_NO_DISK);

}

/* Main program size depends on whether there's subroutines */

mainProgramWords= code->m_first_sub_instruction_pos ?

code->m_first_sub_instruction_pos :

code->m_instructions_length;

int res = insertATTRINFOData_NdbRecord((const char*)code->m_buffer,

mainProgramWords << 2);

if (res == 0)

{

/* Add subroutines, if we have any */

if (code->m_number_of_subs > 0)

{

assert(mainProgramWords > 0);

assert(code->m_first_sub_instruction_pos > 0);

Uint32 *subroutineStart=

&code->m_buffer[ code->m_first_sub_instruction_pos ];

subroutineWords=

code->m_instructions_length -

code->m_first_sub_instruction_pos;

res = insertATTRINFOData_NdbRecord((const char*) subroutineStart,

subroutineWords << 2);

}

/* Update signal section lengths */

theInterpretedSize= mainProgramWords;

theSubroutineSize= subroutineWords;

}

return res;

{

/* Options size has already been checked.

if ((options->optionsPresent & ScanOptions::SO_GETVALUE) &&

(options->numExtraGetValues > 0))

{

if (options->extraGetValues == NULL)

{

setErrorCodeAbort(4299);

/* Incorrect combination of ScanOption flags,

return -1;

}

/* Add extra getValue()s */

for (unsigned int i=0; i < options->numExtraGetValues; i++)

{

NdbOperation::GetValueSpec *pvalSpec = &(options->extraGetValues[i]);

pvalSpec->recAttr=NULL;

if (pvalSpec->column == NULL)

{

setErrorCodeAbort(4295);

// Column is NULL in Get/SetValueSpec structure

return -1;

}

/* Call internal NdbRecord specific getValue() method

NdbRecAttr *pra=

getValue_NdbRecord_scan(&NdbColumnImpl::getImpl(*pvalSpec->column),

(char *) pvalSpec->appStorage);

if (pra == NULL)

{

return -1;

}

pvalSpec->recAttr = pra;

}

}

if (options->optionsPresent & ScanOptions::SO_PARTITION_ID)

{

/* Should not have any blobs defined at this stage */

assert(theBlobList == NULL);

assert(m_pruneState == SPS_UNKNOWN);

/* Only allowed to set partition id for PK ops on UserDefined

if(unlikely(! (m_attribute_record->flags &

NdbRecord::RecHasUserDefinedPartitioning)))

{

/* Explicit partitioning info not allowed for table and operation*/

setErrorCodeAbort(4546);

return -1;

}

m_pruneState= SPS_FIXED;

m_pruningKey= options->partitionId;

/* And set the vars in the operation now too */

theDistributionKey = options->partitionId;

theDistrKeyIndicator_ = 1;

assert((m_attribute_record->flags & NdbRecord::RecHasUserDefinedPartitioning) != 0);

DBUG_PRINT("info", ("NdbScanOperation::handleScanOptions(dist key): %u",

theDistributionKey));

}

if (options->optionsPresent & ScanOptions::SO_INTERPRETED)

{

/* Check the program's for the same table as the

const NdbDictionary::Table* codeTable=

options->interpretedCode->getTable();

if (codeTable != NULL)

{

NdbTableImpl* impl= &NdbTableImpl::getImpl(*codeTable);

if ((impl->m_id != (int) m_attribute_record->tableId) ||

(table_version_major(impl->m_version) !=

table_version_major(m_attribute_record->tableVersion)))

return 4524; // NdbInterpretedCode is for different table`

}

if ((options->interpretedCode->m_flags &

NdbInterpretedCode::Finalised) == 0)

{

setErrorCodeAbort(4519);

return -1; // NdbInterpretedCode::finalise() not called.

}

m_interpreted_code= options->interpretedCode;

}

/* User's operation 'tag' data. */

if (options->optionsPresent & ScanOptions::SO_CUSTOMDATA)

{

m_customData = options->customData;

}

/* Preferred form of partitioning information */

if (options->optionsPresent & ScanOptions::SO_PART_INFO)

{

Uint32 partValue;

Ndb::PartitionSpec tmpSpec;

const Ndb::PartitionSpec* pSpec= options->partitionInfo;

if (unlikely(validatePartInfoPtr(pSpec,

options->sizeOfPartInfo,

tmpSpec) ||

getPartValueFromInfo(pSpec,

m_currentTable,

&partValue)))

return -1;

assert(m_pruneState == SPS_UNKNOWN);

m_pruneState= SPS_FIXED;

m_pruningKey= partValue;

theDistributionKey= partValue;

theDistrKeyIndicator_= 1;

DBUG_PRINT("info", ("Set distribution key from partition spec to %u",

partValue));

}

return 0;

bool& haveBlob,

const Uint32 * m_read_mask)

{

Bitmask<MAXNROFATTRIBUTESINWORDS> readMask;

Uint32 columnCount= 0;

Uint32 maxAttrId= 0;

haveBlob= false;

for (Uint32 i= 0; i<result_record->noOfColumns; i++)

{

const NdbRecord::Attr *col= &result_record->columns[i];

Uint32 attrId= col->attrId;

assert(!(attrId & AttributeHeader::PSEUDO));

/* Skip column if result_mask says so and we don't need

if (!BitmaskImpl::get(MAXNROFATTRIBUTESINWORDS, m_read_mask, attrId))

continue;

/* Blob reads are handled with a getValue() in NdbBlob.cpp. */

if (unlikely(col->flags & NdbRecord::IsBlob))

{

m_keyInfo= 1; // Need keyinfo for blob scan

haveBlob= true;

continue;

}

if (col->flags & NdbRecord::IsDisk)

m_flags &= ~Uint8(OF_NO_DISK);

if (attrId > maxAttrId)

maxAttrId= attrId;

readMask.set(attrId);

columnCount++;

}

int result= 0;

/* Are there any columns to read via NdbRecord?

if (columnCount > 0)

{

bool all= (columnCount == m_currentTable->m_columns.size());

if (all)

result= insertATTRINFOHdr_NdbRecord(AttributeHeader::READ_ALL,

columnCount);

else

{

/* How many bitmask words are significant? */

Uint32 sigBitmaskWords= (maxAttrId>>5) + 1;

result= insertATTRINFOHdr_NdbRecord(AttributeHeader::READ_PACKED,

sigBitmaskWords << 2);

if (result != -1)

result= insertATTRINFOData_NdbRecord((const char*) &readMask.rep.data[0],

sigBitmaskWords << 2); // Bitmask

}

}

return result;

const Uint32 * readMask)

{

bool haveBlob= false;

/* Add AttrInfos for packed read of cols in result_record */

if (generatePackedReadAIs(m_attribute_record, haveBlob, readMask) != 0)

return -1;

theInitialReadSize= theTotalCurrAI_Len - AttrInfo::SectionSizeInfoLength;

/* Handle any getValue() calls made against the old API. */

if (m_scanUsingOldApi)

{

if (handleScanGetValuesOldApi() !=0)

return -1;

}

/* Handle scan options - always for old style scan API */

if (options != NULL)

{

if (handleScanOptions(options) != 0)

return -1;

}

/* Get Blob handles unless this is an old Api scan op

if (unlikely(haveBlob) && !m_scanUsingOldApi)

{

if (getBlobHandlesNdbRecord(m_transConnection, readMask) == -1)

return -1;

}

/* Add interpreted code words to ATTRINFO signal

if (m_interpreted_code != NULL)

{

if (addInterpretedCode() == -1)

return -1;

}

/* Scan is now fully defined, so let's start preparing

if (prepareSendScan(theNdbCon->theTCConPtr,

theNdbCon->theTransactionId) == -1)

/* Error code should be set */

return -1;

return 0;

Uint32 sizeOfOptions,

ScanOptions& currOptions)

{

/* Handle different sized ScanOptions */

if (unlikely((sizeOfOptions !=0) &&

(sizeOfOptions != sizeof(ScanOptions))))

{

/* Different size passed, perhaps it's an old client */

if (sizeOfOptions == sizeof(ScanOptions_v1))

{

const ScanOptions_v1* oldOptions=

(const ScanOptions_v1*) optionsPtr;

/* v1 of ScanOptions, copy into current version

currOptions.optionsPresent= oldOptions->optionsPresent;

currOptions.scan_flags= oldOptions->scan_flags;

currOptions.parallel= oldOptions->parallel;

currOptions.batch= oldOptions->batch;

currOptions.extraGetValues= oldOptions->extraGetValues;

currOptions.numExtraGetValues= oldOptions->numExtraGetValues;

currOptions.partitionId= oldOptions->partitionId;

currOptions.interpretedCode= oldOptions->interpretedCode;

currOptions.customData= oldOptions->customData;

/* New fields */

currOptions.partitionInfo= NULL;

currOptions.sizeOfPartInfo= 0;

optionsPtr= &currOptions;

}

else

{

/* No other versions supported currently */

setErrorCodeAbort(4298);

/* Invalid or unsupported ScanOptions structure */

return -1;

}

}

return 0;

NdbOperation::LockMode lock_mode,

const unsigned char *result_mask,

const NdbScanOperation::ScanOptions *options,

Uint32 sizeOfOptions)

{

int res;

Uint32 scan_flags = 0;

Uint32 parallel = 0;

Uint32 batch = 0;

ScanOptions currentOptions;

if (options != NULL)

{

if (handleScanOptionsVersion(options, sizeOfOptions, currentOptions))

return -1;

/* Process some initial ScanOptions - most are

if (options->optionsPresent & ScanOptions::SO_SCANFLAGS)

scan_flags = options->scan_flags;

if (options->optionsPresent & ScanOptions::SO_PARALLEL)

parallel = options->parallel;

if (options->optionsPresent & ScanOptions::SO_BATCH)

batch = options->batch;

}

#if 0 // ToDo: this breaks optimize index, but maybe there is a better solution

if (result_record->flags & NdbRecord::RecIsIndex)

{

setErrorCodeAbort(4340);

return -1;

}

#endif

m_attribute_record= result_record;

AttributeMask readMask;

m_attribute_record->copyMask(readMask.rep.data, result_mask);

/* Process scan definition info */

res= processTableScanDefs(lock_mode, scan_flags, parallel, batch);

if (res == -1)

return -1;

theStatus= NdbOperation::UseNdbRecord;

/* Call generic scan code */

return scanImpl(options, readMask.rep.data);

const NdbTableImpl* table,

Uint32* partValue)

{

switch(partInfo->type)

{

case Ndb::PartitionSpec::PS_USER_DEFINED:

{

assert(table->m_fragmentType == NdbDictionary::Object::UserDefined);

*partValue= partInfo->UserDefined.partitionId;

return 0;

}

case Ndb::PartitionSpec::PS_DISTR_KEY_PART_PTR:

{

assert(table->m_fragmentType != NdbDictionary::Object::UserDefined);

Uint32 hashVal;

int ret= Ndb::computeHash(&hashVal, table,

partInfo->KeyPartPtr.tableKeyParts,

partInfo->KeyPartPtr.xfrmbuf,

partInfo->KeyPartPtr.xfrmbuflen);

if (ret == 0)

{

/* We send the hash result here (rather than the partitionId

*partValue= hashVal;

return 0;

}

else

{

setErrorCodeAbort(ret);

return -1;

}

}

case Ndb::PartitionSpec::PS_DISTR_KEY_RECORD:

{

assert(table->m_fragmentType != NdbDictionary::Object::UserDefined);

Uint32 hashVal;

int ret= Ndb::computeHash(&hashVal,

partInfo->KeyRecord.keyRecord,

partInfo->KeyRecord.keyRow,

partInfo->KeyRecord.xfrmbuf,

partInfo->KeyRecord.xfrmbuflen);

if (ret == 0)

{

/* See comments above about sending hashResult rather than

*partValue= hashVal;

return 0;

}

else

{

setErrorCodeAbort(ret);

return -1;

}

}

}

/* 4542 : Unknown partition information type */

setErrorCodeAbort(4542);

return -1;

const char *row1,

const char *row2,

Uint32 prefix_length)

{

Uint32 i;

if (row1 == row2) // Easy case with same ptrs

return 0;

for (i= 0; i<prefix_length; i++)

{

const NdbRecord::Attr *col= &rec->columns[rec->key_indexes[i]];

bool is_null1= col->is_null(row1);

bool is_null2= col->is_null(row2);

if (is_null1)

{

if (!is_null2)

return -1;

/* Fall-through to compare next one. */

}

else

{

if (is_null2)

return 1;

Uint32 offset= col->offset;

Uint32 maxSize= col->maxSize;

const char *ptr1= row1 + offset;

const char *ptr2= row2 + offset;

/* bug#56853 */

char buf1[NdbRecord::Attr::SHRINK_VARCHAR_BUFFSIZE];

char buf2[NdbRecord::Attr::SHRINK_VARCHAR_BUFFSIZE];

if (col->flags & NdbRecord::IsMysqldShrinkVarchar)

{

Uint32 len1;

bool ok1 = col->shrink_varchar(row1, len1, buf1);

assert(ok1);

ptr1 = buf1;

Uint32 len2;

bool ok2 = col->shrink_varchar(row2, len2, buf2);

assert(ok2);

ptr2 = buf2;

}

void *info= col->charset_info;

int res=

(*col->compare_function)(info, ptr1, maxSize, ptr2, maxSize);

if (res)

{

return res;

}

}

}

return 0;

const NdbRecord *result_record,

const char *row,

Uint32* distKey)

{

const Uint32 MaxKeySizeInLongWords= (NDB_MAX_KEY_SIZE + 7) / 8;

Uint64 tmp[ MaxKeySizeInLongWords ];

char* tmpshrink = (char*)tmp;

Uint32 tmplen = (Uint32)sizeof(tmp);

/* This can't work for User Defined partitioning */

assert(key_record->table->m_fragmentType !=

NdbDictionary::Object::UserDefined);

Ndb::Key_part_ptr ptrs[NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY+1];

Uint32 i;

for (i = 0; i<key_record->distkey_index_length; i++)

{

const NdbRecord::Attr *col =

&key_record->columns[key_record->distkey_indexes[i]];

if (col->flags & NdbRecord::IsMysqldShrinkVarchar)

{

if (tmplen >= 256)

{

Uint32 len;

bool len_ok = col->shrink_varchar(row, len, tmpshrink);

if (!len_ok)

{

/* 4209 : Length parameter in equal/setValue is incorrect */

setErrorCodeAbort(4209);

return -1;

}

ptrs[i].ptr = tmpshrink;

tmpshrink += len;

tmplen -= len;

}

else

{

/* 4207 : Key size is limited to 4092 bytes */

setErrorCodeAbort(4207);

return -1;

}

}

else

{

ptrs[i].ptr = row + col->offset;

}

ptrs[i].len = col->maxSize;

}

ptrs[i].ptr = 0;

Uint32 hashValue;

int ret = Ndb::computeHash(&hashValue, result_record->table,

ptrs, tmpshrink, tmplen);

if (ret == 0)

{

*distKey = hashValue;

return 0;

}

else

{

#ifdef VM_TRACE

ndbout << "err: " << ret << endl;

#endif

setErrorCodeAbort(ret);

return -1;

}

Uint32 sizeOfPartInfo,

Ndb::PartitionSpec& tmpSpec)

{

if (unlikely(sizeOfPartInfo != sizeof(Ndb::PartitionSpec)))

{

if (sizeOfPartInfo == sizeof(Ndb::PartitionSpec_v1))

{

const Ndb::PartitionSpec_v1* oldPSpec=

(const Ndb::PartitionSpec_v1*) partInfo;

/* Let's upgrade to the latest variant */

tmpSpec.type= oldPSpec->type;

if (tmpSpec.type == Ndb::PartitionSpec_v1::PS_USER_DEFINED)

{

tmpSpec.UserDefined.partitionId= oldPSpec->UserDefined.partitionId;

}

else

{

tmpSpec.KeyPartPtr.tableKeyParts= oldPSpec->KeyPartPtr.tableKeyParts;

tmpSpec.KeyPartPtr.xfrmbuf= oldPSpec->KeyPartPtr.xfrmbuf;

tmpSpec.KeyPartPtr.xfrmbuflen= oldPSpec->KeyPartPtr.xfrmbuflen;

}

partInfo= &tmpSpec;

}

else

{

/* 4545 : Invalid or Unsupported PartitionInfo structure */

setErrorCodeAbort(4545);

return -1;

}

}

if (partInfo->type != Ndb::PartitionSpec::PS_NONE)

{

if (m_pruneState == SPS_FIXED)

{

/* 4543 : Duplicate partitioning information supplied */

setErrorCodeAbort(4543);

return -1;

}

if ((partInfo->type == Ndb::PartitionSpec::PS_USER_DEFINED) !=

((m_currentTable->m_fragmentType == NdbDictionary::Object::UserDefined)))

{

/* Mismatch between type of partitioning info supplied, and table's

/* 4544 : Wrong partitionInfo type for table */

setErrorCodeAbort(4544);

return -1;

}

}

else

{

/* PartInfo supplied, but set to NONE */

partInfo= NULL;

}

return 0;

const IndexBound& bound)

{

return setBound(key_record, bound, NULL, 0);

const IndexBound& bound,

const Ndb::PartitionSpec* partInfo,

Uint32 sizeOfPartInfo)

{

if (unlikely((theStatus != NdbOperation::UseNdbRecord)))

{

setErrorCodeAbort(4284);

/* Cannot mix NdbRecAttr and NdbRecord methods in one operation */

return -1;

}

if (unlikely(key_record == NULL))

{

setErrorCodeAbort(4285);

/* NULL NdbRecord pointer */

return -1;

}

/* Has the user supplied an open range (no bounds)? */

const bool openRange= (((bound.low_key == NULL) &&

(bound.high_key == NULL)) ||

((bound.low_key_count == 0) &&

(bound.high_key_count == 0)));

/* Check the base table's partitioning scheme

bool tabHasUserDefPartitioning= (m_currentTable->m_fragmentType ==

NdbDictionary::Object::UserDefined);

/* Validate explicit partitioning info if it's supplied */

Ndb::PartitionSpec tmpSpec;

if (partInfo)

{

/* May update the PartInfo ptr */

if (validatePartInfoPtr(partInfo,

sizeOfPartInfo,

tmpSpec))

return -1;

}

m_num_bounds++;

if (unlikely((m_num_bounds > 1) &&

(m_multi_range == 0)))

{

/* > 1 IndexBound, but not MRR */

setErrorCodeAbort(4509);

/* Non SF_MultiRange scan cannot have more than one bound */

return -1;

}

Uint32 j;

Uint32 key_count, common_key_count;

Uint32 range_no;

Uint32 bound_head;

range_no= bound.range_no;

if (unlikely(range_no > MaxRangeNo))

{

setErrorCodeAbort(4286);

return -1;

}

/* Check valid ordering of supplied range numbers */

if ( m_read_range_no && m_ordered )

{

if (unlikely((m_num_bounds > 1) &&

(range_no <= m_previous_range_num)))

{

setErrorCodeAbort(4282);

/* range_no not strictly increasing in ordered multi-range index scan */

return -1;

}

m_previous_range_num= range_no;

}

key_count= bound.low_key_count;

common_key_count= key_count;

if (key_count < bound.high_key_count)

key_count= bound.high_key_count;

else

common_key_count= bound.high_key_count;

if (unlikely(key_count > key_record->key_index_length))

{

/* Too many keys specified for key bound. */

setErrorCodeAbort(4281);

return -1;

}

/* We need to get a ptr to the first word of this

Uint32* firstRangeWord= NULL;

const Uint32 keyLenBeforeRange= theTupKeyLen;

if (likely(!openRange))

{

/* If low and high key pointers are the same and key counts are

const bool isEqRange=

(bound.low_key == bound.high_key) &&

(bound.low_key_count == bound.high_key_count) &&

(bound.low_inclusive && bound.high_inclusive); // Does this matter?

if (isEqRange)