int
CatalogManager::new_table_def(Node* node)
{
Node *tablePtr = cm_catNodeMgr.newCopyDataNode(node);
tablePtr->leftSon = cm_catRoot->leftSon;
cm_catRoot->leftSon = tablePtr;
++cm_catRoot->numval;
Node *insertPtr = node->leftSon;
Node *columnPtr = nullptr;
int columnCount = 0;
while (insertPtr != nullptr)
{
columnPtr = cm_catNodeMgr.newCopyDataNode(insertPtr);
if (insertPtr->rightSon != nullptr)
{
columnPtr->rightSon = cm_catNodeMgr.newCopyDataNode(insertPtr->rightSon);
}
columnPtr->leftSon = tablePtr->rightSon;
tablePtr->rightSon = columnPtr;
insertPtr = insertPtr->leftSon;
++columnCount;
}
// build file
string tmpStr(node->strval);
tmpStr += ".db";
BufferManager* bufmgr = BufferManager::getInstance();
bufmgr->createFile(tmpStr.c_str());
Pager* page = bufmgr->getPager(tmpStr.c_str());
unsigned char* block = bufmgr->newblock(page, BUFFER_FLAG_DIRTY);
int* blockData = (int*)(block+16*sizeof(char));
int* blockVarType = blockData + 5;
int* blockVarLen = blockVarType + columnCount;
strncpy((char*)block, "MINISQL v0.01", 16*sizeof(char));
blockData[0] = 1;
blockData[1] = 0;
blockData[2] = 0;
blockData[3] = sizeof(char)*16+sizeof(int)*(5+2*columnCount);
blockData[4] = columnCount;
insertPtr = node->leftSon;
for (int i = columnCount-1; i >=0 ; --i)
{
blockVarType[i] = insertPtr->operation;
blockVarLen[i] = (insertPtr->operation == VAL_CHAR)? insertPtr->numval: 4;
insertPtr = insertPtr->leftSon;
}
return 0;
}
int
CatalogManager::new_index_def(char* tableName, char* columnName, char* indexName)
{
Node *ptr = cm_catRoot->leftSon;
Node *tmpPtr = nullptr;
string tmpStr(tableName);
tmpStr += "_";
tmpStr += columnName;
tmpStr += ".idx";
BufferManager* bufmgr = BufferManager::getInstance();
IDXFileHeader idxHeader;
strncpy(idxHeader.Header_string, "MINISQL v0.01", 16*sizeof(char));
while (ptr != nullptr)
{
if (strcmp(tableName, ptr->strval) == 0)
{
ptr = ptr->rightSon;
while (ptr != nullptr)
{
if (strcmp(columnName, ptr->strval) == 0)
{
if(ptr->operation == VAL_CHAR){
idxHeader.Type = IDX_TYPE_STRING;
idxHeader.Val_size = ptr->numval;
}
else if(ptr->operation == VAL_FLOAT){
idxHeader.Type = IDX_TYPE_FLOAT;
idxHeader.Val_size = sizeof(float);
}
else if(ptr->operation == VAL_INT){
idxHeader.Type = IDX_TYPE_INT;
idxHeader.Val_size = sizeof(int);
}
idxHeader.N_freepages = 0;
idxHeader.Free_list = IDX_FLAG_NONPAGE;
idxHeader.Root = IDX_FLAG_NOROOT;
idxHeader.Degree = (BLOCK_SIZE - IDX_FILEHEADER_SIZE - IDX_BLOCKHEADER_SIZE) / (idxHeader.Val_size + IDX_LEFTPTR_SIZE);
ptr = ptr->rightSon;
tmpPtr = cm_catNodeMgr.newEmptyNode();
STRDUP_NEW(tmpPtr->strval, indexName);
if (/*ptr!=nullptr && */ptr->rightSon != nullptr)
{
tmpPtr->rightSon = ptr->rightSon;
ptr->rightSon = tmpPtr;
return 1;
}
else
{
bufmgr->createFile(tmpStr.c_str());
Pager* page = bufmgr->getPager(tmpStr.c_str());
unsigned char* block = bufmgr->newblock(page, BUFFER_FLAG_DIRTY);
memcpy(block, &idxHeader, IDX_FILEHEADER_SIZE);
ptr->rightSon = tmpPtr;
return 0;
}
}
ptr = ptr->leftSon;
}
}
ptr = ptr->leftSon;
}
exit(-1);
}
CatalogManager::~CatalogManager()
{
size_t const_offset = sizeof(int)*5 + sizeof(double) + CAT_NAME_MAXSIZE;
size_t var_offset=0;
Node* node = cm_catRoot;
int nodeCount=0;
NodePosMap nodeMap;
vector<Node*> tStack;
while(node!=nullptr||!tStack.empty()) {
if(node!=nullptr) {
nodeMap[node] = nodeCount++;
if(node->rightSon!=nullptr) {
tStack.push_back(node->rightSon);
}
node = node->leftSon;
}
else {
node = tStack.back();
tStack.pop_back();
}
}
BufferManager* bufmgr = BufferManager::getInstance();
unsigned char* block;
Pager* pager = bufmgr->getPager("minisql.frm");
int blockNumber, blockOffset, nodePerBlock;
BlockPtr bPtr;
nodePerBlock = BLOCK_SIZE / const_offset;
node = cm_catRoot;
while( node!=nullptr || !tStack.empty() ) {
if(node!=nullptr) {
blockNumber = nodeMap[node] / nodePerBlock;
blockOffset = (nodeMap[node]%nodePerBlock)*const_offset;
while(blockNumber>=pager->getNPages()) {
bufmgr->newblock(pager, BUFFER_FLAG_NONDIRTY);
}
block = bufmgr->getblock(pager, blockNumber, BUFFER_FLAG_DIRTY);
if(node->leftSon) {
bPtr.lBlock = nodeMap[node->leftSon] / nodePerBlock;
bPtr.lOffset = (nodeMap[node->leftSon]%nodePerBlock)*const_offset;
}
else {
bPtr.lBlock = bPtr.lOffset = CAT_FLAG_NONBLOCK;
}
if(node->rightSon) {
bPtr.rBlock = nodeMap[node->rightSon] / nodePerBlock;
bPtr.rOffset = (nodeMap[node->rightSon]%nodePerBlock)*const_offset;
}
else {
bPtr.rBlock = bPtr.rOffset = CAT_FLAG_NONBLOCK;
}
var_offset = blockOffset;
memcpy(block + var_offset, &node->operation, sizeof(int)); var_offset+=sizeof(int);
if(node->strval){
memcpy(block + var_offset, node->strval, CAT_NAME_MAXSIZE); var_offset+=CAT_NAME_MAXSIZE;
}
else{ memset(block + var_offset, 0, CAT_NAME_MAXSIZE); var_offset += CAT_NAME_MAXSIZE;
}
memcpy(block + var_offset, &node->numval, sizeof(double)); var_offset+=sizeof(double);
memcpy(block + var_offset, &bPtr, sizeof(BlockPtr));
if(node->rightSon!=nullptr) {
tStack.push_back(node->rightSon);
}
node = node->leftSon;
}
else {
node = tStack.back();
tStack.pop_back();
}
}
cm_catNodeMgr.clean();
m_columndef.clean();
}
