mirror of
https://github.com/MariaDB/server.git
synced 2025-01-22 23:04:20 +01:00
528 lines
13 KiB
C++
528 lines
13 KiB
C++
/* Copyright (C) 2003 MySQL AB
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
#ifndef TC_INDX_H
|
|
#define TC_INDX_H
|
|
|
|
#include "SignalData.hpp"
|
|
|
|
class TcIndxReq {
|
|
/**
|
|
* Reciver(s)
|
|
*/
|
|
friend class Dbtc; // Reciver
|
|
|
|
/**
|
|
* Sender(s)
|
|
*/
|
|
friend class NdbIndexOperation;
|
|
|
|
/**
|
|
* For printing
|
|
*/
|
|
friend bool printTCINDXREQ(FILE *, const Uint32 *, Uint32, Uint16);
|
|
|
|
public:
|
|
/**
|
|
* Length of signal
|
|
*/
|
|
STATIC_CONST( StaticLength = 8 );
|
|
STATIC_CONST( SignalLength = 25 );
|
|
STATIC_CONST( MaxKeyInfo = 8 );
|
|
STATIC_CONST( MaxAttrInfo = 5 );
|
|
|
|
private:
|
|
|
|
enum CommitType {
|
|
CommitIfFailFree = 0,
|
|
TryCommit = 1,
|
|
CommitAsMuchAsPossible = 2
|
|
};
|
|
|
|
/**
|
|
* DATA VARIABLES
|
|
*/
|
|
//-------------------------------------------------------------
|
|
// Unconditional part. First 8 words
|
|
//-------------------------------------------------------------
|
|
UintR apiConnectPtr; // DATA 0
|
|
UintR senderData; // DATA 1
|
|
UintR attrLen; // DATA 2 (including API Version)
|
|
UintR indexId; // DATA 3
|
|
UintR requestInfo; // DATA 4
|
|
UintR indexSchemaVersion; // DATA 5
|
|
UintR transId1; // DATA 6
|
|
UintR transId2; // DATA 7
|
|
//-------------------------------------------------------------
|
|
// Conditional part. Those four words will be sent only if their
|
|
// indicator is set.
|
|
//-------------------------------------------------------------
|
|
UintR scanInfo; // DATA 8
|
|
UintR distrGroupHashValue; // DATA 9
|
|
UintR distributionKeySize; // DATA 10
|
|
UintR storedProcId; // DATA 11
|
|
|
|
//-------------------------------------------------------------
|
|
// Variable sized key and attrinfo part. Those will be placed to
|
|
// pack the signal in an appropriate manner.
|
|
//-------------------------------------------------------------
|
|
UintR keyInfo[MaxKeyInfo]; // DATA 12 - 19
|
|
UintR attrInfo[MaxAttrInfo]; // DATA 20 - 24
|
|
|
|
static Uint8 getAPIVersion(const UintR & attrLen);
|
|
|
|
/**
|
|
* Get:ers for requestInfo
|
|
*/
|
|
static Uint8 getCommitFlag(const UintR & requestInfo);
|
|
static Uint8 getCommitType(const UintR & requestInfo);
|
|
static Uint8 getStartFlag(const UintR & requestInfo);
|
|
static Uint8 getSimpleFlag(const UintR & requestInfo);
|
|
static Uint8 getDirtyFlag(const UintR & requestInfo);
|
|
static Uint8 getInterpretedFlag(const UintR & requestInfo);
|
|
static Uint8 getDistributionGroupFlag(const UintR & requestInfo);
|
|
static Uint8 getDistributionGroupTypeFlag(const UintR & requestInfo);
|
|
static Uint8 getDistributionKeyFlag(const UintR & requestInfo);
|
|
static Uint8 getScanIndFlag(const UintR & requestInfo);
|
|
|
|
static Uint8 getOperationType(const UintR & requestInfo);
|
|
|
|
static Uint16 getIndexLength(const UintR & requestInfo);
|
|
static Uint8 getAIInTcIndxReq(const UintR & requestInfo);
|
|
|
|
/**
|
|
* Get:ers for scanInfo
|
|
*/
|
|
|
|
static void setAPIVersion(UintR & attrLen, Uint16 apiVersion);
|
|
|
|
/**
|
|
* Set:ers for requestInfo
|
|
*/
|
|
static void clearRequestInfo(UintR & requestInfo);
|
|
static void setCommitType(UintR & requestInfo, Uint32 type);
|
|
static void setCommitFlag(UintR & requestInfo, Uint32 flag);
|
|
static void setStartFlag(UintR & requestInfo, Uint32 flag);
|
|
static void setSimpleFlag(UintR & requestInfo, Uint32 flag);
|
|
static void setDirtyFlag(UintR & requestInfo, Uint32 flag);
|
|
static void setInterpretedFlag(UintR & requestInfo, Uint32 flag);
|
|
static void setDistributionGroupFlag(UintR & requestInfo, Uint32 flag);
|
|
static void setDistributionGroupTypeFlag(UintR & requestInfo, Uint32 flag);
|
|
static void setDistributionKeyFlag(UintR & requestInfo, Uint32 flag);
|
|
static void setScanIndFlag(UintR & requestInfo, Uint32 flag);
|
|
|
|
static void setOperationType(UintR & requestInfo, Uint32 type);
|
|
|
|
static void setIndexLength(UintR & requestInfo, Uint32 len);
|
|
static void setAIInTcIndxReq(UintR & requestInfo, Uint32 len);
|
|
|
|
/**
|
|
* Set:ers for scanInfo
|
|
*/
|
|
|
|
};
|
|
|
|
#define API_VER_NO_SHIFT (16)
|
|
#define API_VER_NO_MASK (65535)
|
|
|
|
/**
|
|
* Request Info
|
|
*
|
|
a = Attr Info in TCINDXREQ - 3 Bits -> Max 7 (Bit 16-18)
|
|
b = Distribution Key Ind - 1 Bit 2
|
|
c = Commit Indicator - 1 Bit 4
|
|
d = Dirty Indicator - 1 Bit 0
|
|
e = Scan Indicator - 1 Bit 14
|
|
g = Distribution Group Ind - 1 Bit 1
|
|
i = Interpreted Indicator - 1 Bit 15
|
|
k = Index lengt - 12 Bits -> Max 4095 (Bit 20 - 31)
|
|
o = Operation Type - 3 Bits -> Max 7 (Bit 5-7)
|
|
p = Simple Indicator - 1 Bit 8
|
|
s = Start Indicator - 1 Bit 11
|
|
t = Distribution GroupType - 1 Bit 3
|
|
y = Commit Type - 2 Bit 12-13
|
|
x = Last Op in execute - 1 Bit 19
|
|
|
|
1111111111222222222233
|
|
01234567890123456789012345678901
|
|
dgbtcooop syyeiaaa-kkkkkkkkkkkk
|
|
*/
|
|
|
|
#define COMMIT_SHIFT (4)
|
|
#define START_SHIFT (11)
|
|
#define SIMPLE_SHIFT (8)
|
|
#define DIRTY_SHIFT (0)
|
|
#define INTERPRETED_SHIFT (15)
|
|
#define DISTR_GROUP_SHIFT (1)
|
|
#define DISTR_GROUP_TYPE_SHIFT (3)
|
|
#define DISTR_KEY_SHIFT (2)
|
|
#define SCAN_SHIFT (14)
|
|
|
|
#define OPERATION_SHIFT (5)
|
|
#define OPERATION_MASK (7)
|
|
|
|
#define AINFO_SHIFT (16)
|
|
#define AINFO_MASK (7)
|
|
|
|
#define INDEX_LEN_SHIFT (20)
|
|
#define INDEX_LEN_MASK (4095)
|
|
|
|
#define COMMIT_TYPE_SHIFT (12)
|
|
#define COMMIT_TYPE_MASK (3)
|
|
|
|
#define LAST_OP_IN_EXEC_SHIFT (19)
|
|
|
|
/**
|
|
* Scan Info
|
|
*
|
|
|
|
|
|
1111111111222222222233
|
|
01234567890123456789012345678901
|
|
|
|
*/
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getCommitFlag(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> COMMIT_SHIFT) & 1);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getCommitType(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> COMMIT_TYPE_SHIFT) & COMMIT_TYPE_MASK);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getStartFlag(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> START_SHIFT) & 1);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getSimpleFlag(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> SIMPLE_SHIFT) & 1);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getDirtyFlag(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> DIRTY_SHIFT) & 1);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getInterpretedFlag(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> INTERPRETED_SHIFT) & 1);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getDistributionGroupFlag(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> DISTR_GROUP_SHIFT) & 1);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getDistributionGroupTypeFlag(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> DISTR_GROUP_TYPE_SHIFT) & 1);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getDistributionKeyFlag(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> DISTR_KEY_SHIFT) & 1);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getScanIndFlag(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> SCAN_SHIFT) & 1);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getOperationType(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> OPERATION_SHIFT) & OPERATION_MASK);
|
|
}
|
|
|
|
inline
|
|
Uint16
|
|
TcIndxReq::getIndexLength(const UintR & requestInfo){
|
|
return (Uint16)((requestInfo >> INDEX_LEN_SHIFT) & INDEX_LEN_MASK);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getAIInTcIndxReq(const UintR & requestInfo){
|
|
return (Uint8)((requestInfo >> AINFO_SHIFT) & AINFO_MASK);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::clearRequestInfo(UintR & requestInfo){
|
|
requestInfo = 0;
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setCommitType(UintR & requestInfo, Uint32 type){
|
|
ASSERT_MAX(type, COMMIT_TYPE_MASK, "TcIndxReq::setCommitType");
|
|
requestInfo |= (type << COMMIT_TYPE_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setCommitFlag(UintR & requestInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxReq::setCommitFlag");
|
|
requestInfo &= ~(1 << COMMIT_SHIFT);
|
|
requestInfo |= (flag << COMMIT_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setStartFlag(UintR & requestInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxReq::setStartFlag");
|
|
requestInfo &= ~(1 << START_SHIFT);
|
|
requestInfo |= (flag << START_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setSimpleFlag(UintR & requestInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxReq::setSimpleFlag");
|
|
requestInfo &= ~(1 << SIMPLE_SHIFT);
|
|
requestInfo |= (flag << SIMPLE_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setDirtyFlag(UintR & requestInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxReq::setDirtyFlag");
|
|
requestInfo &= ~(1 << DIRTY_SHIFT);
|
|
requestInfo |= (flag << DIRTY_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setInterpretedFlag(UintR & requestInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxReq::setInterpretedFlag");
|
|
requestInfo &= ~(1 << INTERPRETED_SHIFT);
|
|
requestInfo |= (flag << INTERPRETED_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setDistributionGroupTypeFlag(UintR & requestInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxReq::setDistributionGroupTypeFlag");
|
|
requestInfo &= ~(1 << DISTR_GROUP_TYPE_SHIFT);
|
|
requestInfo |= (flag << DISTR_GROUP_TYPE_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setDistributionGroupFlag(UintR & requestInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxReq::setDistributionGroupFlag");
|
|
requestInfo &= ~(1 << DISTR_GROUP_SHIFT);
|
|
requestInfo |= (flag << DISTR_GROUP_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setDistributionKeyFlag(UintR & requestInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxReq::setDistributionKeyFlag");
|
|
requestInfo &= ~(1 << DISTR_KEY_SHIFT);
|
|
requestInfo |= (flag << DISTR_KEY_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setScanIndFlag(UintR & requestInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxReq::setScanIndFlag");
|
|
requestInfo &= ~(1 << SCAN_SHIFT);
|
|
requestInfo |= (flag << SCAN_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setOperationType(UintR & requestInfo, Uint32 type){
|
|
ASSERT_MAX(type, OPERATION_MASK, "TcIndxReq::setOperationType");
|
|
requestInfo |= (type << OPERATION_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setIndexLength(UintR & requestInfo, Uint32 len){
|
|
ASSERT_MAX(len, INDEX_LEN_MASK, "TcIndxReq::setKeyLength");
|
|
requestInfo |= (len << INDEX_LEN_SHIFT);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setAIInTcIndxReq(UintR & requestInfo, Uint32 len){
|
|
ASSERT_MAX(len, AINFO_MASK, "TcIndxReq::setAIInTcIndxReq");
|
|
requestInfo |= (len << AINFO_SHIFT);
|
|
}
|
|
|
|
inline
|
|
Uint8
|
|
TcIndxReq::getAPIVersion(const UintR & anAttrLen){
|
|
return (Uint16)((anAttrLen >> API_VER_NO_SHIFT) & API_VER_NO_MASK);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxReq::setAPIVersion(UintR & anAttrLen, Uint16 apiVersion){
|
|
// ASSERT_MAX(apiVersion, API_VER_NO_MASK, "TcIndxReq::setAPIVersion");
|
|
anAttrLen |= (apiVersion << API_VER_NO_SHIFT);
|
|
}
|
|
|
|
class TcIndxConf {
|
|
|
|
/**
|
|
* Reciver(s)
|
|
*/
|
|
friend class Ndb;
|
|
friend class NdbConnection;
|
|
|
|
/**
|
|
* Sender(s)
|
|
*/
|
|
friend class Dbtc;
|
|
|
|
/**
|
|
* For printing
|
|
*/
|
|
friend bool printTCINDXCONF(FILE *, const Uint32 *, Uint32, Uint16);
|
|
|
|
public:
|
|
/**
|
|
* Length of signal
|
|
*/
|
|
STATIC_CONST( SignalLength = 5 );
|
|
|
|
private:
|
|
/**
|
|
* DATA VARIABLES
|
|
*/
|
|
//-------------------------------------------------------------
|
|
// Unconditional part. First 5 words
|
|
//-------------------------------------------------------------
|
|
|
|
Uint32 apiConnectPtr;
|
|
Uint32 gci;
|
|
Uint32 confInfo;
|
|
Uint32 transId1;
|
|
Uint32 transId2;
|
|
|
|
struct OperationConf {
|
|
Uint32 apiOperationPtr;
|
|
Uint32 attrInfoLen;
|
|
};
|
|
//-------------------------------------------------------------
|
|
// Operations confirmations,
|
|
// No of actually sent = getNoOfOperations(confInfo)
|
|
//-------------------------------------------------------------
|
|
OperationConf operations[10];
|
|
|
|
/**
|
|
* Get:ers for confInfo
|
|
*/
|
|
static Uint32 getNoOfOperations(const Uint32 & confInfo);
|
|
static Uint32 getCommitFlag(const Uint32 & confInfo);
|
|
static bool getMarkerFlag(const Uint32 & confInfo);
|
|
|
|
/**
|
|
* Set:ers for confInfo
|
|
*/
|
|
static void setCommitFlag(Uint32 & confInfo, Uint8 flag);
|
|
static void setNoOfOperations(Uint32 & confInfo, Uint32 noOfOps);
|
|
static void setMarkerFlag(Uint32 & confInfo, Uint32 flag);
|
|
};
|
|
|
|
inline
|
|
Uint32
|
|
TcIndxConf::getNoOfOperations(const Uint32 & confInfo){
|
|
return confInfo & 65535;
|
|
}
|
|
|
|
inline
|
|
Uint32
|
|
TcIndxConf::getCommitFlag(const Uint32 & confInfo){
|
|
return ((confInfo >> 16) & 1);
|
|
}
|
|
|
|
inline
|
|
bool
|
|
TcIndxConf::getMarkerFlag(const Uint32 & confInfo){
|
|
const Uint32 bits = 3 << 16; // Marker only valid when doing commit
|
|
return (confInfo & bits) == bits;
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxConf::setNoOfOperations(Uint32 & confInfo, Uint32 noOfOps){
|
|
ASSERT_MAX(noOfOps, 65535, "TcIndxConf::setNoOfOperations");
|
|
confInfo |= noOfOps;
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxConf::setCommitFlag(Uint32 & confInfo, Uint8 flag){
|
|
ASSERT_BOOL(flag, "TcIndxConf::setCommitFlag");
|
|
confInfo |= (flag << 16);
|
|
}
|
|
|
|
inline
|
|
void
|
|
TcIndxConf::setMarkerFlag(Uint32 & confInfo, Uint32 flag){
|
|
ASSERT_BOOL(flag, "TcIndxConf::setMarkerFlag");
|
|
confInfo |= (flag << 17);
|
|
}
|
|
|
|
class TcIndxRef {
|
|
|
|
/**
|
|
* Reciver(s)
|
|
*/
|
|
friend class NdbIndexOperation;
|
|
|
|
/**
|
|
* Sender(s)
|
|
*/
|
|
friend class Dbtc;
|
|
|
|
/**
|
|
* For printing
|
|
*/
|
|
friend bool printTCINDXREF(FILE *, const Uint32 *, Uint32, Uint16);
|
|
|
|
public:
|
|
/**
|
|
* Length of signal
|
|
*/
|
|
public:
|
|
STATIC_CONST( SignalLength = 4 );
|
|
|
|
private:
|
|
Uint32 connectPtr;
|
|
Uint32 transId[2];
|
|
Uint32 errorCode;
|
|
};
|
|
|
|
#endif
|