Merge ymer.(none):/usr/local/mysql/mysql-5.0-ndb-bug27370 (87a0ffa0) · Commits · Software / OSDI20 Artifacts / mariadb

ndb/include/kernel/signaldata/ScanTab.hpp

+27 −17

Original line number	Diff line number	Diff line
		@@ -113,15 +113,15 @@ private:
		z = Descending (TUX) - 1 Bit 14
		x = Range Scan (TUX) - 1 Bit 15
		b = Scan batch - 10 Bit 16-25 (max 1023)
		d = Distribution key flag
		d = Distribution key flag - 1 Bit 26

		1111111111222222222233
		01234567890123456789012345678901
		ppppppppl hcktzxbbbbbbbbbb
		ppppppppl hcktzxbbbbbbbbbbd
		*/

		#define PARALLELL_SHIFT (0)
		#define PARALLELL_MASK (255)
		#define PARALLEL_SHIFT (0)
		#define PARALLEL_MASK (255)

		#define LOCK_MODE_SHIFT (8)
		#define LOCK_MODE_MASK (1)
		@@ -148,11 +148,12 @@ private:
		#define SCAN_BATCH_MASK (1023)

		#define SCAN_DISTR_KEY_SHIFT (26)
		#define SCAN_DISTR_KEY_MASK (1)

		inline
		Uint8
		ScanTabReq::getParallelism(const UintR & requestInfo){
		return (Uint8)((requestInfo >> PARALLELL_SHIFT) & PARALLELL_MASK);
		return (Uint8)((requestInfo >> PARALLEL_SHIFT) & PARALLEL_MASK);
		}

		inline
		@@ -206,58 +207,65 @@ ScanTabReq::clearRequestInfo(UintR & requestInfo){
		inline
		void
		ScanTabReq::setParallelism(UintR & requestInfo, Uint32 type){
		ASSERT_MAX(type, PARALLELL_MASK, "ScanTabReq::setParallellism");
		requestInfo \|= (type << PARALLELL_SHIFT);
		ASSERT_MAX(type, PARALLEL_MASK, "ScanTabReq::setParallelism");
		requestInfo= (requestInfo & ~(PARALLEL_MASK << PARALLEL_SHIFT)) \|
		((type & PARALLEL_MASK) << PARALLEL_SHIFT);
		}

		inline
		void
		ScanTabReq::setLockMode(UintR & requestInfo, Uint32 mode){
		ASSERT_MAX(mode, LOCK_MODE_MASK, "ScanTabReq::setLockMode");
		requestInfo \|= (mode << LOCK_MODE_SHIFT);
		requestInfo= (requestInfo & ~(LOCK_MODE_MASK << LOCK_MODE_SHIFT)) \|
		((mode & LOCK_MODE_MASK) << LOCK_MODE_SHIFT);
		}

		inline
		void
		ScanTabReq::setHoldLockFlag(UintR & requestInfo, Uint32 flag){
		ASSERT_BOOL(flag, "ScanTabReq::setHoldLockFlag");
		requestInfo \|= (flag << HOLD_LOCK_SHIFT);
		requestInfo= (requestInfo & ~(HOLD_LOCK_MASK << HOLD_LOCK_SHIFT)) \|
		((flag & HOLD_LOCK_MASK) << HOLD_LOCK_SHIFT);
		}

		inline
		void
		ScanTabReq::setReadCommittedFlag(UintR & requestInfo, Uint32 flag){
		ASSERT_BOOL(flag, "ScanTabReq::setReadCommittedFlag");
		requestInfo \|= (flag << READ_COMMITTED_SHIFT);
		requestInfo= (requestInfo & ~(READ_COMMITTED_MASK << READ_COMMITTED_SHIFT)) \|
		((flag & READ_COMMITTED_MASK) << READ_COMMITTED_SHIFT);
		}

		inline
		void
		ScanTabReq::setRangeScanFlag(UintR & requestInfo, Uint32 flag){
		ASSERT_BOOL(flag, "ScanTabReq::setRangeScanFlag");
		requestInfo \|= (flag << RANGE_SCAN_SHIFT);
		requestInfo= (requestInfo & ~(RANGE_SCAN_MASK << RANGE_SCAN_SHIFT)) \|
		((flag & RANGE_SCAN_MASK) << RANGE_SCAN_SHIFT);
		}

		inline
		void
		ScanTabReq::setDescendingFlag(UintR & requestInfo, Uint32 flag){
		ASSERT_BOOL(flag, "ScanTabReq::setDescendingFlag");
		requestInfo \|= (flag << DESCENDING_SHIFT);
		requestInfo= (requestInfo & ~(DESCENDING_MASK << DESCENDING_SHIFT)) \|
		((flag & DESCENDING_MASK) << DESCENDING_SHIFT);
		}

		inline
		void
		ScanTabReq::setTupScanFlag(UintR & requestInfo, Uint32 flag){
		ASSERT_BOOL(flag, "ScanTabReq::setTupScanFlag");
		requestInfo \|= (flag << TUP_SCAN_SHIFT);
		requestInfo= (requestInfo & ~(TUP_SCAN_MASK << TUP_SCAN_SHIFT)) \|
		((flag & TUP_SCAN_MASK) << TUP_SCAN_SHIFT);
		}

		inline
		void
		ScanTabReq::setScanBatch(Uint32 & requestInfo, Uint32 flag){
		ASSERT_MAX(flag, SCAN_BATCH_MASK, "ScanTabReq::setScanBatch");
		requestInfo &= ~(SCAN_BATCH_MASK << SCAN_BATCH_SHIFT);
		requestInfo \|= (flag << SCAN_BATCH_SHIFT);
		requestInfo= (requestInfo & ~(SCAN_BATCH_MASK << SCAN_BATCH_SHIFT)) \|
		((flag & SCAN_BATCH_MASK) << SCAN_BATCH_SHIFT);
		}

		inline
		@@ -270,7 +278,8 @@ inline
		void
		ScanTabReq::setKeyinfoFlag(UintR & requestInfo, Uint32 flag){
		ASSERT_BOOL(flag, "ScanTabReq::setKeyinfoFlag");
		requestInfo \|= (flag << KEYINFO_SHIFT);
		requestInfo= (requestInfo & ~(KEYINFO_MASK << KEYINFO_SHIFT)) \|
		((flag & KEYINFO_MASK) << KEYINFO_SHIFT);
		}

		inline
		@@ -283,7 +292,8 @@ inline
		void
		ScanTabReq::setDistributionKeyFlag(UintR & requestInfo, Uint32 flag){
		ASSERT_BOOL(flag, "ScanTabReq::setKeyinfoFlag");
		requestInfo \|= (flag << SCAN_DISTR_KEY_SHIFT);
		requestInfo= (requestInfo & ~(SCAN_DISTR_KEY_MASK << SCAN_DISTR_KEY_SHIFT)) \|
		((flag & SCAN_DISTR_KEY_MASK) << SCAN_DISTR_KEY_SHIFT);
		}

		/**

ndb/include/ndbapi/NdbOperation.hpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -908,6 +908,8 @@ protected:
		// get table or index key from prepared signals
		int getKeyFromTCREQ(Uint32* data, unsigned size);

		virtual void setReadLockMode(LockMode lockMode);

		/******************************************************************************
		* These are the private variables that are defined in the operation objects.
		*****************************************************************************/

ndb/include/ndbapi/NdbScanOperation.hpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -212,6 +212,7 @@ protected:
		int prepareSend(Uint32 TC_ConnectPtr, Uint64 TransactionId);
		int doSend(int ProcessorId);
		void checkForceSend(bool forceSend);
		virtual void setReadLockMode(LockMode lockMode);

		virtual void setErrorCode(int aErrorCode);
		virtual void setErrorCodeAbort(int aErrorCode);

ndb/src/ndbapi/NdbBlob.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -1163,7 +1163,7 @@ NdbBlob::atPrepare(NdbTransaction* aCon, NdbOperation* anOp, const NdbColumnImpl
		if (isReadOp()) {
		// upgrade lock mode
		if (theNdbOp->theLockMode == NdbOperation::LM_CommittedRead)
		theNdbOp->theLockMode = NdbOperation::LM_Read;
		theNdbOp->setReadLockMode(NdbOperation::LM_Read);
		// add read of head+inline in this op
		if (getHeadInlineValue(theNdbOp) == -1)
		DBUG_RETURN(-1);
		@@ -1184,7 +1184,7 @@ NdbBlob::atPrepare(NdbTransaction* aCon, NdbOperation* anOp, const NdbColumnImpl
		if (isScanOp()) {
		// upgrade lock mode
		if (theNdbOp->theLockMode == NdbOperation::LM_CommittedRead)
		theNdbOp->theLockMode = NdbOperation::LM_Read;
		theNdbOp->setReadLockMode(NdbOperation::LM_Read);
		// add read of head+inline in this op
		if (getHeadInlineValue(theNdbOp) == -1)
		DBUG_RETURN(-1);

ndb/src/ndbapi/NdbOperationDefine.cpp

+30 −0

Original line number	Diff line number	Diff line
		@@ -322,6 +322,36 @@ NdbOperation::interpretedDeleteTuple()
		}//if
		}//NdbOperation::interpretedDeleteTuple()

		void
		NdbOperation::setReadLockMode(LockMode lockMode)
		{
		/* We only support changing lock mode for read operations at this time. */
		assert(theOperationType == ReadRequest \|\| theOperationType == ReadExclusive);
		switch (lockMode)
		{
		case LM_CommittedRead:
		theOperationType= ReadRequest;
		theSimpleIndicator= 1;
		theDirtyIndicator= 1;
		break;
		case LM_Read:
		theNdbCon->theSimpleState= 0;
		theOperationType= ReadRequest;
		theSimpleIndicator= 0;
		theDirtyIndicator= 0;
		break;
		case LM_Exclusive:
		theNdbCon->theSimpleState= 0;
		theOperationType= ReadExclusive;
		theSimpleIndicator= 0;
		theDirtyIndicator= 0;
		break;
		default:
		/* Not supported / invalid. */
		assert(false);
		}
		theLockMode= lockMode;
		}


		/******************************************************************************