gStore/KVstore/tree/Tree.cpp

/*=============================================================================
# Filename: Tree.cpp
# Author: syzz
# Mail: 1181955272@qq.com
# Last Modified: 2015-04-26 16:45
# Description: achieve functions in Tree.h
=============================================================================*/

#include "Tree.h"
using namespace std;

//tree's operations should be atom(if read nodes)
//sum the request and send to Storage at last
//ensure that all nodes operated are in memory
int request = 0;

Tree::Tree()
{
	height = 0;
	mode = "";
	root = NULL;
	leaves_head = NULL;
	leaves_tail = NULL;
	TSM = NULL;
	storepath = "";
	filename = "";
	transfer_size[0] = transfer_size[1] = transfer_size[2] = 0;
}

Tree::Tree(const string& _storepath, const string& _filename, const char* _mode)
{
	storepath = _storepath;
	filename = _filename;
	this->height = 0;
	this->mode = string(_mode);
	string filepath = this->getFilePath();
	TSM = new Storage(filepath, this->mode, &this->height);
	if(this->mode == "open")
		this->TSM->preRead(this->root, this->leaves_head, this->leaves_tail);
	else
		this->root = NULL;
	this->transfer[0].setStr((char*)malloc(1 << 20));
	this->transfer[1].setStr((char*)malloc(1 << 20));
	this->transfer[2].setStr((char*)malloc(1 << 20));
	this->transfer_size[0] = this->transfer_size[1] = this->transfer_size[2] = 1 << 20;	//initialied to 1M
}

string
Tree::getFilePath()
{
	return storepath+"/"+filename;
}

void			//WARN: not check _str and _len
Tree::CopyToTransfer(const char* _str, unsigned _len, unsigned _index)
{
	if(_index > 2)
		return;
	/*
	if(_str == NULL || _len == 0)
	{
		printf("error in CopyToTransfer: empty string\n");
		return;
	}
	*/
	//unsigned length = _bstr->getLen();
	unsigned length = _len;
	if(length + 1 > this->transfer_size[_index])
	{
		transfer[_index].release();
		transfer[_index].setStr((char*)malloc(length+1));
		this->transfer_size[_index] = length + 1;	//one more byte: convenient to add \0
	}
	memcpy(this->transfer[_index].getStr(), _str, length);
	this->transfer[_index].getStr()[length] = '\0';	//set for string() in KVstore
	this->transfer[_index].setLen(length);
}

unsigned 
Tree::getHeight() const
{
	return this->height;
}

void
Tree::setHeight(unsigned _h)
{
	this->height = _h;
}

Node*
Tree::getRoot() const
{
	return this->root;
}

void
Tree::prepare(Node* _np) const
{
	bool flag = _np->inMem();
	if(!flag)
		this->TSM->readNode(_np, &request);	//readNode deal with request
}

bool
Tree::search(const char* _str1, unsigned _len1, char*& _str2, int& _len2)
{
	const TBstr* value = NULL;
	if(_str1 == NULL || _len1 == 0)
	{
		printf("error in Tree-search: empty string\n");
		return false;
	}
	this->CopyToTransfer(_str1, _len1, 1);
	bool ret = this->search(&transfer[1], value);
	if(ret)
	{
		_str2 = value->getStr();
		_len2 = value->getLen();
	}
	return ret;
}

bool
Tree::search(const TBstr* _key, const TBstr*& _value)
{
	request = 0;
	TBstr bstr = *_key;	//not to modify its memory
	int store;	
	Node* ret = this->find(_key, &store, false);
	if(ret == NULL || store == -1 || bstr != *(ret->getKey(store)))	//tree is empty or not found
	{
		bstr.clear();
		return false;
	}
	const TBstr* val = ret->getValue(store);
	this->CopyToTransfer(val->getStr(), val->getLen(), 0);		//not sum to request
	_value = &transfer[0];
	this->TSM->request(request);
	bstr.clear();
	return true;
}

