bool Bucket::Hidratate(ByteString &bytesString){
bool success = true;
if(int(bytesString.getSize()) != capacity)
{
success = false;
}
else
{
//si tenia registros los borro
this->toEmpty();
//Obtiene la Metadata
dispersionNumber = bytesString.readAsInt(0);
//Obtiene los registros
Record* record = NULL;
ByteString recordBytesString;
int position = 1*sizeof(int);
int recordSize = bytesString.readAsInt(1*sizeof(int));
while(recordSize > 0)
{
record = new Record();
recordBytesString = bytesString.read(position,recordSize);
record->Hidratate(recordBytesString);
success = this->insertRecord(record);
position = position + recordSize;
//Valida que quede el minimo recordSize que puede tener un registro
if(position <= capacity - Record::getMinSize())
recordSize = bytesString.readAsInt(position);
else
recordSize = -1;
}
}
return success;
}
void BPlusTree::exportNode(ofstream& salida, Node* unNodo, int tabulacion,bool keyText,bool textContent) {
if (unNodo->isLeaf()) {
LeafNode *unNodoHoja = static_cast<LeafNode*> (unNodo);
salida << endl;
for(int i = 0 ; i < tabulacion ; i++)
salida << " ";
salida << "Numero: " << unNodoHoja->number << " Nivel: " << unNodoHoja->level << " Cant.Elem: " << unNodoHoja->keyMount
<< " Esp.Libre: " << TreeConstraits::getEfectiveSizeNode() - unNodoHoja->occupiedSpace << " Hoja.Sig: " << unNodoHoja->nextLeaf << endl;
for (int posicion = 0; posicion < unNodoHoja->keyMount; ++posicion) {
for(int i = 0 ; i < tabulacion + 4 ; i++)
salida << " ";
salida << "(";
Key unaClave = unNodoHoja->keys[posicion];
if(keyText)
{
salida << unaClave.toString();
}
else
{
ByteString clave(unaClave.toString());
salida << Utility::toString(clave.readAsInt(0));
}
salida << ";";
ByteString unDato = unNodoHoja->byteData[posicion];
if(textContent)
{
salida << unDato.toString();
}
else
{
salida << Utility::intToString(unDato.readAsInt(0));
}
salida << ")";
salida << (unaClave.getSize() + unDato.getSize() + TreeConstraits::getControlSizeRecord()) << endl;
}
salida << endl;
} else {
InnerNode *unNodoInterior = static_cast<InnerNode*> (unNodo);
salida << endl << endl;
for(int i=0; i<tabulacion ; i++)
salida << " ";
salida << "Numero: " << unNodoInterior->number << " Nivel: " << unNodoInterior->level << " Cant.Elem: " << unNodoInterior->keyMount
<< " Esp.Libre: " << TreeConstraits::getEfectiveSizeNode() - unNodoInterior->occupiedSpace << endl;
for (int posicion = 0; posicion <= unNodoInterior->keyMount; ++posicion) {
if (posicion < unNodoInterior->keyMount) {
Key unaClave = unNodoInterior->keys[posicion];
for(int i=0; i<(tabulacion+1) ; i++)
salida << " ";
salida << "(";
if(keyText)
{
salida << unaClave.toString();
}
else
{
ByteString clave(unaClave.toString());
salida << Utility::toString(clave.readAsInt(0));
}
salida << ")";
salida << unaClave.getSize();
salida << " ";
salida << unNodoInterior->getSons()[posicion] << " ";
}
}
for (int posicion = 0; posicion <= unNodoInterior->keyMount; ++posicion) {
Node *hijo = hidratateNode(unNodoInterior->sons[posicion]);
exportNode(salida, hijo, tabulacion + 2,keyText,textContent);
if (hijo)
freeNodeMemory(hijo);
}
for(int i=0; i<tabulacion ; i++)
salida << " ";
salida << endl;
}
}
bool BPlusTree::recursiveInsert(Node* nodoCorriente, Key clave, ByteString dato, Key* clavePromocion, Node** nuevoNodo) {
if (!nodoCorriente->isLeaf()) {
InnerNode *nodoInteriorCorriente = static_cast<InnerNode*> (nodoCorriente);
Key nuevaClave;
Node* nuevoNodoHijo = NULL;
int posicion = getPosition(nodoInteriorCorriente, clave);
Node* nodoHijo = hidratateNode(nodoInteriorCorriente->sons[posicion]);
bool resultado = recursiveInsert(nodoHijo, clave, dato, &nuevaClave, &nuevoNodoHijo);
if (nuevoNodoHijo) {
if (nodoInteriorCorriente->isOverflow(nuevaClave.getSize() + TreeConstraits::getControlSizeRecord() + keyTopSize)) {
splitInnerNode(nodoInteriorCorriente, clavePromocion, nuevoNodo, posicion);
if (posicion == nodoInteriorCorriente->keyMount + 1
&& nodoInteriorCorriente->keyMount < (*nuevoNodo)->keyMount) {
InnerNode *nuevoNodoInterior = static_cast<InnerNode*> (*nuevoNodo);
nodoInteriorCorriente->keys[nodoInteriorCorriente->keyMount] = *clavePromocion;
nodoInteriorCorriente->sons[nodoInteriorCorriente->keyMount + 1] = nuevoNodoInterior->sons[0];
nodoInteriorCorriente->keyMount++;
nodoInteriorCorriente->occupiedSpace += (*clavePromocion).getSize() + TreeConstraits::getControlSizeRecord();
nuevoNodoInterior->sons[0] = nuevoNodoHijo->number;
*clavePromocion = nuevaClave;
persistNode(nuevoNodoHijo);
freeNodeMemory(nuevoNodoHijo);
persistNode(nodoHijo);
freeNodeMemory(nodoHijo);
return resultado;
} else {
if (posicion >= nodoInteriorCorriente->keyMount + 1) {
posicion -= (nodoInteriorCorriente->keyMount + 1);
nodoInteriorCorriente = static_cast<InnerNode*> (*nuevoNodo);
}
}
}
int i = nodoInteriorCorriente->keyMount;
while (i > posicion) {
nodoInteriorCorriente->keys[i] = nodoInteriorCorriente->keys[i - 1];
nodoInteriorCorriente->sons[i + 1] = nodoInteriorCorriente->sons[i];
i--;
}
nodoInteriorCorriente->keys[posicion] = nuevaClave;
nodoInteriorCorriente->sons[posicion + 1] = nuevoNodoHijo->number;
nodoInteriorCorriente->keyMount++;
nodoInteriorCorriente->occupiedSpace += nuevaClave.getSize() + TreeConstraits::getControlSizeRecord();
persistNode(nuevoNodoHijo);
freeNodeMemory(nuevoNodoHijo);
}
persistNode(nodoHijo);
freeNodeMemory(nodoHijo);
return resultado;
} else {
LeafNode *nodoHojaCorriente = static_cast<LeafNode*> (nodoCorriente);
int posicion = getPosition(nodoHojaCorriente, clave);
// chequea que no exista la clave
if (posicion < nodoHojaCorriente->keyMount && equalKey(clave, nodoHojaCorriente->keys[posicion])) {
return false;
}
int i = nodoHojaCorriente->keyMount - 1;
while (i >= 0 && minorKey(clave, nodoHojaCorriente->keys[i])) {
nodoHojaCorriente->keys[i + 1] = nodoHojaCorriente->keys[i];
nodoHojaCorriente->byteData[i + 1] = nodoHojaCorriente->byteData[i];
i--;
}
nodoHojaCorriente->keys[i + 1] = clave;
nodoHojaCorriente->byteData[i + 1] = dato;
nodoHojaCorriente->keyMount++;
nodoHojaCorriente->occupiedSpace += dato.getSize() + clave.getSize() + TreeConstraits::getControlSizeRecord();
if (nodoHojaCorriente->isOverflow(keyTopSize)) {
splitLeafNode(nodoHojaCorriente, clavePromocion, nuevoNodo);
if (posicion >= nodoHojaCorriente->keyMount) {
posicion -= nodoHojaCorriente->keyMount;
nodoHojaCorriente = static_cast<LeafNode*> (*nuevoNodo);
}
}
if (nuevoNodo && nodoHojaCorriente != *nuevoNodo && posicion == nodoHojaCorriente->keyMount - 1) {
*clavePromocion = clave;
}
return true;
}
}
void ClassifBPlusTree::exportNode(ofstream& salida, Node* unNodo, int tabulacion,bool keytext, bool textContent) {
if (unNodo->isLeaf()) {
LeafNode *unNodoHoja = static_cast<LeafNode*> (unNodo);
salida << endl;
for(int i = 0 ; i < tabulacion ; i++)
salida << " ";
salida << "Numero: " << unNodoHoja->number << " Nivel: " << unNodoHoja->level << " Cant.Elem: " << unNodoHoja->keyMount << " Esp.Libre: " << TreeConstraits::getEfectiveSizeNode() - unNodoHoja->occupiedSpace << " Hoja.Sig: " << unNodoHoja->nextLeaf << endl;
for (int posicion = 0; posicion < unNodoHoja->keyMount; ++posicion) {
for(int i = 0 ; i < tabulacion + 4 ; i++)
salida << " ";
salida << "(";
Key unaClave = unNodoHoja->keys[posicion];
if(keytext)
{
salida << unaClave.toString();
}
else
{
ByteString clave(unaClave.toString());
if(clave.getSize()==(2*sizeof(int)))
{
salida << Utility::toString(clave.readAsInt(0));
salida << "-";
salida << Utility::toString(clave.readAsInt(sizeof(int)));
}
else
salida << Utility::toString(clave.readAsInt(0));
}
salida << ";";
ByteString unDato = unNodoHoja->byteData[posicion];
int idBlock = unDato.readAsInt(0);
string datoString = Utility::intToString(idBlock);
salida << datoString;
salida << ")";
salida << (unaClave.getSize() + unDato.getSize() + TreeConstraits::getControlSizeRecord()) << endl;
for(int i = 0 ; i < tabulacion + 4 ; i++)
salida << " ";
ListofID listOfID(this->fileBlockManager,idBlock);
list<int> listOfInt = listOfID.getListID();
list<int>::iterator it;
int id;
//int count = 0;
ByteString bs;
unsigned int i = 0;
for(it=listOfInt.begin();it!=listOfInt.end();++it)
{
i++;
id = *it;
bs.insertLast(Utility::intToString(id));
bs.insertLast(" ");
if((i == listOfInt.size()) || (bs.toString().size() >80))
{
salida << bs.toString();
salida << endl;
if(i != listOfInt.size())
{
for(int i = 0 ; i < tabulacion + 4 ; i++)
salida << " ";
}
bs.clean();
}
}
}
} else {
InnerNode *unNodoInterior = static_cast<InnerNode*> (unNodo);
salida << endl << endl;
for(int i=0; i<tabulacion ; i++)
salida << " ";
salida << "Numero: " << unNodoInterior->number << " Nivel: " << unNodoInterior->level << " Cant.Elem: " << unNodoInterior->keyMount
<< " Esp.Libre: " << TreeConstraits::getEfectiveSizeNode() - unNodoInterior->occupiedSpace << endl;
for (int posicion = 0; posicion <= unNodoInterior->keyMount; ++posicion) {
if (posicion < unNodoInterior->keyMount) {
Key unaClave = unNodoInterior->keys[posicion];
for(int i=0; i<(tabulacion+1) ; i++)
salida << " ";
salida << "(";
if(keytext)
{
salida << unaClave.toString();
}
else
{
ByteString clave(unaClave.toString());
salida << Utility::toString(clave.readAsInt(0));
}
salida << ")";
salida << unaClave.getSize();
salida << " ";
salida << unNodoInterior->getSons()[posicion] << " ";
}
}
for (int posicion = 0; posicion <= unNodoInterior->keyMount; ++posicion) {
Node *hijo = hidratateNode(unNodoInterior->sons[posicion]);
exportNode(salida, hijo, tabulacion + 2,keytext,textContent);
if (hijo)
freeNodeMemory(hijo);
}
for(int i=0; i<tabulacion ; i++)
salida << " ";
salida << endl;
}
}
