开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 其他数据库 > 查看源码
CtrlCenter.cpp
资源名称：minisqlc.rar　[点击查看]
上传用户：lkd6667
上传日期：2015-05-13
资源大小：1448k
文件大小：19k
源码类别：

其他数据库

开发平台：

C/C++

CtrlCenter.cpp：源码内容
  1. //!CtrlCenter.cpp
  3. #include <iostream>
  4. #include "CtrlCenter.h"
  5. #include "Glob_Var.h"
  6. #include "Catalog.h"
  7. #include "Record.h"
  8. #include "BPTree.h"
  9. using namespace std;
  11. extern _M_Buffer  Buffer;
  13. //////////////////////////////////////////////////////////////////////////////////////
  14. // PS:
  15. // IncludeMin == 0 --------  exclude min
  16. // IncludeMin == 1 --------  include min
  17. // IncludeMax == 0 --------  exclude max
  18. // IncludeMax == 1 --------  include max
  20. //////////////////////////////////////////////////////////////////////////////////////
  21. // this method creates the database file and the index file
  23. void Create( TB_Create_Info& CreateInfo) {
  24. char KeyInfo[256];
  25. HCatalog catalog; 
  26. catalog.Create(CreateInfo,KeyInfo);  // create and initialize *.dbf file
  27. BPTree tree;
  28. tree.create(KeyInfo);                // create and initialize the *.idx file
  29. }
  31. //////////////////////////////////////////////////////////////////////////////////////
  32. // this method selects the records and prints them out 
  34. void Select( TB_Select_Info& SelectInfo) {
  35. Condition_Info ConditionInfo;  //for index
  36. Select_Rec_Info SelectRecInfo; //for record
  37. HCatalog catalog;
  38. Record   rec;
  39. // check the validity of the SelectInfo 
  40. catalog.Select(SelectInfo, ConditionInfo, SelectRecInfo);
  41. rec.PrintHead(SelectRecInfo);  // print the head
  43. BPTree tree;
  44. if( tree.isEmpty() )
  45. throw 1027;
  46. Key_Location min, max;
  47. bool IncludeMin,IncludeMax;
  48.   
  49. // set the address of min and max keys in the select operation
  50. switch(ConditionInfo.OperType) {
  51. case ALL: {  // select all fields
  52.   min = tree.getStart();
  53.   max = tree.getEnd();
  54.   IncludeMin = 1;
  55.   IncludeMax = 1;
  56.   Print(tree, SelectRecInfo, IncludeMin, min, IncludeMax, max);
  57.   break;
  58. }
  59. case B : {
  60.   max = tree.getEnd();
  61.   BPTreeNode node;
  62.   node.readNodeFromFile(max.ptr);
  63.   // compare with the biggest key
  64.   if( node.compare(node.k[node.ItemOnNode-1], ConditionInfo.min) <= 0)
  65. throw 1027;
  66.   if( tree.search(ConditionInfo.min, &min) )  // the min key is existed
  67. min = tree.moveToNextKey(min);
  68.   if( min.offset == node.MaxItem )
  69. min = tree.moveToNextKey(min);
  70.   IncludeMin = 1; IncludeMax =1;  // include the max&min key when printing
  71.   Print(tree, SelectRecInfo, IncludeMin, min, IncludeMax, max);              
  72.   break;
  73. }
  74.     case BE : {
  75.   max = tree.getEnd();
  76.   BPTreeNode node;
  77.   node.readNodeFromFile(max.ptr);
  78.   // compare with the biggest key
  79.   if( node.compare(node.k[node.ItemOnNode-1],ConditionInfo.min) < 0)
  80. throw 1027;
  81.   tree.search(ConditionInfo.min, &min);
  82.   if( min.offset == node.MaxItem )  // can't find and reach the end of a node
  83. min = tree.moveToNextKey(min);
  84.   IncludeMin = 1; IncludeMax =1;  // include the max&min key when printing
  85.   Print(tree,SelectRecInfo,IncludeMin,min,IncludeMax,max);              
  86.   break;
  87. }
  88.     case L  : {
  89.   min = tree.getStart();
  90.   BPTreeNode node;
  91.   node.readNodeFromFile(min.ptr);
  92.   // compare with the smallest key
  93.   if( node.compare(node.k[0],ConditionInfo.max) >= 0)
  94. throw 1027;
  95.   tree.search(ConditionInfo.max, &max);
  97.   BPTreeNode EndNode;
  98.   EndNode.readNodeFromFile(max.ptr);
  99.   // exceed the biggest key in tree
  100.   if( max.offset == EndNode.MaxItem ) {
  101. IncludeMax = 1;
  102. max.offset = EndNode.ItemOnNode - 1;
  103.   }
  104.   else 
  105. IncludeMax = 0;
  107.   IncludeMin = 1;  // include the min key when printing
  108.   Print(tree, SelectRecInfo, IncludeMin, min, IncludeMax, max);      
  109.   break;
  110. }
  111.     case LE : {
  112.   min = tree.getStart();
  113.   BPTreeNode node;
  114.   node.readNodeFromFile(min.ptr);
  115.   if( node.compare(node.k[0],ConditionInfo.max) > 0)
  116. throw 1027;
  117.   if( tree.search(ConditionInfo.max,&max) )  // the max key is existed
  118. IncludeMax = 1;
  119.   else 
  120.   {
  121. /*Key_Location end;
  122. end = tree.GetEnd();*/
  123. BPTreeNode EndNode;
  124. EndNode.readNodeFromFile(max.ptr);
  125. // exceed the biggest key in tree
  126. if( max.offset == EndNode.MaxItem/* && max.ptr == end.ptr*/ ) 
  127. {
  128.   IncludeMax = 1;
  129.   max.offset = EndNode.ItemOnNode - 1;
  130. }
  131.        
  132. else 
  133.   IncludeMax = 0;
  134.   }
  135.   IncludeMin = 1;  // include the min key when printing
  136.   Print(tree,SelectRecInfo,IncludeMin,min,IncludeMax,max); 
  137.   break;
  138. }
  139.     case E  :
  140.   if( !tree.search(ConditionInfo.min,&min) )
  141. throw 1026;  // Error 1026: the Key name isn't existed    
  142.   max = min;
  143.   IncludeMin = 1;  IncludeMax = 1;
  144.   Print(tree,SelectRecInfo,IncludeMin,min,IncludeMax,max);
  145.   break;
  146.     case NE :
  147.   Key_Location temp;
  148.   if( !tree.search(ConditionInfo.min,&temp) ) {
  149. min = tree.getStart();
  150. max = tree.getEnd();
  151. IncludeMin = 1;
  152. IncludeMax = 1;
  153. // print all record;
  154. Print(tree,SelectRecInfo,IncludeMin,min,IncludeMax,max);
  155. break;
  156.   }
  157.   else {
  158. min = tree.getStart();
  159. max = tree.getEnd();
  160. IncludeMin = 1;
  161. IncludeMax = 1;                       
  162. // the key is in the middle of the tree
  163. IncludeMin = 1;
  164. IncludeMax = 0;
  165. Print(tree,SelectRecInfo,IncludeMin,min,IncludeMax,temp);
  166. IncludeMin = 0;
  167. IncludeMax = 1;
  168. Print(tree,SelectRecInfo,IncludeMin,temp,IncludeMax,max);
  169. break;
  170.   }
  171.     case BETWEEN: {
  172.   //the first leaf node
  173.   Key_Location temp;                     
  174.   temp = tree.getStart();             
  175.   BPTreeNode StartNode;                 
  176.   StartNode.readNodeFromFile(temp.ptr);  
  177.   //the last leaf node
  178.   temp = tree.getEnd();                
  179.   BPTreeNode EndNode;                 
  180.   EndNode.readNodeFromFile(temp.ptr);   
  182.   // two conditions throw error
  183.   if( StartNode.compare(StartNode.k[0], ConditionInfo.max) > 0)
  184. throw 1027;              
  185.   if( EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1], ConditionInfo.min) < 0)
  186. throw 1027;
  188.   // print all records
  189.   if( StartNode.compare(StartNode.k[0], ConditionInfo.min) >= 0 &&
  190.   EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1], ConditionInfo.max) <= 0) {
  191. min = tree.getStart();
  192. max = tree.getEnd();
  193. IncludeMin = 1;
  194. IncludeMax = 1;
  195. Print(tree,SelectRecInfo,IncludeMin,min,IncludeMax,max);
  196. break;
  197.   }
  198.   // print from the leftest to some middle record(max)
  199.   if( StartNode.compare(StartNode.k[0],ConditionInfo.min) >= 0 &&
  200.   EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1],ConditionInfo.max) > 0) {
  201. min = tree.getStart();
  202. BPTreeNode node;
  203. node.readNodeFromFile(min.ptr);
  205. if( tree.search(ConditionInfo.max, &max) )  // the max key is existed
  206.   IncludeMax = 1;
  207. else {
  208.   Key_Location end;
  209.   end = tree.getEnd();
  210.   // exceed the biggest key in tree
  211.   // may not need here
  212.   if( max.offset == node.MaxItem && max.ptr == end.ptr )  
  213.   {
  214. IncludeMax = 1;
  215. max.offset = node.ItemOnNode - 1;
  216.   }
  217.   else if( max.offset == node.MaxItem )  // exceed the biggest key in node
  218.   {
  219. max = tree.moveToNextKey(max);       // move to the next key
  220. IncludeMax = 0;
  221.   }
  222.   else 
  223. IncludeMax = 0;
  224. }      
  225. IncludeMin = 1;
  226. Print(tree, SelectRecInfo, IncludeMin, min, IncludeMax, max); 
  227. break;
  228.   }
  229.   // print from min to max
  230.   if( StartNode.compare(StartNode.k[0],ConditionInfo.min) < 0 &&
  231.   EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1],ConditionInfo.max) <= 0) {
  232. max = tree.getEnd();
  233. BPTreeNode node;
  234. node.readNodeFromFile(max.ptr);
  236. tree.search(ConditionInfo.min,&min);
  237. if( min.offset == node.MaxItem )  // can't find and reach the end of a node
  238. min = tree.moveToNextKey(min);
  239. IncludeMin = 1;   IncludeMax =1;  // include the max&min key when printing
  240. Print(tree, SelectRecInfo, IncludeMin, min, IncludeMax, max); 
  241. break;
  242.    }
  244.   // print from min to the last record
  245.   if( StartNode.compare(StartNode.k[0],ConditionInfo.min) < 0 &&
  246.   EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1],ConditionInfo.max) > 0) {
  247. Key_Location temp;
  248. temp = tree.getEnd();
  249. BPTreeNode node;
  250. node.readNodeFromFile(temp.ptr);
  251. tree.search(ConditionInfo.min,&min);
  252. if( min.offset == node.MaxItem )  // can't find and reach the end of a node
  253.   min = tree.moveToNextKey(min);
  254. IncludeMin = 1;   // include the min key when printing
  256. if( tree.search(ConditionInfo.max,&max) )  // the max key is existed
  257.   IncludeMax = 1;
  258. else 
  259. {
  260.   if( max.offset == node.MaxItem )  // exceed the biggest key in node
  261.   {
  262. max = tree.moveToNextKey(max);
  263. IncludeMax = 0;
  264.   }
  265.   else 
  266. IncludeMax = 0;
  267. }
  268. Print(tree,SelectRecInfo,IncludeMin,min,IncludeMax,max); 
  269. break;     
  270.   }
  271. }
  272. }
  273. rec.PrintEnd(SelectRecInfo);
  274. }     
  276. /////////////////////////////////////////////////////////////////////////////////////////////
  277. // insert a new record and adjust the B+ tree
  279. void Insert( TB_Insert_Info& InsertInfo ) {
  280. pKey_Attr pKey = new Key_Attr;
  281. Key_Location KeyLoca;
  282. Rec_Info RecInfo;
  283. HCatalog catalog;
  284. Record   rec;
  285. BPTree tree;
  287. catalog.Insert(InsertInfo, (*pKey), RecInfo);
  288. if( tree.search(pKey, &KeyLoca) )
  289. throw 1025;  // Error 1025: the Key is existed
  290. _F_FileAddr pRec = rec.Insert(RecInfo);
  291. tree.insert(pKey, pRec);
  292. }
  294. //////////////////////////////////////////////////////////////////////////////////////
  295. // update a record 
  297. void Update( TB_Update_Info& UpdateInfo) {
  298. cout<<"begin update"<<endl; //===//
  299. Condition_Info ConditionInfo;
  300. Rec_Info RecInfo;
  301. HCatalog catalog;
  302. BPTree tree;
  303. //error if index tree is empty
  304. if( tree.isEmpty() )
  305. throw 1027; 
  306. cout<<"begin catalog update"<<endl; //====//
  307. catalog.Update(UpdateInfo, ConditionInfo, RecInfo);
  308. cout<<"end catalog update"<<endl; //====//
  309.   
  310. Key_Location min,max;
  311. bool IncludeMin,IncludeMax;
  313. switch(ConditionInfo.OperType) {
  314.     case ALL:
  315.     {
  316. min = tree.getStart();
  317. max = tree.getEnd();
  318. IncludeMin = 1;
  319. IncludeMax = 1;
  320. UpdateRec(tree, RecInfo, IncludeMin, min, IncludeMax, max);
  321. break;
  322.     }
  323.     case B :
  324.     {
  325. max = tree.getEnd();
  326. BPTreeNode node;
  327. node.readNodeFromFile(max.ptr);
  328. // compare with the biggest key
  329. if( node.compare(node.k[node.ItemOnNode-1],ConditionInfo.min) <= 0)
  330. throw 1027; 
  331. // the min key is existed
  332. if( tree.search(ConditionInfo.min,&min) )
  333. min = tree.moveToNextKey(min);
  334. if( min.offset == node.MaxItem )
  335. min = tree.moveToNextKey(min);
  336. IncludeMin = 1; IncludeMax =1;
  337. UpdateRec(tree, RecInfo, IncludeMin, min, IncludeMax, max);              
  338. break;
  339.     }
  340.     case BE : 
  341.     {
  342. max = tree.getEnd();
  343. BPTreeNode node;
  344. node.readNodeFromFile(max.ptr);
  345. // compare with the biggest key
  346. if( node.compare(node.k[node.ItemOnNode-1],ConditionInfo.min) < 0)
  347. throw 1027;
  348. tree.search(ConditionInfo.min, &min);
  349. if( min.offset == node.MaxItem )
  350. min = tree.moveToNextKey(min);
  351. IncludeMin = 1; IncludeMax =1;
  352. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,max);              
  353. break;
  354.     }
  355.     case L :
  356.     {
  357. min = tree.getStart();
  358. BPTreeNode node;
  359. node.readNodeFromFile(min.ptr);
  360. // compare with the smallest key
  361. if( node.compare(node.k[0],ConditionInfo.max) >= 0)
  362. throw 1027;
  363. tree.search(ConditionInfo.max, &max);
  364.          
  365. BPTreeNode EndNode;
  366. EndNode.readNodeFromFile(max.ptr);
  367. // exceed the biggest key in tree
  368. if( max.offset == EndNode.MaxItem ) {
  369. IncludeMax = 1;
  370. max.offset = EndNode.ItemOnNode - 1;
  371. }
  372. else 
  373. IncludeMax = 0;
  375. IncludeMin = 1;
  376. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,max);      
  377. break;
  378.     }
  379.     case LE :
  380.     {
  381. min = tree.getStart();
  382. BPTreeNode node;
  383. node.readNodeFromFile(min.ptr);
  385. if( node.compare(node.k[0],ConditionInfo.max) > 0)
  386. throw 1027;
  387. if( tree.search(ConditionInfo.max, &max) )
  388. IncludeMax = 1;
  389. else {
  390. BPTreeNode EndNode;
  391. EndNode.readNodeFromFile(max.ptr);
  392. // exceed the biggest key in tree
  393. if( max.offset == EndNode.MaxItem ) {
  394. IncludeMax = 1;
  395. max.offset = EndNode.ItemOnNode - 1;
  396. }
  397. else 
  398. IncludeMax = 0;
  399. }
  400. IncludeMin = 1;
  401. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,max); 
  402. break;
  403.     }
  404.     case E :
  405.     {
  406. if( !tree.search(ConditionInfo.min,&min) )
  407. throw 1026;   
  408. max = min;
  409. IncludeMin = 1;  IncludeMax = 1;
  410. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,max);
  411. break;
  412.     }
  413.     case NE :
  414.     {
  415. Key_Location temp;
  416. //condition update all records
  417. if( !tree.search(ConditionInfo.min,&temp) ) {
  418. min = tree.getStart();
  419. max = tree.getEnd();
  420. IncludeMin = 1;
  421. IncludeMax = 1;
  422. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,max);
  423. break;
  424. }
  425. else { //condition having some nodes equal the key
  426. min = tree.getStart();
  427. max = tree.getEnd();      
  428. IncludeMin = 1;
  429. IncludeMax = 0;
  430. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,temp);
  431. IncludeMin = 0;
  432. IncludeMax = 1;
  433. UpdateRec(tree,RecInfo,IncludeMin,temp,IncludeMax,max);
  434. break;
  435. }
  436.     }
  437.     case BETWEEN:
  438.     {                                        
  439. Key_Location temp;                     
  440. temp = tree.getStart();              
  441. BPTreeNode StartNode;                 
  442. StartNode.readNodeFromFile(temp.ptr);  
  443.                                            
  444. temp = tree.getEnd();                
  445. BPTreeNode EndNode;                  
  446. EndNode.readNodeFromFile(temp.ptr);
  448. // max < k[0]
  449. if( StartNode.compare(StartNode.k[0], ConditionInfo.max) > 0)
  450. throw 1027;               
  451. // k[n-1] < min
  452. if( EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1], ConditionInfo.min) < 0)
  453. throw 1027;
  454. // update all records
  455. if( StartNode.compare(StartNode.k[0],ConditionInfo.min) >= 0 &&
  456. EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1],ConditionInfo.max) <= 0) {
  457. // print all record
  458. min = tree.getStart();
  459. max = tree.getEnd();
  460. IncludeMin = 1;
  461. IncludeMax = 1;
  462. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,max);
  463. break;
  464. }
  465. // update from k[0] to max
  466. if( StartNode.compare(StartNode.k[0],ConditionInfo.min) >= 0 &&
  467. EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1],ConditionInfo.max) > 0) {
  468. min = tree.getStart();
  469. BPTreeNode node;
  470. node.readNodeFromFile(min.ptr);
  471. if( tree.search(ConditionInfo.max,&max) )
  472. IncludeMax = 1;
  473. else {
  474. Key_Location end;
  475. end = tree.getEnd();
  476. // exceed the biggest key in tree
  477. if( max.offset == node.MaxItem && max.ptr == end.ptr ) {
  478. IncludeMax = 1;
  479. max.offset = node.ItemOnNode - 1;
  480. }
  481. else if( max.offset == node.MaxItem ) {
  482. max = tree.moveToNextKey(max);
  483. IncludeMax = 0;
  484. }
  485. else 
  486. IncludeMax = 0;
  487. }
  488. IncludeMin = 1;  // include the max key when updating
  489. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,max); 
  490. break;
  491. }
  492. // update from min to k[n-1]
  493. if( StartNode.compare(StartNode.k[0],ConditionInfo.min) < 0 &&
  494. EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1],ConditionInfo.max) <= 0) {
  495. max = tree.getEnd();
  496. BPTreeNode node;
  497. node.readNodeFromFile(max.ptr);
  498. tree.search(ConditionInfo.min,&min);
  499. if( min.offset == node.MaxItem )
  500. min = tree.moveToNextKey(min);
  501. IncludeMin = 1; IncludeMax =1; 
  502. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,max); 
  503. break;
  504. }
  505. // update from min to max
  506. if( StartNode.compare(StartNode.k[0], ConditionInfo.min) < 0 &&
  507. EndNode.compare(EndNode.k[EndNode.ItemOnNode - 1], ConditionInfo.max) > 0) {
  508. Key_Location temp;
  509. temp = tree.getEnd();
  510. BPTreeNode node;
  511. node.readNodeFromFile(temp.ptr);
  512. tree.search(ConditionInfo.min,&min);
  513. if( min.offset == node.MaxItem )
  514. min = tree.moveToNextKey(min);
  515. IncludeMin = 1; 
  516. if( tree.search(ConditionInfo.max,&max) )
  517. IncludeMax = 1;
  518. else {
  519. if( max.offset == node.MaxItem ) {
  520. max = tree.moveToNextKey(max);
  521. IncludeMax = 0;
  522. }
  523. else 
  524. IncludeMax = 0;
  525. }
  526. UpdateRec(tree,RecInfo,IncludeMin,min,IncludeMax,max); 
  527. break;     
  528. }
  529. }
  530.   }  
  531.   cout<<"end update"<<endl; //===//
  532. }
  534. //////////////////////////////////////////////////////////////////////////////////////
  535. // delete a record and adjust the B+ tree
  536. void Delete( TB_Delete_Info& DeleteInfo ) {
  537. Condition_Info ConditionInfo;
  538. Key_Location KeyLoca;
  539. Rec_Info RecInfo;
  540. HCatalog catalog;
  541. Record   rec;
  542. BPTree tree;
  544. catalog.Delete(DeleteInfo,ConditionInfo);
  545. if( !tree.search(ConditionInfo.min, &KeyLoca) )
  546. throw 1026;  // Error 1026: the Key name isn't existed
  547. _F_FileAddr ptr;
  548. tree.myDelete(ConditionInfo.min, ptr); 
  549. rec.Delete(ptr);
  550. }
  552. //////////////////////////////////////////////////////////////////////////////////////
  553. // print the record
  555. void Print(BPTree & tree, Select_Rec_Info & SelectRecInfo,      
  556.            bool IncludeMin, Key_Location min, bool IncludeMax, Key_Location max) {
  558. Record rec;
  559. Key_Location temp;
  561. if( (min == max) && ((0==IncludeMin) || (0==IncludeMax)) ) {
  562. return;
  563. }
  564. if( IncludeMin == 0 )
  565. min = tree.moveToNextKey(min);
  566. //not include the max
  567. if(IncludeMax == 0 ) {
  568. temp = min;
  569. _F_FileAddr ptr;
  570. if(temp == max )
  571. throw 1027;  // no record
  572. while( temp != max ) {
  573. ptr = tree.getCurRecAddr(temp);
  574. rec.Print(ptr, SelectRecInfo);     // print the record
  575. temp = tree.moveToNextKey(temp);  // move to next
  576. }
  577. }
  578. else { // include max
  579. temp = min;
  580. _F_FileAddr ptr;
  581. do {
  582. ptr = tree.getCurRecAddr(temp);
  583. rec.Print(ptr, SelectRecInfo);     // print the record
  584. if(temp == max)
  585. break;
  586. temp = tree.moveToNextKey(temp);  // move to next
  587. }while(1);
  588. }
  589. }
  591. //////////////////////////////////////////////////////////////////////////////////////
  592. // update the record
  594. void UpdateRec(BPTree & tree,Rec_Info & RecInfo,              
  595.    bool IncludeMin,Key_Location min,bool IncludeMax,Key_Location max) {
  596. cout<<"begin updateRec"<<endl; //====//
  597. Record rec;
  598. Key_Location temp;
  600. if( (min == max) && ((0==IncludeMin) || (0==IncludeMax)) )
  601. return;
  602. if( IncludeMin == 0 ) 
  603. min = tree.moveToNextKey(min);
  604. cout<<"in updaterec"<<endl; //===//
  605. if(IncludeMax == 0 ) {
  606. temp = min;
  607. _F_FileAddr ptr;
  608. if(temp == max )
  609. throw 1027;
  610. while( temp != max ) {
  611. ptr = tree.getCurRecAddr(temp);
  612. rec.Update(ptr,RecInfo); 
  613. temp = tree.moveToNextKey(temp);
  614. }
  615. }
  616. else { //( IncludeMax == 1)
  617. temp = min;
  618. _F_FileAddr ptr;
  619. do {
  620. ptr = tree.getCurRecAddr(temp);
  621. rec.Update(ptr,RecInfo); 
  622. if(temp == max)
  623. break;
  624. temp = tree.moveToNextKey(temp);
  625. } while(1);
  626. }
  627. cout<<"end updateRec"<<endl; //==//
  628. }
  630. //////////////////////////////////////////////////////////////////////////////////////
  631. // drop the table
  633. void Ctrl_DropTB() {
  634. char address[256];
  635. strcpy(address,CurLocation);
  636. strcat(address,CurRelationName);
  637. strcat(address,".dbf");
  638. _M_File table1 = Buffer[address];
  639. table1.Close();  // close the file whose path is 'address'
  641. strcpy(address,CurLocation);
  642. strcat(address,CurRelationName);
  643. DelTB(address);  // delete the file
  644. }
  646. //////////////////////////////////////////////////////////////////////////////////////
  647. // drop the database
  649. void Ctrl_DropDB() {
  650. Buffer.End();   // close the buffer,write all page from memory to file
  651. char address[256];
  652. strcpy(address,CurLocation);
  653. DelDB(address); // delete datebase 
  654. Buffer.Start(); // initialize a new buffer
  655. }
  657. //////////////////////////////////////////////////////////////////////////////////////