bool
Tree::insert(const char* _str1, unsigned _len1, const char* _str2, unsigned _len2)
{
	if(_str1 == NULL || _len1 == 0)
	{
		printf("error in Tree-insert: empty string\n");
		return false;
	}
	this->CopyToTransfer(_str1, _len1, 1);
	this->CopyToTransfer(_str2, _len2, 2);	//not check value
	bool ret = this->insert(&transfer[1], &transfer[2]);	
	return ret;
}

bool
Tree::insert(const TBstr* _key, const TBstr* _value)
{
	request = 0;
	Node* ret;
	if(this->root == NULL)	//tree is empty
	{
		leaves_tail = leaves_head = root = new LeafNode;
		request += Node::LEAF_SIZE;
		this->height = 1;
		root->setHeight(1);	//add to heap later
	}
	//this->prepare(this->root); //root must be in-mem
	if(root->getNum() == Node::MAX_KEY_NUM)
	{
		Node* father = new IntlNode;
		request += Node::INTL_SIZE;
		father->addChild(root, 0);
		ret = root->split(father, 0);
		if(ret->isLeaf() && ret->getNext() == NULL)
			this->leaves_tail = ret;
		if(ret->isLeaf())
			request += Node::LEAF_SIZE;
		else
			request += Node::INTL_SIZE;
		this->height++;		//height rises only when root splits
		//WARN: height area in Node: 4 bit!
		father->setHeight(this->height);	//add to heap later
		this->TSM->updateHeap(ret, ret->getRank(), false);
		this->root = father;
	}
	Node* p = this->root;
	Node* q;
	int i, j;
	TBstr bstr = *_key;
	while(!p->isLeaf())
	{
		j = p->getNum();
		for(i = 0; i < j; ++i)
			if(bstr < *(p->getKey(i)))
				break;
		q = p->getChild(i);
		this->prepare(q);
		if(q->getNum() == Node::MAX_KEY_NUM)
		{
			ret = q->split(p, i);
			if(ret->isLeaf() && ret->getNext() == NULL)
				this->leaves_tail = ret;
			if(ret->isLeaf())
				request += Node::LEAF_SIZE;
			else
				request += Node::INTL_SIZE;
			//BETTER: in loop may update multiple times
			this->TSM->updateHeap(ret, ret->getRank(), false);
			this->TSM->updateHeap(q, q->getRank(), true);
			this->TSM->updateHeap(p, p->getRank(), true);
			if(bstr < *(p->getKey(i)))
				p = q;
			else 
				p = ret;
		}
		else
		{
			p->setDirty();
			this->TSM->updateHeap(p, p->getRank(), true);
			p = q;
		}
	}
	j = p->getNum();
	for(i = 0; i < j; ++i)
		if(bstr < *(p->getKey(i)))
			break;
	//insert existing key is ok, but not inserted in
	//however, the tree-shape may change due to possible split in former code
	bool ifexist = false;
	if(i > 0 && bstr == *(p->getKey(i-1)))
		ifexist = true;
	else
	{
		p->addKey(_key, i, true);
		p->addValue(_value, i, true);
		p->addNum();
		request += (_key->getLen() + _value->getLen());
		p->setDirty();
		this->TSM->updateHeap(p, p->getRank(), true);
		//_key->clear();
		//_value->clear();
	}
	this->TSM->request(request);
	bstr.clear();		//NOTICE: must be cleared!
	return !ifexist;		//QUERY(which case:return false)
}

bool
Tree::modify(const char* _str1, unsigned _len1, const char* _str2, unsigned _len2)
{
	if(_str1 == NULL || _len1 == 0)
	{
		printf("error in Tree-modify: empty string\n");
		return false;
	}
	this->CopyToTransfer(_str1, _len1, 1);
	this->CopyToTransfer(_str2, _len2, 2);	//not check value
	bool ret = this->modify(&transfer[1], &transfer[2]);
	return ret;
}

bool
Tree::modify(const TBstr* _key, const TBstr* _value)
{					
	request = 0;
	TBstr bstr = *_key;
	int store;
	Node* ret = this->find(_key, &store, true);
	if(ret == NULL || store == -1 || bstr != *(ret->getKey(store)))	//tree is empty or not found
	{
		bstr.clear();
		return false;
	}
	unsigned len = ret->getValue(store)->getLen();
	ret->setValue(_value, store, true);
	request += (_value->getLen()-len);
	//_value->clear();
	ret->setDirty();
	this->TSM->request(request);
	bstr.clear();
	return true;
}

