X-Git-Url: https://git.llucax.com/z.facultad/75.52/treemulator.git/blobdiff_plain/19b0c56e5c163ef13971c7508c8211a61b377a32..a4c2bc5e5d6b2a6cfdae3ae0159535deaacd28f4:/src/btree.cpp diff --git a/src/btree.cpp b/src/btree.cpp index 225d043..a063bef 100644 --- a/src/btree.cpp +++ b/src/btree.cpp @@ -1,8 +1,9 @@ #include "btree.h" -BTree::BTree (const std::string &name, unsigned int block_size, bool create_new_file) +BTree::BTree (const std::string &name, unsigned int block_size, int kt, bool create_new_file) { + key_type = kt; uchar *node; BTreeNodeHeader nh; @@ -44,14 +45,15 @@ void BTree::WriteFileHeader () void BTree::WriteBlock (uchar *block, uint num) { - fseek (fp, num*header.block_size + sizeof (BTreeFileHeader), SEEK_SET); + num++; + fseek (fp, num*header.block_size, SEEK_SET); fwrite (block, 1, header.block_size, fp); } void BTree::AddKey (const Clave &k) { uint left, right; - Clave *kout = AddKeyR (&k, 0, left, right); + Clave *kout = AddKeyR (k.Clone (), 0, left, right); if (kout) { unsigned short level; @@ -70,6 +72,7 @@ void BTree::AddKey (const Clave &k) WriteKeys (node, node_header, node_keys); WriteNodoHeader (node, &node_header); WriteBlock (node, left); + DeleteKeys (node_keys); delete [] node; /* Leo y actualizo la Raiz */ @@ -86,11 +89,26 @@ void BTree::AddKey (const Clave &k) WriteKeys (node, node_header, node_keys); WriteNodoHeader (node, &node_header); WriteBlock (node, 0); + delete [] node; + DeleteKeys (node_keys); PrintNode (0); } } Clave* BTree::AddKeyR (const Clave *k, uint node_num, uint &left_child, uint &right_child) +{ + uchar *node = ReadBlock (node_num); + BTreeNodeHeader node_header; + ReadNodoHeader (node, &node_header); + delete [] node; + + if (node_header.level == 0) + return AddKeyLeafR (k, node_num, left_child, right_child); + + return AddKeyOtherR (k, node_num, left_child, right_child); +} + +Clave* BTree::AddKeyLeafR (const Clave *k, uint node_num, uint &left_child, uint &right_child) { Clave *kout = NULL; std::list node_keys; @@ -102,49 +120,162 @@ Clave* BTree::AddKeyR (const Clave *k, uint node_num, uint &left_child, uint &ri BTreeNodeHeader node_header; ReadNodoHeader (node, &node_header); - if (node_header.level != 0) { - std::cout << "Entrando nodo level = " << node_header.level << std::endl; - /* No estoy en una hoja, asi que tengo que buscar - * para donde moverme para agregar la clave - */ - std::cout << "Leo Claves" << std::endl; + if (node_header.free_space > data->Size ()) { + BTreeData *datait; + node_keys = ReadKeys (node, node_header); + std::list::iterator it = node_keys.begin (); + + while (it != node_keys.end ()) { + datait = (*it); + if ((*data) < (*datait)) + /* Me pase, lo agrego aca! */ + break; + it++; + } + node_keys.insert (it, data); + WriteKeys (node, node_header, node_keys); + WriteNodoHeader (node, &node_header); + WriteBlock (node, node_num); + DeleteKeys (node_keys); + delete [] node; + + PrintNode (node_num); + } else { + /* Split : Creo e inicializo el nuevo nodo */ + std::list new_node_keys; + std::list old_node_keys; + BTreeNodeHeader new_node_header; + uint new_node_num; + uchar *new_node = NewBlock (new_node_num); + ReadNodoHeader (new_node, &new_node_header); + new_node_header.level = node_header.level; + node_keys = ReadKeys (node, node_header); + new_node_keys = ReadKeys (new_node, new_node_header); + /* Agrego la clave en la lista que ya tengo de manera ordenada */ std::list::iterator it = node_keys.begin (); - std::list::iterator posterior; - std::list::iterator ultima; - - /* Se supone que la primera es un hijo :) */ - BTreeData *lchild = (*it++); - posterior = it; + std::list::iterator previt = node_keys.begin (); while (it != node_keys.end ()) { - if ((*data) < (*(*it))) + BTreeData *datait; + datait = (*it); + if ((*data) < (*datait)) + /* Me pase, lo agrego aca! */ break; - ultima = it; + previt = it; it++; } + if (it != node_keys.end ()) + node_keys.insert (it, data); + else + node_keys.push_back (data); - if (it == posterior) { - std::cout << "==== Me voy al nodo " << lchild->getChild () << std::endl; - k = AddKeyR (k, lchild->getChild (), left_child, right_child); - } else { - std::cout << "==== Me voy al nodo " << (*ultima)->getChild () << std::endl; - k = AddKeyR (k, (*ultima)->getChild (), left_child, right_child); + /* Tengo que guardar claves hasta ocupar nodo size/2 en cada nodo + * y subir la clave del medio */ + node_header.item_count = 0; + node_header.free_space = header.block_size - sizeof (BTreeNodeHeader); + + uint total_size = 0; + it = node_keys.begin (); + while (it != node_keys.end ()) { + BTreeData *datait; + datait = (*it); + total_size += datait->Size (); + it++; + /* Hack : Si me quedo con todas las claves, en el caso de ser + * del mismo tama#o se desbalancea. Hay que ver que efecto + * puede tener en el caso de claves de long. variable + */ + if (it == node_keys.end ()) + total_size -= datait->Size (); } - if (k) { - data = new BTreeData (k->Clone (), right_child); + + it = node_keys.begin (); + uint used = 0; + while (used < total_size/2) { + BTreeData *d = (*it); + old_node_keys.push_back (d); + used += d->Size (); + it++; + } + kout = (*it++)->getClave (); // Esta se retorna al "padre" para que se la agregue + + while (it != node_keys.end ()) { + BTreeData *d = (*it); + new_node_keys.push_back (d); + it++; } + + /* Guardo */ + WriteKeys (node, node_header, old_node_keys); + WriteNodoHeader (node, &node_header); + WriteBlock (node, node_num); + WriteKeys (new_node, new_node_header, new_node_keys); + WriteNodoHeader (new_node, &new_node_header); + WriteBlock (new_node, new_node_num); + DeleteKeys (old_node_keys); + DeleteKeys (new_node_keys); + + PrintNode (node_num); + PrintNode (new_node_num); + + /* Paso los hijos */ + left_child = node_num; + right_child = new_node_num; + delete [] new_node; + delete [] node; } + return kout; +} + +Clave* BTree::AddKeyOtherR (const Clave *k, uint node_num, uint &left_child, uint &right_child) +{ + Clave *kout = NULL; + std::list node_keys; + + BTreeData *data = new BTreeLeafData (k->Clone ()); + + /* Leo el nodo raiz para empezar a agregar */ + uchar *node = ReadBlock (node_num); + BTreeNodeHeader node_header; + ReadNodoHeader (node, &node_header); + + node_keys = ReadKeys (node, node_header); + + std::list::iterator it = node_keys.begin (); + std::list::iterator posterior; + std::list::iterator ultima; + + /* Se supone que la primera es un hijo :) */ + BTreeData *lchild = (*it++); + posterior = it; + + while (it != node_keys.end ()) { + if ((*data) < (*(*it))) + break; + ultima = it; + it++; + } + + if (it == posterior) { + k = AddKeyR (k, lchild->getChild (), left_child, right_child); + } else { + k = AddKeyR (k, (*ultima)->getChild (), left_child, right_child); + } + DeleteKeys (node_keys); /* Nada que hacer */ - if (!k) return NULL; + if (data) delete data; + if (!k) { + delete [] node; + return NULL; + } - /* Estoy en una hoja, veo si lo puedo agregar */ + data = new BTreeData (k->Clone (), right_child); if (node_header.free_space > data->Size ()) { - /* TODO : Insertar ordenado */ BTreeData *datait; node_keys = ReadKeys (node, node_header); std::list::iterator it = node_keys.begin (); @@ -160,10 +291,11 @@ Clave* BTree::AddKeyR (const Clave *k, uint node_num, uint &left_child, uint &ri WriteKeys (node, node_header, node_keys); WriteNodoHeader (node, &node_header); WriteBlock (node, node_num); + DeleteKeys (node_keys); + delete [] node; PrintNode (node_num); } else { - std::cout << "=============== SPLIT ================" << std::endl; /* Split : Creo e inicializo el nuevo nodo */ std::list new_node_keys; std::list old_node_keys; @@ -180,11 +312,7 @@ Clave* BTree::AddKeyR (const Clave *k, uint node_num, uint &left_child, uint &ri std::list::iterator it = node_keys.begin (); std::list::iterator previt = node_keys.begin (); - if (node_header.level != 0) { - /* La primera es ChildData */ - it++; - previt = it; - } + previt = ++it; while (it != node_keys.end ()) { BTreeData *datait; @@ -229,13 +357,9 @@ Clave* BTree::AddKeyR (const Clave *k, uint node_num, uint &left_child, uint &ri it++; } kout = (*it)->getClave (); // Esta se retorna al "padre" para que se la agregue - if (node_header.level != 0) { - new_node_keys.push_back ( new BTreeChildData ((*it)->getChild ())); - } - it++; - std::string s = *kout; - std::cout << "SPLIT Retorna : " << s << std::endl; + new_node_keys.push_back ( new BTreeChildData ((*it)->getChild ())); + it++; while (it != node_keys.end ()) { BTreeData *d = (*it); new_node_keys.push_back (d); @@ -249,6 +373,8 @@ Clave* BTree::AddKeyR (const Clave *k, uint node_num, uint &left_child, uint &ri WriteKeys (new_node, new_node_header, new_node_keys); WriteNodoHeader (new_node, &new_node_header); WriteBlock (new_node, new_node_num); + DeleteKeys (old_node_keys); + DeleteKeys (new_node_keys); PrintNode (node_num); PrintNode (new_node_num); @@ -277,9 +403,14 @@ void BTree::WriteNodoHeader (uchar *node, BTreeNodeHeader *header) uchar *BTree::ReadBlock (uint num) { + /* Como el bloque 0 se usa para el header, el Nodo "num" + * está en el bloque "num+1" + */ + num++; + uchar *out = new uchar[header.block_size]; - fseek (fp, num*header.block_size + sizeof (BTreeFileHeader), SEEK_SET); + fseek (fp, num*header.block_size, SEEK_SET); fread (out, 1, header.block_size, fp); return out; @@ -309,9 +440,9 @@ std::list BTree::ReadKeys (uchar *node, BTreeNodeHeader &node_heade /* TODO : Detectar si estoy en una hoja */ BTreeData *data; if (node_header.level == 0) { - data = new BTreeLeafData (node); + data = new BTreeLeafData (node, key_type); } else { - data = new BTreeData (node); + data = new BTreeData (node, key_type); } node += data->Size (); keys.push_back (data); @@ -331,7 +462,9 @@ void BTree::WriteKeys (uchar *node, BTreeNodeHeader &node_header, std::listToArray(), d->Size ()); + uchar *n = d->ToArray (); + memcpy (node, n, d->Size ()); + delete [] n; node += d->Size (); node_header.free_space -= d->Size (); node_header.item_count++; @@ -362,6 +495,7 @@ void BTree::PrintNode (uint num) std::cout << std::endl; delete [] node; + DeleteKeys (node_keys); } uchar *BTree::NewBlock (uint &num) @@ -373,7 +507,7 @@ uchar *BTree::NewBlock (uint &num) fseek (fp, 0, SEEK_END); filelen = ftell (fp); - num = (filelen - sizeof (BTreeFileHeader))/header.block_size; + num = filelen/header.block_size - 1; node = new uchar[header.block_size]; ReadNodoHeader (node, &nh); @@ -386,3 +520,67 @@ uchar *BTree::NewBlock (uint &num) return node; } +bool BTree::FindKey (const Clave &k) +{ + return FindKeyR (&k, 0); +} + +bool BTree::FindKeyR (const Clave *k, uint node_num) +{ + std::list node_keys; + BTreeNodeHeader node_header; + + /* Leo el nodo raiz para empezar a agregar */ + uchar *node = ReadBlock (node_num); + ReadNodoHeader (node, &node_header); + node_keys = ReadKeys (node, node_header); + + std::list::iterator it = node_keys.begin (); + std::list::iterator posterior; + std::list::iterator ultima; + + /* Se supone que la primera es un hijo :) */ + BTreeData *lchild; + if (node_header.level != 0) { + lchild = (*it++); + } + posterior = it; + + BTreeData *data; + if (node_header.level == 0) + data = new BTreeLeafData ((Clave *)k); + else + data = new BTreeData ((Clave *)k, 0); + + while (it != node_keys.end ()) { + if ((*data) == (*(*it))) { + /* La encontre!, retorno */ + delete [] node; + DeleteKeys (node_keys); + return true; + } + + if ((*data) < (*(*it))) + break; + ultima = it; + it++; + } + + /* TODO: Aca faltaria liberar memoria */ + if (it == posterior) + return FindKeyR (k, lchild->getChild ()); + + return FindKeyR (k, (*ultima)->getChild ()); +} + +void BTree::DeleteKeys (std::list &keys) +{ + std::list::iterator it = keys.begin (); + + while (it != keys.end ()) { + BTreeData *d = (*it); + delete d; + it++; + } +} +