/* this function is useful for search and modify, and range-query */
Node*		//return the first key's position that >= *_key
Tree::find(const TBstr* _key, int* _store, bool ifmodify) const
{											//to assign value for this->bstr, function shouldn't be const!
	if(this->root == NULL)
		return NULL;						//Tree Is Empty
	Node* p = root;
	int i, j;
	TBstr bstr = *_key;					//local Bstr: multiple delete
	while(!p->isLeaf())
	{
		if(ifmodify)
			p->setDirty();
		j = p->getNum();
		for(i = 0; i < j; ++i)				//BETTER(Binary-Search)
			if(bstr < *(p->getKey(i)))
				break;
		p = p->getChild(i);
		this->prepare(p);
	}
	j = p->getNum();
	for(i = 0; i < j; ++i)
		if(bstr <= *(p->getKey(i)))
			break;
	if(i == j)
		*_store = -1;	//Not Found
	else	
		*_store = i;
	bstr.clear();
	return p;
}

/*
Node*
Tree::find(unsigned _len, const char* _str, int* store) const
{
}
*/

bool
Tree::remove(const char* _str, unsigned _len)
{
	if(_str == NULL || _len == 0)
	{
		printf("error in Tree-remove: empty string\n");
		return false;
	}
	this->CopyToTransfer(_str, _len, 1);
	bool ret = this->remove(&transfer[1]);
	return ret;
}

bool	//BETTER: if not found, the road are also dirty! find first?
Tree::remove(const TBstr* _key)
{
	request = 0;
	Node* ret;
	if(this->root == NULL)	//tree is empty
		return false;
	Node* p = this->root;
	Node* q;
	int i, j;
	TBstr bstr = *_key;
	while(!p->isLeaf())
	{
		j = p->getNum();
		for(i = 0; i < j; ++i)
			if(bstr < *(p->getKey(i)))
				break;
		q = p->getChild(i);
		this->prepare(q);
		if(q->getNum() < Node::MIN_CHILD_NUM)	//==MIN_KEY_NUM
		{
			if(i > 0)
				this->prepare(p->getChild(i-1));
			if(i < j)
				this->prepare(p->getChild(i+1));
			ret = q->coalesce(p, i);
			if(ret != NULL)
				this->TSM->updateHeap(ret, 0, true);//non-sense node
			this->TSM->updateHeap(q, q->getRank(), true);
			if(q->isLeaf())
			{
				if(q->getPrev() == NULL)
					this->leaves_head = q;
				if(q->getNext() == NULL)
					this->leaves_tail = q;
			}
			if(p->getNum() == 0)		//root shrinks
			{
				//this->leaves_head = q;
				this->root = q;
				this->TSM->updateHeap(p, 0, true);	//instead of delete p				
				this->height--;
			}
		}
		else 
			p->setDirty();
		this->TSM->updateHeap(p, p->getRank(), true);
		p = q;
	}
	bool flag = false;
	j = p->getNum();		//LeafNode(maybe root)
	for(i = 0; i < j; ++i)
		if(bstr == *(p->getKey(i)))
		{
			request -= p->getKey(i)->getLen();
			request -= p->getValue(i)->getLen();
			p->subKey(i, true);		//to release
			p->subValue(i, true);	//to release
			p->subNum();
			if(p->getNum() == 0)	//root leaf 0 key
			{
				this->root = NULL;
				this->leaves_head = NULL;
				this->leaves_tail = NULL;
				this->height = 0;
				this->TSM->updateHeap(p, 0, true);	//instead of delete p
			}
			p->setDirty();
			flag = true;
			break;
		}
	this->TSM->request(request);
	bstr.clear();
	return flag;		//i == j, not found		
}

const TBstr*
Tree::getRangeValue()
{
	return this->VALUES.read();
}

bool	//special case: not exist, one-edge-case
Tree::range_query(const TBstr* _key1, const TBstr* _key2)
{		//the range is: *_key1 <= x < *_key2 	
	/*
	if(_key1 == NULL && _key2 == NULL)
		return false;
		*/
	//ok to search one-edge, requiring only one be NULL
	this->VALUES.open();
	/* find and write value */
	int store1, store2;
	Node *p1, *p2;
	if(_key1 != NULL)
	{
		request = 0;
		p1 = this->find(_key1, &store1, false);
		if(p1 == NULL || store1 == -1)
			return false;	//no element
		this->TSM->request(request);
	}
	else
	{
		p1 = this->leaves_head;
		store1 = 0;
	}
	if(_key2 != NULL)
	{		//QUERY: another strategy is to getnext and compare every time to tell end
		request = 0;
		p2 = this->find(_key2, &store2, false);
		if(p2 == NULL)
			return false;
		else if(store2 == -1)
			store2 = p2->getNum();
		else if(store2 == 0)
		{
			p2 = p2->getPrev();
			if(p2 == NULL)
				return false;		//no element
			store2 = p2->getNum();
		}
		this->TSM->request(request);
	}
	else
	{
		p2 = this->leaves_tail;
		store2 = p2->getNum();
	}

	Node* p = p1;
	unsigned i, l, r;
	while(1)
	{
		request = 0;
		this->prepare(p);
		if(p == p1)
			l = store1;
		else
			l = 0;
		if(p == p2)
			r = store2;
		else
			r = p->getNum();
		for(i = l; i < r; ++i)
			this->VALUES.write(p->getValue(i));
		this->TSM->request(request);
		if(p != p2)
			p = p->getNext();
		else
			break;
	}
	this->VALUES.reset();
	return true;
}

bool 
Tree::save()	//save the whole tree to disk
{
	if(TSM->writeTree(this->root))
		return true;
	else
		return false;
}

void
Tree::release(Node* _np) const
{
	if(_np == NULL)	return;
	if(_np->isLeaf())
	{
		delete _np;
		return;
	}
	int cnt = _np->getNum();
	for(; cnt >= 0; --cnt)
		release(_np->getChild(cnt));
	delete _np;
}

Tree::~Tree()
{
	//delete VALUES;
	delete TSM;
	//recursively delete each Node
	release(root);
}

void
Tree::print(string s)
{
#ifdef DEBUG
	Util::showtime();
	fputs("Class Tree\n", Util::logsfp);
	fputs("Message: ", Util::logsfp);
	fputs(s.c_str(), Util::logsfp);
	fputs("\n", Util::logsfp);
	fprintf(Util::logsfp, "Height: %d\n", this->height);
	if(s == "tree" || s == "TREE")
	{
		if(this->root == NULL)
		{
			fputs("Null Tree\n", Util::logsfp);
			return;
		}
		Node** ns = new Node*[this->height];
		int* ni = new int[this->height];
		Node* np;
		int i, pos = 0;
		ns[pos] = this->root;
		ni[pos] = this->root->getNum();
		pos++;
		while(pos > 0)
		{
			np = ns[pos-1];
			i = ni[pos-1];
			this->prepare(np);
			if(np->isLeaf() || i < 0)	//LeafNode or ready IntlNode
			{							//child-num ranges: 0~num
				if(s == "tree")
					np->print("node");
				else
					np->print("NODE");	//print full node-information
				pos--;
				continue;
			}
			else
			{
				ns[pos] = np->getChild(i);
				ni[pos-1]--;
				ni[pos] = ns[pos]->getNum();
				pos++;
			}
		}
		delete[] ns;
		delete[] ni;
	}
	else if(s == "LEAVES" || s == "leaves")
	{
		Node* np;
		for(np = this->leaves_head; np != NULL; np = np->getNext())
		{
			this->prepare(np);
			if(s == "leaves")
				np->print("node");
			else
				np->print("NODE");
		}
	}
	else if(s == "check tree")
	{
		//check the tree, if satisfy B+ definition
		//TODO	
	}
	else;
#endif
}