1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // CegoObjectManager.cc
4 // --------------------
5 // Cego database object manager implementation
6 //
7 // Design and Implementation by Bjoern Lemke
8 //
9 // (C)opyright 2000-2019 Bjoern Lemke
10 //
11 // IMPLEMENTATION MODULE
12 //
13 // Class: CegoObjectManager
14 //
15 // Description: Basic database object handling
16 //
17 // Status: CLEAN
18 //
19 ///////////////////////////////////////////////////////////////////////////////
20
21 // LFC INCLUDES
22 #include <lfcbase/Exception.h>
23
24 // CEGO INCLUDES
25 #include "CegoDefs.h"
26 #include "CegoObjectManager.h"
27 #include "CegoBTreeManager.h"
28 #include "CegoXMLdef.h"
29 #include "CegoBTreeNode.h"
30
31 // POSIX INCLUDES
32 #include <string.h>
33 #include <stdlib.h>
34
CegoObjectManager(CegoDatabaseManager * pDBMng)35 CegoObjectManager::CegoObjectManager(CegoDatabaseManager* pDBMng)
36 {
37 _pDBMng = pDBMng;
38 _pLockHandle = new CegoLockHandler(pDBMng);
39 _ignoreInvalid = false;
40 _modId = _pDBMng->getModId("CegoObjectManager");
41 }
42
~CegoObjectManager()43 CegoObjectManager::~CegoObjectManager()
44 {
45 delete _pLockHandle;
46 }
47
getDBMng()48 CegoDatabaseManager* CegoObjectManager::getDBMng()
49 {
50 return _pDBMng;
51 }
52
getLockHandler()53 CegoLockHandler* CegoObjectManager::getLockHandler()
54 {
55 return _pLockHandle;
56 }
57
createTableObject(CegoTableObject & tableObject)58 void CegoObjectManager::createTableObject(CegoTableObject& tableObject)
59 {
60 unsigned long long lockId = 0;
61 CegoBufferPage bp;
62
63 PageIdType dataPageId = 0;
64
65 try
66 {
67 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
68
69 if ( tableObject.getType() == CegoObject::SYSTEM )
70 {
71 lockMode = CegoBufferPool::PERSISTENT;
72 }
73
74 if ( objectExists(tableObject.getTabSetId(), tableObject.getName(), tableObject.getType()) )
75 {
76 Chain msg = Chain("Object ") + tableObject.getName() + Chain(" exists");
77 throw Exception(EXLOC, msg);
78 }
79
80 PageIdType pageOffset;
81 if ( tableObject.getType() == CegoObject::RBSEG )
82 {
83 pageOffset = _pDBMng->getTempPageOffset(tableObject.getTabSetId());
84 }
85 else
86 {
87 pageOffset = _pDBMng->getSysPageOffset(tableObject.getTabSetId());
88 }
89
90 PageIdType pageId;
91 pageId = pageOffset + tableObject.getTabName().getHashPos(TABMNG_HASHSIZE);
92
93 bool created = false;
94
95 _pDBMng->bufferFix(bp, tableObject.getTabSetId(), pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
96
97 // we previously have to create tuple page
98 // allocating and encoding table entry must be done without interrupt by a checkpoint
99 // otherwise, inconsistent table information is written to datafile
100
101 CegoBufferPage tupPage;
102
103 getNewFilePage(tupPage, tableObject.getTabSetId(), tableObject.getType());
104 tupPage.setType(CegoBufferPage::TUPLE);
105 dataPageId = tupPage.getPageId();
106 _pDBMng->bufferUnfix(tupPage, true, _pLockHandle);
107
108 while ( ! created )
109 {
110 char *buf;
111
112 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
113
114 buf = (char*)bp.newEntry(tableObject.getEntrySize());
115
116 if ( buf )
117 {
118 _pLockHandle->unlockSysPage(lockId);
119 lockId = 0;
120
121 tableObject.setDataPageId(dataPageId);
122 tableObject.setLastDataPageId(dataPageId);
123
124 tableObject.encode(buf);
125
126 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
127
128 created = true;
129 }
130 else
131 {
132 pageId = bp.getNextPageId();
133
134 CegoBufferPage nbp;
135
136 if ( pageId == 0)
137 {
138 getNewFilePage(nbp, tableObject.getTabSetId(), CegoObject::SYSTEM);
139 }
140 else
141 {
142 _pDBMng->bufferFix(nbp, tableObject.getTabSetId(), pageId, lockMode, _pLockHandle);
143 }
144
145 bp.setNextPageId(nbp.getPageId());
146
147 _pLockHandle->unlockSysPage(lockId);
148 lockId = 0;
149
150 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
151
152 bp = nbp;
153 }
154 }
155 }
156 catch ( Exception e)
157 {
158 if ( dataPageId )
159 freeObjectPages(tableObject.getTabSetId(), dataPageId);
160
161 if ( bp.isFixed() )
162 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
163
164 if ( lockId )
165 _pLockHandle->unlockSysPage(lockId);
166
167
168
169 throw e;
170 }
171 }
172
createBTreeObject(CegoBTreeObject & btreeObject)173 void CegoObjectManager::createBTreeObject(CegoBTreeObject& btreeObject)
174 {
175 unsigned long long lockId = 0;
176 CegoBufferPage bp;
177
178 try
179 {
180 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
181
182 if ( objectExists(btreeObject.getTabSetId(), btreeObject.getName(), CegoObject::BTREE) )
183 {
184 Chain msg = Chain("Btree ") + btreeObject.getName() + Chain(" exists");
185 throw Exception(EXLOC, msg);
186 }
187
188 PageIdType pageOffset;
189 pageOffset = _pDBMng->getSysPageOffset(btreeObject.getTabSetId());
190
191 PageIdType pageId;
192 pageId = pageOffset + btreeObject.getTabName().getHashPos(TABMNG_HASHSIZE);
193
194 bool created = false;
195
196 _pDBMng->bufferFix(bp, btreeObject.getTabSetId(), pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
197
198 while ( ! created )
199 {
200 char *buf;
201
202 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
203
204 buf = (char*)bp.newEntry(btreeObject.getEntrySize());
205
206 if ( buf )
207 {
208 _pLockHandle->unlockSysPage(lockId);
209 lockId = 0;
210
211 // object is still invalid
212 btreeObject.setDataPageId(0);
213
214 btreeObject.encode(buf);
215
216 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
217
218 created = true;
219 }
220 else
221 {
222 pageId = bp.getNextPageId();
223
224 CegoBufferPage nbp;
225
226 if ( pageId == 0)
227 {
228 getNewFilePage(nbp, btreeObject.getTabSetId(), CegoObject::SYSTEM);
229 }
230 else
231 {
232 _pDBMng->bufferFix(nbp, btreeObject.getTabSetId(), pageId, lockMode, _pLockHandle);
233 }
234
235 bp.setNextPageId(nbp.getPageId());
236
237 _pLockHandle->unlockSysPage(lockId);
238 lockId = 0;
239
240 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
241
242 bp = nbp;
243 }
244 }
245 }
246 catch ( Exception e)
247 {
248 if ( bp.isFixed() )
249 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
250
251 if ( lockId )
252 _pLockHandle->unlockSysPage(lockId);
253
254 throw e;
255 }
256 }
257
createKeyObject(CegoKeyObject & keyObject)258 void CegoObjectManager::createKeyObject(CegoKeyObject& keyObject)
259 {
260 unsigned long long lockId = 0;
261 CegoBufferPage bp;
262
263 try
264 {
265 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
266
267 if ( objectExists(keyObject.getTabSetId(), keyObject.getName(), keyObject.getType()) )
268 {
269 Chain msg = Chain("Object ") + keyObject.getName() + Chain(" exists");
270 throw Exception(EXLOC, msg);
271 }
272
273 PageIdType pageOffset;
274 pageOffset = _pDBMng->getSysPageOffset(keyObject.getTabSetId());
275
276 PageIdType pageId;
277 pageId = pageOffset + keyObject.getTabName().getHashPos(TABMNG_HASHSIZE);
278
279 bool created = false;
280
281 _pDBMng->bufferFix(bp, keyObject.getTabSetId(), pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
282
283 while ( ! created )
284 {
285 char *buf;
286
287 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
288
289 buf = (char*)bp.newEntry(keyObject.getEntrySize());
290
291 if ( buf )
292 {
293 _pLockHandle->unlockSysPage(lockId);
294 lockId = 0;
295
296 keyObject.encode(buf);
297 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
298 created = true;
299 }
300 else
301 {
302 pageId = bp.getNextPageId();
303
304 CegoBufferPage nbp;
305
306 if ( pageId == 0 )
307 {
308 getNewFilePage(nbp, keyObject.getTabSetId(), CegoObject::SYSTEM);
309 }
310 else
311 {
312 _pDBMng->bufferFix(nbp, keyObject.getTabSetId(), pageId, lockMode, _pLockHandle);
313 }
314
315 bp.setNextPageId(nbp.getPageId());
316
317 _pLockHandle->unlockSysPage(lockId);
318 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
319
320 bp = nbp;
321 }
322 }
323 }
324 catch ( Exception e)
325 {
326 if ( bp.isFixed() )
327 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
328
329 if ( lockId )
330 _pLockHandle->unlockSysPage(lockId);
331
332 throw e;
333 }
334 }
335
createCheckObject(CegoCheckObject & checkObject)336 void CegoObjectManager::createCheckObject(CegoCheckObject& checkObject)
337 {
338 unsigned long long lockId = 0;
339 CegoBufferPage bp;
340
341 try
342 {
343 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
344
345 if ( objectExists(checkObject.getTabSetId(), checkObject.getName(), checkObject.getType()) )
346 {
347 Chain msg = Chain("Object ") + checkObject.getName() + Chain(" exists");
348 throw Exception(EXLOC, msg);
349 }
350
351 PageIdType pageOffset;
352 pageOffset = _pDBMng->getSysPageOffset(checkObject.getTabSetId());
353
354 PageIdType pageId;
355 pageId = pageOffset + checkObject.getTabName().getHashPos(TABMNG_HASHSIZE);
356
357 bool created = false;
358
359 _pDBMng->bufferFix(bp, checkObject.getTabSetId(), pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
360
361 while ( ! created )
362 {
363 char *buf;
364
365 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
366
367 buf = (char*)bp.newEntry(checkObject.getEntrySize());
368
369 if ( buf )
370 {
371 _pLockHandle->unlockSysPage(lockId);
372 lockId = 0;
373
374 checkObject.encode(buf);
375 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
376 created = true;
377 }
378 else
379 {
380 pageId = bp.getNextPageId();
381
382 CegoBufferPage nbp;
383
384 if ( pageId == 0 )
385 {
386 getNewFilePage(nbp, checkObject.getTabSetId(), CegoObject::SYSTEM);
387 }
388 else
389 {
390 _pDBMng->bufferFix(nbp, checkObject.getTabSetId(), pageId, lockMode, _pLockHandle);
391 }
392
393 bp.setNextPageId(nbp.getPageId());
394
395 _pLockHandle->unlockSysPage(lockId);
396 lockId = 0;
397
398 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
399
400 bp = nbp;
401 }
402 }
403 }
404 catch ( Exception e)
405 {
406 if ( bp.isFixed() )
407 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
408
409 if ( lockId )
410 _pLockHandle->unlockSysPage(lockId);
411
412 throw e;
413 }
414 }
415
createViewObject(CegoViewObject & viewObject)416 void CegoObjectManager::createViewObject(CegoViewObject& viewObject)
417 {
418 unsigned long long lockId = 0;
419 CegoBufferPage bp;
420
421 try
422 {
423 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
424
425 if ( objectExists(viewObject.getTabSetId(), viewObject.getName(), viewObject.getType()) )
426 {
427 Chain msg = Chain("Object ") + viewObject.getName() + Chain(" exists");
428 throw Exception(EXLOC, msg);
429 }
430
431 PageIdType pageOffset;
432 pageOffset = _pDBMng->getSysPageOffset(viewObject.getTabSetId());
433
434 PageIdType pageId;
435 pageId = pageOffset + viewObject.getTabName().getHashPos(TABMNG_HASHSIZE);
436
437 bool created = false;
438
439 _pDBMng->bufferFix(bp, viewObject.getTabSetId(), pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
440
441 while ( ! created )
442 {
443 char *buf;
444
445 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
446
447 buf = (char*)bp.newEntry(viewObject.getEntrySize());
448
449 if ( buf )
450 {
451 _pLockHandle->unlockSysPage(lockId);
452 lockId = 0;
453
454 viewObject.encode(buf);
455 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
456 created = true;
457 }
458 else
459 {
460 pageId = bp.getNextPageId();
461
462 CegoBufferPage nbp;
463
464 if ( pageId == 0 )
465 {
466 getNewFilePage(nbp, viewObject.getTabSetId(), CegoObject::SYSTEM);
467 }
468 else
469 {
470 _pDBMng->bufferFix(nbp, viewObject.getTabSetId(), pageId, lockMode, _pLockHandle);
471 }
472
473 bp.setNextPageId(nbp.getPageId());
474
475 _pLockHandle->unlockSysPage(lockId);
476 lockId = 0;
477
478 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
479
480 bp = nbp;
481 }
482 }
483 }
484 catch ( Exception e)
485 {
486 if ( bp.isFixed() )
487 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
488
489 if ( lockId )
490 _pLockHandle->unlockSysPage(lockId);
491
492 throw e;
493 }
494 }
495
createProcObject(CegoProcObject & procObject)496 void CegoObjectManager::createProcObject(CegoProcObject& procObject)
497 {
498 unsigned long long lockId = 0;
499 CegoBufferPage bp;
500
501 try
502 {
503 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
504
505 if ( objectExists(procObject.getTabSetId(), procObject.getName(), procObject.getType()) )
506 {
507 Chain msg = Chain("Object ") + procObject.getName() + Chain(" exists");
508 throw Exception(EXLOC, msg);
509 }
510
511 PageIdType pageOffset;
512 pageOffset = _pDBMng->getSysPageOffset(procObject.getTabSetId());
513
514 PageIdType pageId;
515 pageId = pageOffset + procObject.getName().getHashPos(TABMNG_HASHSIZE);
516
517 bool created = false;
518
519 _pDBMng->bufferFix(bp, procObject.getTabSetId(), pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
520
521 while ( ! created )
522 {
523 char *buf;
524
525 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
526
527 buf = (char*)bp.newEntry(procObject.getEntrySize());
528
529 if ( buf )
530 {
531 _pLockHandle->unlockSysPage(lockId);
532 lockId = 0;
533
534 procObject.encode(buf);
535 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
536 created = true;
537 }
538 else
539 {
540 pageId = bp.getNextPageId();
541
542 CegoBufferPage nbp;
543
544 if ( pageId == 0 )
545 {
546 getNewFilePage(nbp, procObject.getTabSetId(), CegoObject::SYSTEM);
547 }
548 else
549 {
550 _pDBMng->bufferFix(nbp, procObject.getTabSetId(), pageId, lockMode, _pLockHandle);
551 }
552
553 bp.setNextPageId(nbp.getPageId());
554
555 _pLockHandle->unlockSysPage(lockId);
556 lockId = 0;
557
558 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
559
560 bp = nbp;
561 }
562 }
563 }
564 catch ( Exception e)
565 {
566 if ( bp.isFixed() )
567 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
568
569 if ( lockId )
570 _pLockHandle->unlockSysPage(lockId);
571
572 throw e;
573 }
574 }
575
createTriggerObject(CegoTriggerObject & triggerObject)576 void CegoObjectManager::createTriggerObject(CegoTriggerObject& triggerObject)
577 {
578 unsigned long long lockId = 0;
579 CegoBufferPage bp;
580
581 try
582 {
583 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
584
585 if ( objectExists(triggerObject.getTabSetId(), triggerObject.getName(), triggerObject.getType()) )
586 {
587 Chain msg = Chain("Object ") + triggerObject.getName() + Chain(" exists");
588 throw Exception(EXLOC, msg);
589 }
590
591 PageIdType pageOffset;
592 pageOffset = _pDBMng->getSysPageOffset(triggerObject.getTabSetId());
593
594 PageIdType pageId;
595 pageId = pageOffset + triggerObject.getName().getHashPos(TABMNG_HASHSIZE);
596
597 bool created = false;
598
599 _pDBMng->bufferFix(bp, triggerObject.getTabSetId(), pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
600
601 while ( ! created )
602 {
603 char *buf;
604
605 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
606
607 buf = (char*)bp.newEntry(triggerObject.getEntrySize());
608
609 if ( buf )
610 {
611 _pLockHandle->unlockSysPage(lockId);
612 lockId = 0;
613
614 triggerObject.encode(buf);
615 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
616 created = true;
617 }
618 else
619 {
620 pageId = bp.getNextPageId();
621
622 CegoBufferPage nbp;
623
624 if ( pageId == 0 )
625 {
626 getNewFilePage(nbp, triggerObject.getTabSetId(), CegoObject::SYSTEM);
627 }
628 else
629 {
630 _pDBMng->bufferFix(nbp, triggerObject.getTabSetId(), pageId, lockMode, _pLockHandle);
631 }
632
633 bp.setNextPageId(nbp.getPageId());
634
635 _pLockHandle->unlockSysPage(lockId);
636 lockId = 0;
637
638 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
639
640 bp = nbp;
641 }
642 }
643 }
644 catch ( Exception e)
645 {
646 if ( bp.isFixed() )
647 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
648
649 if ( lockId )
650 _pLockHandle->unlockSysPage(lockId);
651
652 throw e;
653 }
654 }
655
createAliasObject(CegoAliasObject & aliasObject)656 void CegoObjectManager::createAliasObject(CegoAliasObject& aliasObject)
657 {
658 unsigned long long lockId = 0;
659 CegoBufferPage bp;
660
661 try
662 {
663 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
664
665 if ( objectExists(aliasObject.getTabSetId(), aliasObject.getName(), aliasObject.getType()) )
666 {
667 Chain msg = Chain("Object ") + aliasObject.getName() + Chain(" exists");
668 throw Exception(EXLOC, msg);
669 }
670
671 PageIdType pageOffset;
672 pageOffset = _pDBMng->getSysPageOffset(aliasObject.getTabSetId());
673
674 PageIdType pageId;
675 pageId = pageOffset + aliasObject.getName().getHashPos(TABMNG_HASHSIZE);
676
677 bool created = false;
678
679 _pDBMng->bufferFix(bp, aliasObject.getTabSetId(), pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
680
681 while ( ! created )
682 {
683 char *buf;
684
685 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
686
687 buf = (char*)bp.newEntry(aliasObject.getEntrySize());
688
689 if ( buf )
690 {
691 _pLockHandle->unlockSysPage(lockId);
692 lockId = 0;
693
694 aliasObject.encode(buf);
695 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
696 created = true;
697 }
698 else
699 {
700 pageId = bp.getNextPageId();
701
702 CegoBufferPage nbp;
703
704 if ( pageId == 0 )
705 {
706 getNewFilePage(nbp, aliasObject.getTabSetId(), CegoObject::SYSTEM);
707 }
708 else
709 {
710 _pDBMng->bufferFix(nbp, aliasObject.getTabSetId(), pageId, lockMode, _pLockHandle);
711 }
712
713 bp.setNextPageId(nbp.getPageId());
714
715 _pLockHandle->unlockSysPage(lockId);
716 lockId = 0;
717
718 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
719
720 bp = nbp;
721 }
722 }
723 }
724 catch ( Exception e)
725 {
726 if ( bp.isFixed() )
727 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
728
729 if ( lockId )
730 _pLockHandle->unlockSysPage(lockId);
731
732 throw e;
733 }
734 }
735
truncateObject(int tabSetId,const Chain & objName,CegoObject::ObjectType type)736 void CegoObjectManager::truncateObject(int tabSetId, const Chain& objName, CegoObject::ObjectType type)
737 {
738 unsigned long long lockId = 0;
739 CegoBufferPage bp;
740
741 _pDBMng->checkTableSetRunState(tabSetId);
742
743 try
744 {
745 PageIdType pageOffset;
746
747 if ( type == CegoObject::RBSEG )
748 {
749 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
750 }
751 else
752 {
753 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
754 }
755
756 PageIdType lowPage;
757 PageIdType highPage;
758
759 getHashPageId(objName, type, lowPage, highPage);
760
761 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
762 {
763 PageIdType pageId = pageOffset + hashPage;
764
765 bool lastPage = false;
766
767 while ( ! lastPage )
768 {
769 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
770
771 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
772 char* pE = (char*)bp.getFirstEntry();
773
774 while ( pE )
775 {
776 CegoObject obj;
777
778 int size;
779 obj.decodeBase(pE, size);
780
781 bool typeMatch = ( type == CegoObject::AVLTREE
782 && ( obj.getType() == CegoObject::AVLTREE
783 || obj.getType() == CegoObject::PAVLTREE
784 || obj.getType() == CegoObject::UAVLTREE ));
785 if ( ! typeMatch )
786 typeMatch = obj.getType() == type;
787
788 if ( typeMatch && objName == obj.getName() && tabSetId == obj.getTabSetId() )
789 {
790 switch ( type )
791 {
792 case CegoObject::FKEY:
793 case CegoObject::CHECK:
794 case CegoObject::VIEW:
795 case CegoObject::PROCEDURE:
796 case CegoObject::TRIGGER:
797 {
798 /* nothing to do */
799 _pLockHandle->unlockSysPage(lockId);
800 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
801 return;
802 }
803 case CegoObject::TABLE:
804 case CegoObject::SYSTEM:
805 case CegoObject::RBSEG:
806 case CegoObject::AVLTREE:
807 case CegoObject::PAVLTREE:
808 case CegoObject::UAVLTREE:
809 {
810 CegoTableObject to;
811 to.decode(pE);
812
813 pageId = to.getDataPageId();
814
815 CegoBufferPage tupPage;
816 getNewFilePage(tupPage, tabSetId, type);
817
818 tupPage.setType(CegoBufferPage::TUPLE);
819
820 int dataPageId = tupPage.getPageId();
821
822 _pDBMng->bufferUnfix(tupPage, true, _pLockHandle);
823
824 to.setDataPageId(dataPageId);
825 to.setLastDataPageId(dataPageId);
826 to.encode(pE);
827
828 _pLockHandle->unlockSysPage(lockId);
829 lockId = 0;
830
831 freeObjectPages(tabSetId, pageId);
832 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
833
834 return;
835 }
836 case CegoObject::BTREE:
837 case CegoObject::PBTREE:
838 case CegoObject::UBTREE:
839 {
840 CegoBTreeObject btoe;
841 btoe.decode(pE);
842
843 CegoBTreeManager btreeMng(this, &btoe);
844 btreeMng.freeBTree();
845
846 CegoBufferPage rootPage;
847 getNewFilePage(rootPage, btoe.getTabSetId(), btoe.getType());
848
849 rootPage.setType(CegoBufferPage::BTREE_LEAF);
850 CegoBTreeNode rootNode;
851 // rootNode.setType(CegoBTreeNode::LEAF);
852 rootNode.setPtr(rootPage.getChunkEntry(), rootPage.getChunkLen());
853 rootNode.initNode();
854
855 int dataPageId = rootPage.getPageId();
856
857 btoe.setDataPageId(dataPageId);
858
859 _pDBMng->bufferUnfix(rootPage, true, _pLockHandle);
860
861 btoe.encode(pE);
862
863 _pLockHandle->unlockSysPage(lockId);
864 lockId = 0;
865
866 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
867
868 return;
869 }
870 case CegoObject::JOIN:
871 case CegoObject::ALIAS:
872 case CegoObject::UNDEFINED:
873 throw Exception(EXLOC, "Invalid object");
874 }
875 }
876 pE = (char*)bp.getNextEntry();
877 }
878
879 pageId = bp.getNextPageId();
880
881 _pLockHandle->unlockSysPage(lockId);
882 lockId = 0;
883
884 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
885
886 if ( pageId == 0 )
887 {
888 lastPage = true;
889 }
890 }
891 }
892 Chain msg = Chain("Object ") + objName + Chain(" not found");
893 throw Exception(EXLOC, msg);
894 }
895 catch ( Exception e)
896 {
897 if ( bp.isFixed() )
898 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
899
900 if ( lockId )
901 _pLockHandle->unlockSysPage(lockId);
902
903 throw e;
904 }
905 }
906
removeObject(int tabSetId,const Chain & objName,CegoObject::ObjectType type)907 void CegoObjectManager::removeObject(int tabSetId, const Chain& objName, CegoObject::ObjectType type)
908 {
909 unsigned long long lockId = 0;
910 CegoBufferPage bp;
911
912 _pDBMng->checkTableSetRunState(tabSetId);
913
914 try
915 {
916 PageIdType pageOffset;
917
918 if ( type == CegoObject::RBSEG )
919 {
920 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
921 }
922 else
923 {
924 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
925 }
926
927 PageIdType lowPage;
928 PageIdType highPage;
929
930 getHashPageId(objName, type, lowPage, highPage);
931
932 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
933 {
934 PageIdType pageId = pageOffset + hashPage;
935
936 bool lastPage = false;
937
938 while ( ! lastPage )
939 {
940 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
941
942 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
943 char* pE = (char*)bp.getFirstEntry();
944
945 while ( pE )
946 {
947 CegoObject obj;
948
949 int size;
950 obj.decodeBase(pE, size);
951
952 bool typeMatch =
953 ( type == CegoObject::AVLTREE && ( obj.getType() == CegoObject::AVLTREE
954 || obj.getType() == CegoObject::PAVLTREE
955 || obj.getType() == CegoObject::UAVLTREE )) ||
956 ( type == CegoObject::BTREE && ( obj.getType() == CegoObject::BTREE
957 || obj.getType() == CegoObject::PBTREE
958 || obj.getType() == CegoObject::UBTREE ));
959
960 if ( ! typeMatch )
961 typeMatch = obj.getType() == type;
962
963 if ( typeMatch && objName == obj.getName() && tabSetId == obj.getTabSetId() )
964 {
965 switch ( type )
966 {
967 case CegoObject::FKEY:
968 case CegoObject::CHECK:
969 case CegoObject::VIEW:
970 case CegoObject::PROCEDURE:
971 case CegoObject::TRIGGER:
972 case CegoObject::ALIAS:
973 {
974 bp.freeEntry(pE);
975 _pLockHandle->unlockSysPage(lockId);
976
977 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
978 return;
979 }
980 case CegoObject::BTREE:
981 case CegoObject::PBTREE:
982 case CegoObject::UBTREE:
983 {
984 CegoBTreeObject btoe;
985 btoe.decode(pE);
986
987 CegoBTreeManager btreeMng(this, &btoe);
988
989 btreeMng.freeBTree();
990
991 bp.freeEntry(pE);
992
993 _pLockHandle->unlockSysPage(lockId);
994 lockId = 0;
995
996 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
997
998 return;
999 }
1000 case CegoObject::TABLE:
1001 case CegoObject::SYSTEM:
1002 case CegoObject::RBSEG:
1003 case CegoObject::AVLTREE:
1004 case CegoObject::PAVLTREE:
1005 case CegoObject::UAVLTREE:
1006 {
1007
1008 CegoTableObject to;
1009 to.decode(pE);
1010
1011 bp.freeEntry(pE);
1012
1013 pageId = to.getDataPageId();
1014
1015 _pLockHandle->unlockSysPage(lockId);
1016 lockId = 0;
1017
1018 freeObjectPages(tabSetId, pageId);
1019 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1020
1021 return;
1022 }
1023 case CegoObject::JOIN:
1024 case CegoObject::UNDEFINED:
1025 throw Exception(EXLOC, "Invalid object");
1026 }
1027 }
1028 pE = (char*)bp.getNextEntry();
1029 }
1030
1031 pageId = bp.getNextPageId();
1032
1033 _pLockHandle->unlockSysPage(lockId);
1034 lockId = 0;
1035
1036 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1037
1038 if ( pageId == 0 )
1039 {
1040 lastPage = true;
1041 }
1042 }
1043 }
1044 Chain msg = Chain("Object ") + objName + Chain(" not found");
1045 throw Exception(EXLOC, msg);
1046 }
1047 catch ( Exception e)
1048 {
1049 if ( bp.isFixed() )
1050 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
1051
1052 if ( lockId )
1053 _pLockHandle->unlockSysPage(lockId);
1054
1055 throw e;
1056 }
1057 }
1058
traceObject(int tabSetId,const Chain & objName,CegoObject::ObjectType type)1059 int CegoObjectManager::traceObject(int tabSetId, const Chain& objName, CegoObject::ObjectType type)
1060 {
1061 unsigned long long lockId = 0;
1062 CegoBufferPage bp;
1063
1064 _pDBMng->checkTableSetRunState(tabSetId);
1065
1066 try
1067 {
1068 PageIdType pageOffset;
1069
1070 if ( type == CegoObject::RBSEG )
1071 {
1072 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
1073 }
1074 else
1075 {
1076 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
1077 }
1078
1079 PageIdType lowPage;
1080 PageIdType highPage;
1081
1082 getHashPageId(objName, type, lowPage, highPage);
1083
1084 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
1085 {
1086 PageIdType pageId = pageOffset + hashPage;
1087
1088 bool lastPage = false;
1089
1090 while ( ! lastPage )
1091 {
1092
1093 // _pDBMng->commitPageEntry(pageId);
1094
1095 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
1096
1097 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
1098 char* pE = (char*)bp.getFirstEntry();
1099
1100 while ( pE )
1101 {
1102 CegoObject obj;
1103
1104 int size;
1105 obj.decodeBase(pE, size);
1106
1107 bool typeMatch =
1108 ( type == CegoObject::AVLTREE && ( obj.getType() == CegoObject::AVLTREE
1109 || obj.getType() == CegoObject::PAVLTREE
1110 || obj.getType() == CegoObject::UAVLTREE )) ||
1111 ( type == CegoObject::BTREE && ( obj.getType() == CegoObject::BTREE
1112 || obj.getType() == CegoObject::PBTREE
1113 || obj.getType() == CegoObject::UBTREE ));
1114
1115 if ( ! typeMatch )
1116 typeMatch = obj.getType() == type;
1117
1118 if ( typeMatch && objName == obj.getName() && tabSetId == obj.getTabSetId() )
1119 {
1120 switch ( type )
1121 {
1122 case CegoObject::FKEY:
1123 case CegoObject::CHECK:
1124 case CegoObject::VIEW:
1125 case CegoObject::PROCEDURE:
1126 case CegoObject::TRIGGER:
1127 {
1128
1129 _pLockHandle->unlockSysPage(lockId);
1130 lockId = 0;
1131
1132 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1133 return 0;
1134 }
1135 case CegoObject::BTREE:
1136 case CegoObject::PBTREE:
1137 case CegoObject::UBTREE:
1138 {
1139 CegoBTreeObject btoe;
1140 btoe.decode(pE);
1141
1142 CegoBTreeManager btreeMng(this, &btoe);
1143
1144 int traceCount = btreeMng.traceBTree();
1145
1146 _pLockHandle->unlockSysPage(lockId);
1147 lockId = 0;
1148
1149 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1150
1151 return traceCount;
1152 }
1153 case CegoObject::TABLE:
1154 case CegoObject::SYSTEM:
1155 case CegoObject::RBSEG:
1156 case CegoObject::AVLTREE:
1157 case CegoObject::PAVLTREE:
1158 case CegoObject::UAVLTREE:
1159 {
1160 CegoTableObject to;
1161 to.decode(pE);
1162
1163 pageId = to.getDataPageId();
1164
1165 _pLockHandle->unlockSysPage(lockId);
1166 lockId = 0;
1167
1168 int traceCount = traceObjectPages(tabSetId, pageId);
1169 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1170
1171 return traceCount;
1172 }
1173 case CegoObject::JOIN:
1174 case CegoObject::ALIAS:
1175 case CegoObject::UNDEFINED:
1176 throw Exception(EXLOC, "Invalid object");
1177 }
1178 }
1179 pE = (char*)bp.getNextEntry();
1180 }
1181
1182 pageId = bp.getNextPageId();
1183
1184 _pLockHandle->unlockSysPage(lockId);
1185 lockId = 0;
1186
1187 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1188
1189 if ( pageId == 0 )
1190 {
1191 lastPage = true;
1192 }
1193 }
1194 }
1195 Chain msg = Chain("Object ") + objName + Chain(" not found");
1196 throw Exception(EXLOC, msg);
1197 }
1198 catch ( Exception e)
1199 {
1200 if ( bp.isFixed() )
1201 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
1202
1203 if ( lockId )
1204 _pLockHandle->unlockSysPage(lockId);
1205
1206 throw e;
1207 }
1208 }
1209
1210
reorgObject(int tabSetId,const Chain & objName,CegoObject::ObjectType type)1211 void CegoObjectManager::reorgObject(int tabSetId, const Chain& objName, CegoObject::ObjectType type)
1212 {
1213 unsigned long long lockId = 0;
1214 CegoBufferPage bp;
1215
1216 _pDBMng->checkTableSetRunState(tabSetId);
1217
1218 try
1219 {
1220 PageIdType pageOffset;
1221
1222 if ( type == CegoObject::RBSEG )
1223 {
1224 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
1225 }
1226 else
1227 {
1228 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
1229 }
1230
1231 PageIdType lowPage;
1232 PageIdType highPage;
1233
1234 getHashPageId(objName, type, lowPage, highPage);
1235
1236 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
1237 {
1238 PageIdType pageId = pageOffset + hashPage;
1239
1240 bool lastPage = false;
1241
1242 while ( ! lastPage )
1243 {
1244 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
1245
1246 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
1247
1248 char* pE = (char*)bp.getFirstEntry();
1249
1250 while ( pE )
1251 {
1252 CegoObject obj;
1253
1254 int size;
1255 obj.decodeBase(pE, size);
1256
1257 bool typeMatch = ( type == CegoObject::AVLTREE
1258 && ( obj.getType() == CegoObject::AVLTREE
1259 || obj.getType() == CegoObject::PAVLTREE
1260 || obj.getType() == CegoObject::UAVLTREE ));
1261 if ( ! typeMatch )
1262 typeMatch = obj.getType() == type;
1263
1264 if ( typeMatch && objName == obj.getName() && tabSetId == obj.getTabSetId() )
1265 {
1266 switch ( type )
1267 {
1268 case CegoObject::TABLE:
1269 case CegoObject::SYSTEM:
1270 case CegoObject::RBSEG:
1271 case CegoObject::AVLTREE:
1272 case CegoObject::PAVLTREE:
1273 case CegoObject::UAVLTREE:
1274 {
1275 CegoTableObject to;
1276 to.decode(pE);
1277
1278 pageId = to.getDataPageId();
1279
1280 PageIdType newPageId;
1281
1282 PageIdType newLastPageId;
1283
1284 removeEmptyPages(tabSetId, pageId, newPageId, newLastPageId);
1285
1286 to.setDataPageId(newPageId);
1287 to.setLastDataPageId(newLastPageId);
1288 to.setRefLastDataPageId(newLastPageId);
1289
1290 to.encode(pE);
1291
1292 _pLockHandle->unlockSysPage(lockId);
1293 lockId = 0;
1294
1295 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1296
1297 return;
1298 }
1299 case CegoObject::VIEW:
1300 case CegoObject::PROCEDURE:
1301 case CegoObject::FKEY:
1302 case CegoObject::JOIN:
1303 case CegoObject::ALIAS:
1304 case CegoObject::UNDEFINED:
1305 case CegoObject::BTREE:
1306 case CegoObject::PBTREE:
1307 case CegoObject::UBTREE:
1308 case CegoObject::CHECK:
1309 case CegoObject::TRIGGER:
1310 throw Exception(EXLOC, "Invalid object");
1311 }
1312 }
1313 pE = (char*)bp.getNextEntry();
1314 }
1315
1316 pageId = bp.getNextPageId();
1317
1318 _pLockHandle->unlockSysPage(lockId);
1319 lockId = 0;
1320
1321 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1322
1323 if ( pageId == 0 )
1324 {
1325 lastPage = true;
1326 }
1327 }
1328 }
1329 Chain msg = Chain("Object ") + objName + Chain(" not found");
1330 throw Exception(EXLOC, msg);
1331 }
1332 catch ( Exception e)
1333 {
1334 if ( bp.isFixed() )
1335 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
1336
1337 if ( lockId )
1338 _pLockHandle->unlockSysPage(lockId);
1339
1340 throw e;
1341 }
1342 }
1343
invalidateObject(int tabSetId,const Chain & objName,CegoObject::ObjectType type)1344 void CegoObjectManager::invalidateObject(int tabSetId, const Chain& objName, CegoObject::ObjectType type)
1345 {
1346 unsigned long long lockId = 0;
1347 CegoBufferPage bp;
1348
1349 _pDBMng->checkTableSetRunState(tabSetId);
1350
1351 try
1352 {
1353 PageIdType pageOffset;
1354
1355 if ( type == CegoObject::RBSEG )
1356 {
1357 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
1358 }
1359 else
1360 {
1361 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
1362 }
1363
1364 PageIdType lowPage;
1365 PageIdType highPage;
1366
1367 getHashPageId(objName, type, lowPage, highPage);
1368
1369 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
1370 {
1371 PageIdType pageId = pageOffset + hashPage;
1372
1373 bool lastPage = false;
1374
1375 while ( ! lastPage )
1376 {
1377 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
1378
1379 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
1380
1381 char* pE = (char*)bp.getFirstEntry();
1382
1383 while ( pE )
1384 {
1385 CegoObject obj;
1386
1387 int size;
1388 obj.decodeBase(pE, size);
1389
1390 bool typeMatch =
1391 ( type == CegoObject::AVLTREE
1392 && ( obj.getType() == CegoObject::AVLTREE
1393 || obj.getType() == CegoObject::PAVLTREE
1394 || obj.getType() == CegoObject::UAVLTREE )) ||
1395 ( type == CegoObject::BTREE
1396 && ( obj.getType() == CegoObject::BTREE
1397 || obj.getType() == CegoObject::PBTREE
1398 || obj.getType() == CegoObject::UBTREE ));
1399
1400 if ( ! typeMatch )
1401 typeMatch = obj.getType() == type;
1402
1403 if ( typeMatch && objName == obj.getName() && tabSetId == obj.getTabSetId() )
1404 {
1405 switch ( type )
1406 {
1407 case CegoObject::TABLE:
1408 case CegoObject::SYSTEM:
1409 case CegoObject::RBSEG:
1410 case CegoObject::AVLTREE:
1411 case CegoObject::PAVLTREE:
1412 case CegoObject::UAVLTREE:
1413 {
1414 CegoTableObject to;
1415 to.decode(pE);
1416
1417 pageId = to.getDataPageId();
1418
1419 freeObjectPages(tabSetId, pageId);
1420
1421 to.setDataPageId(0);
1422
1423 to.setLastDataPageId(0);
1424
1425 to.encode(pE);
1426
1427 _pLockHandle->unlockSysPage(lockId);
1428 lockId = 0;
1429
1430 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1431
1432 return;
1433 }
1434 case CegoObject::BTREE:
1435 case CegoObject::PBTREE:
1436 case CegoObject::UBTREE:
1437 {
1438 CegoBTreeObject bto;
1439 bto.decode(pE);
1440
1441 pageId = bto.getDataPageId();
1442
1443 CegoBTreeManager btreeMng(this, &bto);
1444 btreeMng.freeBTree();
1445
1446 bto.setDataPageId(0);
1447
1448 bto.encode(pE);
1449
1450 _pLockHandle->unlockSysPage(lockId);
1451 lockId = 0;
1452
1453 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1454
1455 return;
1456 }
1457 case CegoObject::VIEW:
1458 case CegoObject::FKEY:
1459 case CegoObject::PROCEDURE:
1460 case CegoObject::JOIN:
1461 case CegoObject::ALIAS:
1462 case CegoObject::UNDEFINED:
1463 case CegoObject::CHECK:
1464 case CegoObject::TRIGGER:
1465 throw Exception(EXLOC, "Invalid object");
1466 }
1467 }
1468 pE = (char*)bp.getNextEntry();
1469 }
1470
1471 pageId = bp.getNextPageId();
1472
1473 _pLockHandle->unlockSysPage(lockId);
1474 lockId = 0;
1475
1476 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1477
1478 if ( pageId == 0 )
1479 {
1480 lastPage = true;
1481 }
1482 }
1483 }
1484 Chain msg = Chain("Object ") + objName + Chain(" not found");
1485 throw Exception(EXLOC, msg);
1486 }
1487 catch ( Exception e)
1488 {
1489 if ( bp.isFixed() )
1490 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
1491
1492 if ( lockId )
1493 _pLockHandle->unlockSysPage(lockId);
1494
1495 throw e;
1496 }
1497 }
1498
alterTableObject(int tabSetId,const Chain & objName,CegoObject::ObjectType type,CegoTableObject & objEntry)1499 void CegoObjectManager::alterTableObject(int tabSetId, const Chain& objName, CegoObject::ObjectType type, CegoTableObject& objEntry)
1500 {
1501 unsigned long long lockId = 0;
1502 unsigned long long altLockId = 0;
1503 CegoBufferPage bp;
1504 CegoBufferPage altPage;
1505
1506 _pDBMng->checkTableSetRunState(tabSetId);
1507
1508 try
1509 {
1510 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
1511
1512 if ( type == CegoObject::SYSTEM )
1513 {
1514 lockMode = CegoBufferPool::PERSISTENT;
1515 }
1516
1517 PageIdType pageOffset;
1518
1519 if ( type == CegoObject::RBSEG )
1520 {
1521 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
1522 }
1523 else
1524 {
1525 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
1526 }
1527
1528 PageIdType lowPage;
1529 PageIdType highPage;
1530
1531 getHashPageId(objName, type, lowPage, highPage);
1532
1533 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
1534 {
1535 PageIdType pageId = pageOffset + hashPage;
1536
1537 bool lastPage = false;
1538
1539 while ( ! lastPage )
1540 {
1541 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
1542
1543 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
1544
1545 char* pE = (char*)bp.getFirstEntry();
1546
1547 while ( pE )
1548 {
1549 CegoObject obj;
1550 int entrySize;
1551
1552 obj.decodeBase(pE, entrySize);
1553
1554 bool typeMatch = ( type == CegoObject::AVLTREE
1555 && ( obj.getType() == CegoObject::AVLTREE
1556 || obj.getType() == CegoObject::PAVLTREE
1557 || obj.getType() == CegoObject::UAVLTREE ));
1558 if ( ! typeMatch )
1559 typeMatch = obj.getType() == type;
1560
1561 if ((Chain)obj.getName() == objName && typeMatch && tabSetId == obj.getTabSetId())
1562 {
1563 CegoTableObject to;
1564
1565 to.decode(pE);
1566
1567 bp.freeEntry(pE);
1568
1569 _pLockHandle->unlockSysPage(lockId);
1570 lockId = 0;
1571
1572 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1573
1574 int dataPageId = to.getDataPageId();
1575 int lastPageId = to.getLastDataPageId();
1576
1577 // make new entry here
1578
1579 int altPageId = pageOffset + objEntry.getName().getHashPos(TABMNG_HASHSIZE);
1580
1581 bool created = false;
1582
1583 _pDBMng->bufferFix(altPage, tabSetId, altPageId, lockMode, _pLockHandle);
1584
1585 while ( ! created )
1586 {
1587 char *buf;
1588
1589 altLockId = _pLockHandle->lockSysPage(altPageId, CegoLockHandler::WRITE);
1590
1591
1592 buf = (char*)altPage.newEntry(objEntry.getEntrySize());
1593
1594 if ( buf )
1595 {
1596 objEntry.setDataPageId(dataPageId);
1597 objEntry.setLastDataPageId(lastPageId);
1598
1599 objEntry.encode(buf);
1600
1601 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
1602 _pLockHandle->unlockSysPage(altLockId);
1603 altLockId = 0;
1604
1605 return;
1606 }
1607 else
1608 {
1609 altPageId = altPage.getNextPageId();
1610
1611 CegoBufferPage nbp;
1612
1613 if ( altPageId == 0 )
1614 {
1615 getNewFilePage(nbp, tabSetId, type);
1616 }
1617 else
1618 {
1619 _pDBMng->bufferFix(nbp, tabSetId, altPageId, lockMode, _pLockHandle);
1620 }
1621
1622 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
1623 _pLockHandle->unlockSysPage(altLockId);
1624 altLockId = 0;
1625
1626 altPage = nbp;
1627 }
1628 }
1629 }
1630 pE = (char*)bp.getNextEntry();
1631 }
1632
1633 pageId = bp.getNextPageId();
1634
1635 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1636 _pLockHandle->unlockSysPage(lockId);
1637 lockId = 0;
1638
1639 if ( pageId == 0 )
1640 {
1641 lastPage = true;
1642 }
1643 }
1644 }
1645 Chain msg = Chain("Table ") + objName + Chain(" not found");
1646 throw Exception(EXLOC, msg);
1647 }
1648 catch ( Exception e)
1649 {
1650 if ( bp.isFixed() )
1651 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
1652
1653 if ( lockId )
1654 _pLockHandle->unlockSysPage(lockId);
1655
1656 if ( altPage.isFixed() )
1657 _pDBMng->bufferUnfix(altPage, false, _pLockHandle);
1658
1659 if ( altLockId )
1660 _pLockHandle->unlockSysPage(altLockId);
1661
1662 throw e;
1663 }
1664 }
1665
alterBTreeObject(int tabSetId,const Chain & objName,CegoObject::ObjectType type,CegoBTreeObject & objEntry)1666 void CegoObjectManager::alterBTreeObject(int tabSetId, const Chain& objName, CegoObject::ObjectType type, CegoBTreeObject& objEntry)
1667 {
1668 unsigned long long lockId = 0;
1669 unsigned long long altLockId = 0;
1670 CegoBufferPage bp;
1671 CegoBufferPage altPage;
1672
1673
1674 _pDBMng->checkTableSetRunState(tabSetId);
1675
1676 try
1677 {
1678 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
1679
1680 if ( type == CegoObject::SYSTEM )
1681 {
1682 lockMode = CegoBufferPool::PERSISTENT;
1683 }
1684
1685 PageIdType pageOffset;
1686
1687 if ( type == CegoObject::RBSEG )
1688 {
1689 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
1690 }
1691 else
1692 {
1693 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
1694 }
1695
1696 PageIdType lowPage;
1697 PageIdType highPage;
1698
1699 getHashPageId(objName, type, lowPage, highPage);
1700
1701 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
1702 {
1703 PageIdType pageId = pageOffset + hashPage;
1704
1705 bool lastPage = false;
1706
1707 while ( ! lastPage )
1708 {
1709 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
1710
1711 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
1712
1713 char* pE = (char*)bp.getFirstEntry();
1714
1715 while ( pE )
1716 {
1717 CegoObject obj;
1718 int entrySize;
1719
1720 obj.decodeBase(pE, entrySize);
1721
1722 bool typeMatch =
1723 ( type == CegoObject::BTREE && ( obj.getType() == CegoObject::BTREE
1724 || obj.getType() == CegoObject::PBTREE
1725 || obj.getType() == CegoObject::UBTREE ));
1726
1727 if ( ! typeMatch )
1728 typeMatch = obj.getType() == type;
1729
1730
1731 if ((Chain)obj.getName() == objName && typeMatch && tabSetId == obj.getTabSetId())
1732 {
1733 CegoBTreeObject bto;
1734
1735 bto.decode(pE);
1736
1737 bp.freeEntry(pE);
1738
1739 _pLockHandle->unlockSysPage(lockId);
1740 lockId = 0;
1741
1742 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1743
1744 PageIdType dataPageId = bto.getDataPageId();
1745
1746 // make new entry here
1747
1748 PageIdType altPageId = pageOffset + objEntry.getName().getHashPos(TABMNG_HASHSIZE);
1749
1750 bool created = false;
1751
1752 _pDBMng->bufferFix(altPage, tabSetId, altPageId, lockMode, _pLockHandle);
1753
1754 while ( ! created )
1755 {
1756 char *buf;
1757
1758 altLockId = _pLockHandle->lockSysPage(altPageId, CegoLockHandler::WRITE);
1759
1760 buf = (char*)altPage.newEntry(objEntry.getEntrySize());
1761
1762 if ( buf )
1763 {
1764 objEntry.setDataPageId(dataPageId);
1765
1766 objEntry.encode(buf);
1767
1768 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
1769 _pLockHandle->unlockSysPage(altLockId);
1770 altLockId = 0;
1771
1772 return;
1773 }
1774 else
1775 {
1776 altPageId = altPage.getNextPageId();
1777
1778 CegoBufferPage nbp;
1779
1780 if ( altPageId == 0 )
1781 {
1782 getNewFilePage(nbp, tabSetId, type);
1783 }
1784 else
1785 {
1786 _pDBMng->bufferFix(nbp, tabSetId, altPageId, lockMode, _pLockHandle);
1787 }
1788
1789 altPage.setNextPageId(nbp.getPageId());
1790
1791 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
1792 _pLockHandle->unlockSysPage(altLockId);
1793 altLockId = 0;
1794
1795 altPage = nbp;
1796 }
1797 }
1798 }
1799 pE = (char*)bp.getNextEntry();
1800 }
1801
1802 pageId = bp.getNextPageId();
1803
1804 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1805 _pLockHandle->unlockSysPage(lockId);
1806 lockId = 0;
1807
1808 if ( pageId == 0 )
1809 {
1810 lastPage = true;
1811 }
1812 }
1813 }
1814 Chain msg = Chain("Btree ") + objName + Chain(" not found");
1815 throw Exception(EXLOC, msg);
1816 }
1817 catch ( Exception e)
1818 {
1819 if ( bp.isFixed() )
1820 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
1821
1822 if ( lockId )
1823 _pLockHandle->unlockSysPage(lockId);
1824
1825 if ( altPage.isFixed() )
1826 _pDBMng->bufferUnfix(altPage, false, _pLockHandle);
1827
1828 if ( altLockId )
1829 _pLockHandle->unlockSysPage(altLockId);
1830
1831 throw e;
1832 }
1833 }
1834
alterKeyObject(int tabSetId,const Chain & keyName,CegoKeyObject & objEntry)1835 void CegoObjectManager::alterKeyObject(int tabSetId, const Chain& keyName, CegoKeyObject& objEntry)
1836 {
1837 unsigned long long lockId = 0;
1838 unsigned long long altLockId = 0;
1839 CegoBufferPage bp;
1840 CegoBufferPage altPage;
1841
1842 _pDBMng->checkTableSetRunState(tabSetId);
1843
1844 try
1845 {
1846 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
1847
1848 PageIdType pageOffset = _pDBMng->getSysPageOffset(tabSetId);
1849
1850 PageIdType lowPage;
1851 PageIdType highPage;
1852
1853 getHashPageId(keyName, CegoObject::FKEY, lowPage, highPage);
1854
1855 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
1856 {
1857 PageIdType pageId = pageOffset + hashPage;
1858
1859 bool lastPage = false;
1860
1861 while ( ! lastPage )
1862 {
1863 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
1864
1865 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
1866
1867 char* pE = (char*)bp.getFirstEntry();
1868
1869 while ( pE )
1870 {
1871 CegoObject obj;
1872 int entrySize;
1873
1874 obj.decodeBase(pE, entrySize);
1875
1876 if ((Chain)obj.getName() == keyName && obj.getType() == CegoObject::FKEY && tabSetId == obj.getTabSetId())
1877 {
1878 CegoKeyObject ko;
1879
1880 ko.decode(pE);
1881
1882 bp.freeEntry(pE);
1883
1884 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1885 _pLockHandle->unlockSysPage(lockId);
1886 lockId = 0;
1887
1888 PageIdType altPageId = pageOffset + objEntry.getName().getHashPos(TABMNG_HASHSIZE);
1889
1890 bool created = false;
1891
1892 _pDBMng->bufferFix(altPage, tabSetId, altPageId, lockMode, _pLockHandle);
1893
1894 while ( ! created )
1895 {
1896 char *buf;
1897
1898 altLockId = _pLockHandle->lockSysPage(altPageId, CegoLockHandler::WRITE);
1899
1900 buf = (char*)altPage.newEntry(objEntry.getEntrySize());
1901
1902 if ( buf )
1903 {
1904 objEntry.encode(buf);
1905 _pLockHandle->unlockSysPage(altLockId);
1906 altLockId = 0;
1907
1908 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
1909 return;
1910 }
1911 else
1912 {
1913 altPageId = altPage.getNextPageId();
1914
1915 CegoBufferPage nbp;
1916
1917 if ( altPageId == 0 )
1918 {
1919 getNewFilePage(nbp, tabSetId, CegoObject::FKEY);
1920 }
1921 else
1922 {
1923 _pDBMng->bufferFix(nbp, tabSetId, altPageId, lockMode, _pLockHandle);
1924 }
1925
1926 altPage.setNextPageId(nbp.getPageId());
1927
1928 _pLockHandle->unlockSysPage(altLockId);
1929 altLockId = 0;
1930
1931 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
1932
1933 altPage = nbp;
1934 }
1935 }
1936 }
1937 pE = (char*)bp.getNextEntry();
1938 }
1939
1940 pageId = bp.getNextPageId();
1941
1942 _pLockHandle->unlockSysPage(lockId);
1943 lockId = 0;
1944
1945 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
1946
1947 if ( pageId == 0 )
1948 {
1949 lastPage = true;
1950 }
1951 }
1952 }
1953 Chain msg = Chain("Key ") + keyName + Chain(" not found");
1954 throw Exception(EXLOC, msg);
1955 }
1956 catch ( Exception e )
1957 {
1958 if ( bp.isFixed() )
1959 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
1960
1961 if ( altPage.isFixed() )
1962 _pDBMng->bufferUnfix(altPage, false, _pLockHandle);
1963
1964 if ( lockId )
1965 _pLockHandle->unlockSysPage(lockId);
1966
1967 if ( altLockId )
1968 _pLockHandle->unlockSysPage(altLockId);
1969
1970 throw e;
1971 }
1972 }
1973
alterTriggerObject(int tabSetId,const Chain & triggerName,CegoTriggerObject & objEntry)1974 void CegoObjectManager::alterTriggerObject(int tabSetId, const Chain& triggerName, CegoTriggerObject& objEntry)
1975 {
1976 unsigned long long lockId = 0;
1977 unsigned long long altLockId = 0;
1978 CegoBufferPage bp;
1979 CegoBufferPage altPage;
1980
1981 _pDBMng->checkTableSetRunState(tabSetId);
1982
1983 try
1984 {
1985 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
1986
1987 PageIdType pageOffset;
1988 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
1989
1990 PageIdType lowPage;
1991 PageIdType highPage;
1992
1993 getHashPageId(triggerName, CegoObject::TRIGGER, lowPage, highPage);
1994
1995 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
1996 {
1997 PageIdType pageId = pageOffset + hashPage;
1998
1999 bool lastPage = false;
2000
2001 while ( ! lastPage )
2002 {
2003 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
2004
2005 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
2006
2007 char* pE = (char*)bp.getFirstEntry();
2008
2009 while ( pE )
2010 {
2011 CegoObject obj;
2012 int entrySize;
2013
2014 obj.decodeBase(pE, entrySize);
2015
2016 if ((Chain)obj.getName() == triggerName && obj.getType() == CegoObject::TRIGGER && tabSetId == obj.getTabSetId())
2017 {
2018 CegoTriggerObject to;
2019
2020 to.decode(pE);
2021
2022 bp.freeEntry(pE);
2023
2024 _pLockHandle->unlockSysPage(lockId);
2025 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
2026
2027 PageIdType altPageId = pageOffset + objEntry.getName().getHashPos(TABMNG_HASHSIZE);
2028
2029 bool created = false;
2030
2031 _pDBMng->bufferFix(altPage, tabSetId, altPageId, lockMode, _pLockHandle);
2032
2033 while ( ! created )
2034 {
2035 char *buf;
2036
2037 altLockId = _pLockHandle->lockSysPage(altPageId, CegoLockHandler::WRITE);
2038
2039 buf = (char*)altPage.newEntry(objEntry.getEntrySize());
2040
2041 if ( buf )
2042 {
2043 _pLockHandle->unlockSysPage(altLockId);
2044 altLockId = 0;
2045
2046 objEntry.encode(buf);
2047 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
2048 return;
2049 }
2050 else
2051 {
2052 altPageId = altPage.getNextPageId();
2053
2054 CegoBufferPage nbp;
2055
2056 if ( altPageId == 0 )
2057 {
2058 getNewFilePage(nbp, tabSetId, CegoObject::TRIGGER);
2059 }
2060 else
2061 {
2062 _pDBMng->bufferFix(nbp, tabSetId, altPageId, lockMode, _pLockHandle);
2063 }
2064
2065 altPage.setNextPageId(nbp.getPageId());
2066
2067 _pLockHandle->unlockSysPage(altLockId);
2068 altLockId = 0;
2069
2070 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
2071
2072 altPage = nbp;
2073 }
2074 }
2075 }
2076 pE = (char*)bp.getNextEntry();
2077 }
2078
2079 pageId = bp.getNextPageId();
2080
2081 _pLockHandle->unlockSysPage(lockId);
2082 lockId = 0;
2083
2084 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
2085
2086 if ( pageId == 0 )
2087 {
2088 lastPage = true;
2089 }
2090 }
2091 }
2092 Chain msg = Chain("Trigger ") + triggerName + Chain(" not found");
2093 throw Exception(EXLOC, msg);
2094 }
2095 catch ( Exception e )
2096 {
2097 if ( bp.isFixed() )
2098 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2099
2100 if ( altPage.isFixed() )
2101 _pDBMng->bufferUnfix(altPage, false, _pLockHandle);
2102
2103 if ( lockId )
2104 _pLockHandle->unlockSysPage(lockId);
2105
2106 if ( altLockId )
2107 _pLockHandle->unlockSysPage(altLockId);
2108
2109 throw e;
2110 }
2111 }
2112
2113
alterProcObject(int tabSetId,const Chain & procName,CegoProcObject & procEntry)2114 void CegoObjectManager::alterProcObject(int tabSetId, const Chain& procName, CegoProcObject& procEntry)
2115 {
2116 unsigned long long lockId = 0;
2117 unsigned long long altLockId = 0;
2118 CegoBufferPage bp;
2119 CegoBufferPage altPage;
2120
2121 _pDBMng->checkTableSetRunState(tabSetId);
2122
2123 try
2124 {
2125 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
2126
2127 PageIdType pageOffset;
2128 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
2129
2130 PageIdType lowPage;
2131 PageIdType highPage;
2132
2133 getHashPageId(procName, CegoObject::PROCEDURE, lowPage, highPage);
2134
2135 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
2136 {
2137 PageIdType pageId = pageOffset + hashPage;
2138
2139 bool lastPage = false;
2140
2141 while ( ! lastPage )
2142 {
2143 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
2144
2145 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
2146
2147 char* pE = (char*)bp.getFirstEntry();
2148
2149 while ( pE )
2150 {
2151 CegoObject obj;
2152 int entrySize;
2153
2154 obj.decodeBase(pE, entrySize);
2155
2156 if ((Chain)obj.getName() == procName && obj.getType() == CegoObject::PROCEDURE && tabSetId == obj.getTabSetId())
2157 {
2158 CegoKeyObject ko;
2159
2160 ko.decode(pE);
2161
2162 bp.freeEntry(pE);
2163
2164 _pLockHandle->unlockSysPage(lockId);
2165 lockId = 0;
2166
2167 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2168
2169 PageIdType altPageId = pageOffset + procEntry.getName().getHashPos(TABMNG_HASHSIZE);
2170
2171 bool created = false;
2172
2173 _pDBMng->bufferFix(altPage, tabSetId, altPageId, lockMode, _pLockHandle);
2174
2175 while ( ! created )
2176 {
2177 char *buf;
2178
2179 altLockId = _pLockHandle->lockSysPage(altPageId, CegoLockHandler::WRITE);
2180
2181 buf = (char*)altPage.newEntry(procEntry.getEntrySize());
2182
2183 if ( buf )
2184 {
2185 procEntry.encode(buf);
2186 _pLockHandle->unlockSysPage(altLockId);
2187 altLockId = 0;
2188
2189 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
2190 return;
2191 }
2192 else
2193 {
2194 altPageId = altPage.getNextPageId();
2195
2196 CegoBufferPage nbp;
2197
2198 if ( altPageId == 0 )
2199 {
2200 getNewFilePage(nbp, tabSetId, CegoObject::PROCEDURE);
2201 }
2202 else
2203 {
2204 _pDBMng->bufferFix(nbp, tabSetId, altPageId, lockMode, _pLockHandle);
2205 }
2206
2207 altPage.setNextPageId(nbp.getPageId());
2208
2209 _pLockHandle->unlockSysPage(altLockId);
2210 altLockId = 0;
2211
2212 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
2213
2214 altPage = nbp;
2215 }
2216 }
2217 }
2218 pE = (char*)bp.getNextEntry();
2219 }
2220
2221 pageId = bp.getNextPageId();
2222
2223 _pLockHandle->unlockSysPage(lockId);
2224 lockId = 0;
2225
2226 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
2227
2228 if ( pageId == 0 )
2229 {
2230 lastPage = true;
2231 }
2232 }
2233 }
2234 Chain msg = Chain("Procedure ") + procName + Chain(" not found");
2235 throw Exception(EXLOC, msg);
2236
2237 }
2238 catch ( Exception e )
2239 {
2240 if ( bp.isFixed() )
2241 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2242
2243 if ( altPage.isFixed() )
2244 _pDBMng->bufferUnfix(altPage, false, _pLockHandle);
2245
2246 if ( lockId )
2247 _pLockHandle->unlockSysPage(lockId);
2248
2249 if ( altLockId )
2250 _pLockHandle->unlockSysPage(altLockId);
2251
2252 throw e;
2253 }
2254 }
2255
alterViewObject(int tabSetId,const Chain & viewName,CegoViewObject & viewEntry)2256 void CegoObjectManager::alterViewObject(int tabSetId, const Chain& viewName, CegoViewObject& viewEntry)
2257 {
2258 unsigned long long lockId = 0;
2259 unsigned long long altLockId = 0;
2260 CegoBufferPage bp;
2261 CegoBufferPage altPage;
2262
2263 _pDBMng->checkTableSetRunState(tabSetId);
2264
2265 try
2266 {
2267 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
2268
2269 PageIdType pageOffset;
2270 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
2271
2272 PageIdType lowPage;
2273 PageIdType highPage;
2274
2275 getHashPageId(viewName, CegoObject::VIEW, lowPage, highPage);
2276
2277 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
2278 {
2279 PageIdType pageId = pageOffset + hashPage;
2280
2281 bool lastPage = false;
2282
2283 while ( ! lastPage )
2284 {
2285 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
2286
2287 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
2288
2289 char* pE = (char*)bp.getFirstEntry();
2290
2291 while ( pE )
2292 {
2293 CegoObject obj;
2294 int entrySize;
2295
2296 obj.decodeBase(pE, entrySize);
2297
2298 if ((Chain)obj.getName() == viewName && obj.getType() == CegoObject::VIEW && tabSetId == obj.getTabSetId())
2299 {
2300 CegoViewObject vo;
2301
2302 vo.decode(pE);
2303
2304 bp.freeEntry(pE);
2305
2306 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2307 _pLockHandle->unlockSysPage(lockId);
2308 lockId = 0;
2309
2310 // make new entry here
2311
2312 PageIdType altPageId = pageOffset + viewEntry.getName().getHashPos(TABMNG_HASHSIZE);
2313
2314 bool created = false;
2315
2316 _pDBMng->bufferFix(altPage, tabSetId, altPageId, lockMode, _pLockHandle);
2317
2318 while ( ! created )
2319 {
2320 char *buf;
2321
2322 altLockId = _pLockHandle->lockSysPage(altPageId, CegoLockHandler::WRITE);
2323
2324 buf = (char*)altPage.newEntry(viewEntry.getEntrySize());
2325
2326 if ( buf )
2327 {
2328 viewEntry.encode(buf);
2329 _pLockHandle->unlockSysPage(altLockId);
2330 altLockId = 0;
2331 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
2332 return;
2333 }
2334 else
2335 {
2336 altPageId = altPage.getNextPageId();
2337
2338 CegoBufferPage nbp;
2339
2340 if ( altPageId == 0 )
2341 {
2342 getNewFilePage(nbp, tabSetId, CegoObject::VIEW);
2343 }
2344 else
2345 {
2346 _pDBMng->bufferFix(nbp, tabSetId, altPageId, lockMode, _pLockHandle);
2347 }
2348
2349 altPage.setNextPageId(nbp.getPageId());
2350
2351 _pLockHandle->unlockSysPage(altLockId);
2352 altLockId = 0;
2353
2354 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
2355
2356 altPage = nbp;
2357 }
2358 }
2359 }
2360 pE = (char*)bp.getNextEntry();
2361 }
2362
2363 pageId = bp.getNextPageId();
2364
2365 _pLockHandle->unlockSysPage(lockId);
2366 lockId = 0;
2367
2368 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
2369
2370 if ( pageId == 0 )
2371 {
2372 lastPage = true;
2373 }
2374 }
2375 }
2376 Chain msg = Chain("View ") + viewName + Chain(" not found");
2377 throw Exception(EXLOC, msg);
2378 }
2379 catch ( Exception e )
2380 {
2381 if ( bp.isFixed() )
2382 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2383
2384 if ( altPage.isFixed() )
2385 _pDBMng->bufferUnfix(altPage, false, _pLockHandle);
2386
2387 if ( lockId )
2388 _pLockHandle->unlockSysPage(lockId);
2389
2390 if ( altLockId )
2391 _pLockHandle->unlockSysPage(altLockId);
2392
2393 throw e;
2394 }
2395 }
2396
alterCheckObject(int tabSetId,const Chain & checkName,CegoCheckObject & checkEntry)2397 void CegoObjectManager::alterCheckObject(int tabSetId, const Chain& checkName, CegoCheckObject& checkEntry)
2398 {
2399 unsigned long long lockId = 0;
2400 unsigned long long altLockId = 0;
2401 CegoBufferPage bp;
2402 CegoBufferPage altPage;
2403
2404 _pDBMng->checkTableSetRunState(tabSetId);
2405
2406 try
2407 {
2408 CegoBufferPool::FixMode lockMode = CegoBufferPool::SYNC;
2409
2410 PageIdType pageOffset;
2411 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
2412
2413 PageIdType lowPage;
2414 PageIdType highPage;
2415
2416 getHashPageId(checkName, CegoObject::CHECK, lowPage, highPage);
2417
2418 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
2419 {
2420 PageIdType pageId = pageOffset + hashPage;
2421
2422 bool lastPage = false;
2423
2424 while ( ! lastPage )
2425 {
2426
2427 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
2428
2429 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::WRITE);
2430
2431 char* pE = (char*)bp.getFirstEntry();
2432
2433 while ( pE )
2434 {
2435 CegoObject obj;
2436 int entrySize;
2437
2438 obj.decodeBase(pE, entrySize);
2439
2440 if ((Chain)obj.getName() == checkName && obj.getType() == CegoObject::CHECK && tabSetId == obj.getTabSetId())
2441 {
2442 CegoCheckObject co;
2443
2444 co.decode(pE);
2445
2446 bp.freeEntry(pE);
2447
2448 _pLockHandle->unlockSysPage(lockId);
2449 lockId = 0;
2450
2451 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2452
2453 // make new entry here
2454
2455 PageIdType altPageId = pageOffset + checkEntry.getName().getHashPos(TABMNG_HASHSIZE);
2456
2457 bool created = false;
2458
2459 _pDBMng->bufferFix(altPage, tabSetId, altPageId, lockMode, _pLockHandle);
2460
2461 while ( ! created )
2462 {
2463 char *buf;
2464
2465 altLockId = _pLockHandle->lockSysPage(altPageId, CegoLockHandler::WRITE);
2466
2467 buf = (char*)altPage.newEntry(checkEntry.getEntrySize());
2468
2469 if ( buf )
2470 {
2471 checkEntry.encode(buf);
2472 _pLockHandle->unlockSysPage(altLockId);
2473 altLockId = 0;
2474
2475 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
2476 return;
2477 }
2478 else
2479 {
2480 altPageId = altPage.getNextPageId();
2481
2482 CegoBufferPage nbp;
2483
2484 if ( altPageId == 0 )
2485 {
2486 getNewFilePage(nbp, tabSetId, CegoObject::VIEW);
2487 }
2488 else
2489 {
2490 _pDBMng->bufferFix(nbp, tabSetId, altPageId, lockMode, _pLockHandle);
2491 }
2492
2493 altPage.setNextPageId(nbp.getPageId());
2494
2495 _pLockHandle->unlockSysPage(altLockId);
2496 altLockId = 0;
2497
2498 _pDBMng->bufferUnfix(altPage, true, _pLockHandle);
2499
2500 altPage = nbp;
2501 }
2502 }
2503 }
2504 pE = (char*)bp.getNextEntry();
2505 }
2506
2507 pageId = bp.getNextPageId();
2508
2509 _pLockHandle->unlockSysPage(lockId);
2510 lockId = 0;
2511
2512 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
2513
2514 if ( pageId == 0 )
2515 {
2516 lastPage = true;
2517 }
2518 }
2519 }
2520
2521 Chain msg = Chain("Check ") + checkName + Chain(" not found");
2522 throw Exception(EXLOC, msg);
2523 }
2524 catch ( Exception e )
2525 {
2526 if ( bp.isFixed() )
2527 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2528
2529 if ( altPage.isFixed() )
2530 _pDBMng->bufferUnfix(altPage, false, _pLockHandle);
2531
2532 if ( lockId )
2533 _pLockHandle->unlockSysPage(lockId);
2534
2535 if ( altLockId )
2536 _pLockHandle->unlockSysPage(altLockId);
2537
2538 throw e;
2539 }
2540 }
2541
getObjectList(int tabSetId,CegoObject::ObjectType type,ListT<Chain> & objList)2542 void CegoObjectManager::getObjectList(int tabSetId, CegoObject::ObjectType type, ListT<Chain>& objList)
2543 {
2544 unsigned long long lockId = 0;
2545 CegoBufferPage bp;
2546
2547 _pDBMng->checkTableSetRunState(tabSetId);
2548
2549 try
2550 {
2551 PageIdType pageOffset;
2552
2553 if ( type == CegoObject::RBSEG )
2554 {
2555 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
2556 }
2557 else
2558 {
2559 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
2560 }
2561
2562 int maxPos = TABMNG_HASHSIZE;
2563
2564 for ( PageIdType hashPos = 0 ; hashPos < maxPos; hashPos++ )
2565 {
2566 PageIdType pageId = pageOffset + hashPos;
2567
2568 bool lastPage = false;
2569
2570 while ( ! lastPage )
2571 {
2572 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
2573
2574 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::READ);
2575
2576 char* pE = (char*)bp.getFirstEntry();
2577
2578 while (pE)
2579 {
2580 CegoObject obj;
2581 int entrySize;
2582
2583 obj.decodeBase(pE, entrySize);
2584
2585 if ( tabSetId == obj.getTabSetId() )
2586 {
2587 bool typeMatch =
2588 ( type == CegoObject::AVLTREE && ( obj.getType() == CegoObject::AVLTREE
2589 || obj.getType() == CegoObject::PAVLTREE
2590 || obj.getType() == CegoObject::UAVLTREE )) ||
2591 ( type == CegoObject::BTREE && ( obj.getType() == CegoObject::BTREE
2592 || obj.getType() == CegoObject::PBTREE
2593 || obj.getType() == CegoObject::UBTREE ));
2594 if ( ! typeMatch )
2595 typeMatch = obj.getType() == type;
2596
2597 if ( typeMatch )
2598 {
2599 objList.Insert(obj.getName());
2600 }
2601 }
2602
2603 pE = (char*)bp.getNextEntry();
2604 }
2605
2606 pageId = bp.getNextPageId();
2607
2608 _pLockHandle->unlockSysPage(lockId);
2609 lockId = 0;
2610
2611 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2612
2613 if ( pageId == 0 )
2614 {
2615 lastPage = true;
2616 }
2617 }
2618 }
2619 }
2620 catch ( Exception e )
2621 {
2622 if ( bp.isFixed() )
2623 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2624
2625 if ( lockId )
2626 _pLockHandle->unlockSysPage(lockId);
2627
2628 throw e;
2629 }
2630 }
2631
setIgnoreInvalid(bool ignoreInvalid)2632 void CegoObjectManager::setIgnoreInvalid(bool ignoreInvalid)
2633 {
2634 _ignoreInvalid = ignoreInvalid;
2635 }
2636
getObjectListByTable(int tabSetId,const Chain & tabName,ListT<CegoTableObject> & idxList,ListT<CegoBTreeObject> & btreeList,ListT<CegoKeyObject> & keyList,ListT<CegoCheckObject> & checkList,ListT<CegoTriggerObject> & triggerList,ListT<CegoAliasObject> & aliasList,int & numInvalid)2637 void CegoObjectManager::getObjectListByTable(int tabSetId, const Chain& tabName,
2638 ListT<CegoTableObject>& idxList,
2639 ListT<CegoBTreeObject>& btreeList,
2640 ListT<CegoKeyObject>& keyList,
2641 ListT<CegoCheckObject>& checkList,
2642 ListT<CegoTriggerObject>& triggerList,
2643 ListT<CegoAliasObject>& aliasList,
2644 int& numInvalid)
2645 {
2646 unsigned long long lockId = 0;
2647 CegoBufferPage bp;
2648 bool objectFound = false;
2649
2650 _pDBMng->checkTableSetRunState(tabSetId);
2651
2652 keyList.Empty();
2653 checkList.Empty();
2654 idxList.Empty();
2655 keyList.Empty();
2656 checkList.Empty();
2657 triggerList.Empty();
2658 aliasList.Empty();
2659 numInvalid = 0;
2660
2661 try
2662 {
2663 PageIdType pageOffset;
2664
2665 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
2666
2667 int maxPos = TABMNG_HASHSIZE;
2668
2669 for ( PageIdType hashPos = 0; hashPos < maxPos; hashPos++ )
2670 {
2671 PageIdType pageId = pageOffset + hashPos;
2672
2673 bool lastPage = false;
2674
2675 while ( ! lastPage )
2676 {
2677 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
2678 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::READ);
2679
2680 char* pE = (char*)bp.getFirstEntry();
2681
2682 while (pE)
2683 {
2684 CegoObject obj;
2685 int entrySize;
2686 obj.decodeBase(pE, entrySize);
2687
2688 if ( tabSetId == obj.getTabSetId() )
2689 {
2690 if ( ( obj.getType() == CegoObject::TABLE
2691 || obj.getType() == CegoObject::VIEW )
2692 && (Chain)obj.getName() == (Chain)tabName )
2693 {
2694 objectFound = true;
2695 }
2696 else if ( obj.getType() == CegoObject::FKEY)
2697 {
2698 CegoKeyObject ko;
2699 ko.decode(pE);
2700 if ( (Chain)ko.getTabName() == (Chain)tabName || (Chain)ko.getRefTable() == (Chain)tabName )
2701 {
2702 keyList.Insert(ko);
2703 }
2704 }
2705 else if ( obj.getType() == CegoObject::CHECK )
2706 {
2707 CegoCheckObject co;
2708 co.decode(pE);
2709
2710 if ( (Chain)co.getTabName() == (Chain)tabName )
2711 {
2712 checkList.Insert(co);
2713 }
2714 }
2715 else if ( obj.getType() == CegoObject::TRIGGER )
2716 {
2717 CegoTriggerObject to;
2718 to.decode(pE);
2719
2720 if ( (Chain)to.getTabName() == (Chain)tabName )
2721 {
2722 triggerList.Insert(to);
2723 }
2724 }
2725 else if ( obj.getType() == CegoObject::ALIAS )
2726 {
2727 CegoAliasObject ao;
2728 ao.decode(pE);
2729
2730 if ( (Chain)ao.getTabName() == (Chain)tabName )
2731 {
2732 aliasList.Insert(ao);
2733 }
2734 }
2735
2736 else if ( obj.getType() == CegoObject::AVLTREE
2737 || obj.getType() == CegoObject::UAVLTREE
2738 || obj.getType() == CegoObject::PAVLTREE )
2739 {
2740 CegoTableObject io;
2741 io.decode(pE);
2742
2743 if ( (Chain)io.getTabName() == (Chain)tabName)
2744 {
2745 if ( io.getDataPageId() == 0 )
2746 {
2747 if ( _ignoreInvalid == false )
2748 {
2749 numInvalid++;
2750 idxList.Insert(io);
2751 }
2752 }
2753 else
2754 {
2755 idxList.Insert(io);
2756 }
2757 }
2758 }
2759 else if ( obj.getType() == CegoObject::BTREE
2760 || obj.getType() == CegoObject::UBTREE
2761 || obj.getType() == CegoObject::PBTREE )
2762 {
2763 CegoBTreeObject bto;
2764 bto.decode(pE);
2765
2766 if ( (Chain)bto.getTabName() == (Chain)tabName)
2767 {
2768 if ( bto.getDataPageId() == 0 )
2769 {
2770 if ( _ignoreInvalid == false )
2771 {
2772 numInvalid++;
2773 btreeList.Insert(bto);
2774 }
2775 }
2776 else
2777 {
2778 btreeList.Insert(bto);
2779 }
2780 }
2781 }
2782 }
2783
2784 pE = (char*)bp.getNextEntry();
2785 }
2786
2787 pageId = bp.getNextPageId();
2788
2789 _pLockHandle->unlockSysPage(lockId);
2790 lockId = 0;
2791
2792 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2793
2794 if ( pageId == 0 )
2795 {
2796 lastPage = true;
2797 }
2798 }
2799 }
2800 }
2801 catch ( Exception e)
2802 {
2803 if ( bp.isFixed() )
2804 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2805
2806 if ( lockId )
2807 _pLockHandle->unlockSysPage(lockId);
2808
2809 throw e;
2810 }
2811
2812 if ( objectFound == false )
2813 {
2814 Chain msg = Chain("Object ") + tabName + Chain(" not found");
2815 throw Exception(EXLOC, msg);
2816 }
2817 }
2818
getObject(int tabSetId,const Chain & objectName,CegoObject::ObjectType type,CegoDecodableObject & oe)2819 void CegoObjectManager::getObject(int tabSetId, const Chain& objectName, CegoObject::ObjectType type, CegoDecodableObject& oe)
2820 {
2821 CegoBufferPage bp;
2822 getObjectWithFix(tabSetId, objectName, type, oe, bp);
2823 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2824 }
2825
getObjectWithFix(int tabSetId,const Chain & objectName,CegoObject::ObjectType type,CegoDecodableObject & oe,CegoBufferPage & bp)2826 void CegoObjectManager::getObjectWithFix(int tabSetId, const Chain& objectName, CegoObject::ObjectType type, CegoDecodableObject& oe, CegoBufferPage &bp)
2827 {
2828 unsigned long long lockId = 0;
2829
2830 _pDBMng->checkTableSetRunState(tabSetId);
2831
2832 try
2833 {
2834 bool notFound = true;
2835
2836 PageIdType pageOffset;
2837
2838 if ( type == CegoObject::RBSEG )
2839 {
2840 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
2841 }
2842 else
2843 {
2844 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
2845 }
2846
2847 PageIdType lowPage;
2848 PageIdType highPage;
2849
2850 getHashPageId(objectName, type, lowPage, highPage);
2851
2852 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
2853 {
2854 PageIdType pageId = pageOffset + hashPage;
2855
2856 bool lastPage = false;
2857
2858 while ( ! lastPage && notFound )
2859 {
2860 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
2861 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::READ);
2862
2863 char* pE = (char*)bp.getFirstEntry();
2864
2865 while (pE && notFound )
2866 {
2867 CegoObject obj;
2868 int entrySize;
2869 obj.decodeBase(pE, entrySize);
2870
2871 if ( tabSetId == obj.getTabSetId() )
2872 {
2873 bool typeMatch =
2874 ( type == CegoObject::AVLTREE && ( obj.getType() == CegoObject::AVLTREE
2875 || obj.getType() == CegoObject::PAVLTREE
2876 || obj.getType() == CegoObject::UAVLTREE )) ||
2877 ( type == CegoObject::BTREE && ( obj.getType() == CegoObject::BTREE
2878 || obj.getType() == CegoObject::PBTREE
2879 || obj.getType() == CegoObject::UBTREE ));
2880 if ( ! typeMatch )
2881 typeMatch = obj.getType() == type;
2882
2883 if ((Chain)obj.getName() == (Chain)objectName && typeMatch ) // && type != CegoObject::FKEY)
2884 {
2885 oe.decode(pE);
2886 notFound = false;
2887 }
2888 else
2889 {
2890 pE = (char*)bp.getNextEntry();
2891 }
2892 }
2893 else
2894 {
2895 pE = (char*)bp.getNextEntry();
2896 }
2897 }
2898
2899 pageId = bp.getNextPageId();
2900
2901 _pLockHandle->unlockSysPage(lockId);
2902 lockId = 0;
2903
2904 if ( notFound == false )
2905 {
2906 return;
2907 }
2908 else
2909 {
2910 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2911 }
2912
2913 if ( pageId == 0 )
2914 {
2915 lastPage = true;
2916 }
2917 }
2918 }
2919 if ( notFound )
2920 {
2921 Chain msg = Chain("Object ") + objectName + Chain(" not found");
2922 throw Exception(EXLOC, msg);
2923 }
2924 }
2925 catch ( Exception e )
2926 {
2927 if ( bp.isFixed() )
2928 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
2929
2930 if ( lockId )
2931 _pLockHandle->unlockSysPage(lockId);
2932
2933 throw e;
2934 }
2935 }
2936
objectExists(int tabSetId,const Chain & objectName,CegoObject::ObjectType type)2937 bool CegoObjectManager::objectExists(int tabSetId, const Chain& objectName, CegoObject::ObjectType type)
2938 {
2939
2940 CegoBufferPage bp;
2941 unsigned long long lockId = 0;
2942
2943 _pDBMng->checkTableSetRunState(tabSetId);
2944
2945 try
2946 {
2947
2948 bool found = false;
2949
2950 PageIdType pageOffset;
2951
2952 if ( type == CegoObject::RBSEG )
2953 {
2954 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
2955 }
2956 else
2957 {
2958 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
2959 }
2960
2961 PageIdType lowPage;
2962 PageIdType highPage;
2963
2964 getHashPageId(objectName, type, lowPage, highPage);
2965
2966 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
2967 {
2968 PageIdType pageId = pageOffset + hashPage;
2969
2970 bool lastPage = false;
2971
2972 while ( ! lastPage && ! found )
2973 {
2974 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
2975
2976 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::READ);
2977
2978 char* pE = (char*)bp.getFirstEntry();
2979
2980 while (pE && ! found )
2981 {
2982 CegoObject oe;
2983 int entrySize;
2984 oe.decodeBase(pE, entrySize);
2985
2986 if ( tabSetId == oe.getTabSetId() )
2987 {
2988 bool typeMatch =
2989 ( type == CegoObject::AVLTREE && ( oe.getType() == CegoObject::AVLTREE
2990 || oe.getType() == CegoObject::PAVLTREE
2991 || oe.getType() == CegoObject::UAVLTREE )) ||
2992 ( type == CegoObject::BTREE && ( oe.getType() == CegoObject::BTREE
2993 || oe.getType() == CegoObject::PBTREE
2994 || oe.getType() == CegoObject::UBTREE ));
2995 if ( ! typeMatch )
2996 typeMatch = oe.getType() == type;
2997
2998 if ((Chain)oe.getName() == objectName && typeMatch )
2999 {
3000 found = true;
3001 }
3002 else
3003 {
3004 pE = (char*)bp.getNextEntry();
3005 }
3006 }
3007 else
3008 {
3009 pE = (char*)bp.getNextEntry();
3010 }
3011 }
3012
3013 pageId = bp.getNextPageId();
3014
3015 _pLockHandle->unlockSysPage(lockId);
3016 lockId = 0;
3017
3018 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3019
3020 if ( pageId == 0 )
3021 {
3022 lastPage = true;
3023 }
3024 }
3025
3026 if ( found )
3027 return true;
3028 }
3029
3030 return false;
3031
3032 }
3033 catch ( Exception e )
3034 {
3035 if ( bp.isFixed() )
3036 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3037
3038 if ( lockId )
3039 _pLockHandle->unlockSysPage(lockId);
3040
3041 throw e;
3042 }
3043 }
3044
insertData(CegoTableObject & oe,char * data,int dataSize,bool doAppend,bool allowWrite)3045 CegoDataPointer CegoObjectManager::insertData(CegoTableObject& oe, char* data, int dataSize, bool doAppend, bool allowWrite)
3046 {
3047
3048 unsigned long long recLock = 0;
3049 unsigned long long lockId = 0;
3050 CegoBufferPage bp;
3051
3052 try
3053 {
3054 PageIdType pageOffset;
3055
3056 if ( oe.getType() == CegoObject::RBSEG )
3057 {
3058 pageOffset = _pDBMng->getTempPageOffset(oe.getTabSetId());
3059 }
3060 else
3061 {
3062 pageOffset = _pDBMng->getSysPageOffset(oe.getTabSetId());
3063 }
3064
3065 PageIdType lowPage;
3066 PageIdType highPage;
3067
3068 getHashPageId(oe.getTabName(), oe.getType(), lowPage, highPage);
3069
3070 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
3071 {
3072 PageIdType pageId = pageOffset + hashPage;
3073
3074 bool lastPage = false;
3075
3076 while ( ! lastPage )
3077 {
3078 _pDBMng->bufferFix(bp, oe.getTabSetId(), pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
3079
3080 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::READ);
3081
3082 char* pE = (char*)bp.getFirstEntry();
3083
3084 while ( pE )
3085 {
3086 CegoObject obj;
3087 int entrySize;
3088 obj.decodeBase(pE, entrySize);
3089
3090 if ( oe.getTabSetId() == obj.getTabSetId()
3091 && (Chain)oe.getName() == (Chain)obj.getName()
3092 && oe.getType() == obj.getType())
3093 {
3094 CegoDataPointer recDP(pageId, bp.getEntryPos());
3095
3096 if ( oe.getType() == CegoObject::RBSEG )
3097 {
3098 recLock = _pLockHandle->lockRBRecord(recDP, CegoLockHandler::WRITE);
3099 }
3100 else
3101 {
3102 recLock = _pLockHandle->lockSysRecord(recDP, CegoLockHandler::WRITE);
3103 }
3104
3105 // resolve required
3106 oe.decode(pE);
3107
3108 CegoDataPointer dp;
3109
3110 int startPageId;
3111
3112 if ( doAppend )
3113 {
3114 startPageId = oe.getRefLastDataPageId();
3115 }
3116 else
3117 {
3118 startPageId = oe.getDataPageId();
3119 }
3120
3121 bool isNewPage;
3122
3123 dp = insertPageData(oe.getTabSetId(), oe.getType(), startPageId, data, dataSize, isNewPage, allowWrite, doAppend);
3124
3125 if ( isNewPage )
3126 {
3127 oe.setRefLastDataPageId(dp.getPageId());
3128 }
3129
3130 if ( oe.getType() == CegoObject::RBSEG )
3131 {
3132 _pLockHandle->unlockRBRecord(recLock);
3133 }
3134 else
3135 {
3136 _pLockHandle->unlockSysRecord(recLock);
3137 }
3138
3139 recLock = 0;
3140
3141 _pLockHandle->unlockSysPage(lockId);
3142 lockId = 0;
3143
3144 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
3145
3146 return dp;
3147 }
3148 else
3149 {
3150 pE = (char*)bp.getNextEntry();
3151 }
3152 }
3153
3154 pageId = bp.getNextPageId();
3155
3156 _pLockHandle->unlockSysPage(lockId);
3157 lockId = 0;
3158
3159 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3160
3161 if ( pageId == 0 )
3162 {
3163 lastPage = true;
3164 }
3165 }
3166 }
3167 Chain msg = Chain("Object ") + oe.getName() + Chain(" not found");
3168 throw Exception(EXLOC, msg);
3169 }
3170 catch ( Exception e )
3171 {
3172 if ( bp.isFixed() )
3173 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3174
3175 if ( lockId )
3176 _pLockHandle->unlockSysPage(lockId);
3177
3178 if ( recLock )
3179 {
3180 if ( oe.getType() == CegoObject::RBSEG )
3181 {
3182 _pLockHandle->unlockRBRecord(recLock);
3183 }
3184 else
3185 {
3186 _pLockHandle->unlockSysRecord(recLock);
3187 }
3188 }
3189 throw e;
3190 }
3191 }
3192
3193 /*
3194 The second insertData method is performance optimized and can be used, if the the data pointer for the corresponding object
3195 is already available (sysEntry). In this case, no lookup up is required to get the entry point for the object.
3196 Anyway the TableObject is given as an argument to set up the lastpage information for the object.
3197 The insertAtLast flag enables append mode rather then looking for unued page slots in the available data pages.
3198 The allowWrite flag is used to allow asynchronous writes of data pages to the data files.
3199 Normally, this is used for index and temp objects.
3200 */
3201
insertData(const CegoDataPointer & sysEntry,CegoTableObject & oe,char * data,int dataSize,bool doAppend,bool allowWrite)3202 CegoDataPointer CegoObjectManager::insertData( const CegoDataPointer& sysEntry, CegoTableObject& oe, char* data, int dataSize, bool doAppend, bool allowWrite)
3203 {
3204 unsigned long long recLock = 0;
3205
3206 try
3207 {
3208 if ( oe.getType() == CegoObject::RBSEG )
3209 {
3210 recLock = _pLockHandle->lockRBRecord(sysEntry, CegoLockHandler::WRITE);
3211 }
3212 else
3213 {
3214 recLock = _pLockHandle->lockSysRecord(sysEntry, CegoLockHandler::WRITE);
3215 }
3216
3217 CegoDataPointer dp;
3218
3219 int pageId;
3220
3221 // int lockPageId = oe.getDataPageId();
3222
3223 if ( doAppend )
3224 {
3225 pageId = oe.getRefLastDataPageId();
3226 }
3227 else
3228 {
3229 pageId = oe.getDataPageId();
3230 }
3231
3232 bool isNewPage;
3233
3234
3235 dp = insertPageData(oe.getTabSetId(), oe.getType(), pageId, data, dataSize, isNewPage, allowWrite, doAppend);
3236 if ( isNewPage )
3237 {
3238 // setLastPage
3239 oe.setRefLastDataPageId(dp.getPageId());
3240 }
3241
3242 if ( oe.getType() == CegoObject::RBSEG )
3243 {
3244 _pLockHandle->unlockRBRecord(recLock);
3245 }
3246 else
3247 {
3248 _pLockHandle->unlockSysRecord(recLock);
3249 }
3250
3251 recLock = 0;
3252
3253 return dp;
3254 }
3255 catch ( Exception e )
3256 {
3257 if ( recLock )
3258 {
3259 if ( oe.getType() == CegoObject::RBSEG )
3260 {
3261 _pLockHandle->unlockRBRecord(recLock);
3262 }
3263 else
3264 {
3265 _pLockHandle->unlockSysRecord(recLock);
3266 }
3267 }
3268 throw e;
3269 }
3270 }
3271
deleteData(CegoObject::ObjectType type,int tabSetId,const CegoDataPointer & dp)3272 void CegoObjectManager::deleteData(CegoObject::ObjectType type, int tabSetId, const CegoDataPointer& dp)
3273 {
3274 CegoBufferPage bp;
3275 unsigned long long lockId = 0;
3276
3277 try
3278 {
3279 _pDBMng->bufferFix(bp, tabSetId, dp.getPageId(), CegoBufferPool::SYNC, _pLockHandle);
3280
3281 char* pE = (char*)bp.getPagePtr() + dp.getOffset();
3282
3283 lockId = _pLockHandle->lockData(type, dp.getPageId(), CegoLockHandler::WRITE);
3284 bp.freeEntry(pE);
3285
3286 _pLockHandle->unlockData(type, lockId);
3287 lockId = 0;
3288
3289 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
3290 }
3291 catch ( Exception e)
3292 {
3293
3294 if ( bp.isFixed() )
3295 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3296
3297 if ( lockId )
3298 _pLockHandle->unlockData(type, lockId);
3299
3300 throw e;
3301 }
3302 }
3303
getObjectCursor(int tabSetId,const Chain & hashName,const Chain & objName,CegoObject::ObjectType type)3304 CegoObjectCursor* CegoObjectManager::getObjectCursor(int tabSetId, const Chain& hashName, const Chain& objName, CegoObject::ObjectType type)
3305 {
3306 CegoBufferPage bp;
3307 unsigned long long lockId = 0;
3308
3309 try
3310 {
3311 PageIdType pageOffset;
3312
3313 if ( type == CegoObject::RBSEG )
3314 {
3315 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
3316 }
3317 else
3318 {
3319 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
3320 }
3321
3322 PageIdType lowPage;
3323 PageIdType highPage;
3324
3325 getHashPageId(hashName, type, lowPage, highPage);
3326
3327 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
3328 {
3329 PageIdType pageId = pageOffset + hashPage;
3330
3331 bool lastPage = false;
3332 bool inserted = false;
3333
3334 while ( ! lastPage && ! inserted)
3335 {
3336 _pDBMng->bufferFix(bp, tabSetId, pageId, CegoBufferPool::PERSISTENT, _pLockHandle);
3337 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::READ);
3338
3339 char* pE = (char*)bp.getFirstEntry();
3340
3341 while (pE && ! inserted )
3342 {
3343 CegoObject obj;
3344 int entrySize;
3345
3346 obj.decodeBase(pE, entrySize);
3347
3348 if ( obj.getTabSetId() == tabSetId )
3349 {
3350 bool typeMatch =
3351 ( type == CegoObject::AVLTREE && ( obj.getType() == CegoObject::AVLTREE
3352 || obj.getType() == CegoObject::PAVLTREE
3353 || obj.getType() == CegoObject::UAVLTREE ));
3354 if ( ! typeMatch )
3355 typeMatch = obj.getType() == type;
3356
3357 if ( (Chain)objName == (Chain)obj.getName() && typeMatch)
3358 {
3359
3360 CegoTableObject to;
3361 to.decode(pE);
3362
3363 _pLockHandle->unlockSysPage(lockId);
3364 lockId = 0;
3365
3366 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3367
3368 CegoObjectCursor* pC = new CegoObjectCursor(_pDBMng,
3369 _pLockHandle,
3370 tabSetId,
3371 type,
3372 to.getDataPageId());
3373 return pC;
3374 }
3375 else
3376 {
3377 pE = (char*)bp.getNextEntry();
3378 }
3379 }
3380 else
3381 {
3382 pE = (char*)bp.getNextEntry();
3383 }
3384 }
3385
3386 _pLockHandle->unlockSysPage(lockId);
3387 lockId = 0;
3388
3389 pageId = bp.getNextPageId();
3390
3391 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3392
3393 if ( pageId == 0 )
3394 {
3395 lastPage = true;
3396 }
3397 }
3398 }
3399
3400 Chain msg = Chain("Object ") + objName + Chain(" not found");
3401 throw Exception(EXLOC, msg);
3402 }
3403 catch ( Exception e )
3404 {
3405 if ( bp.isFixed() )
3406 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3407 if ( lockId )
3408 _pLockHandle->unlockSysPage(lockId);
3409
3410 throw e;
3411 }
3412 }
3413
claimDataPtrUnlocked(int tabSetId,CegoBufferPool::FixMode fixMode,const CegoDataPointer & dp,char * & ptr,int & len,CegoBufferPage & bp)3414 void CegoObjectManager::claimDataPtrUnlocked(int tabSetId, CegoBufferPool::FixMode fixMode, const CegoDataPointer& dp, char*& ptr, int& len, CegoBufferPage& bp)
3415 {
3416 // cout << "Claim unlocked : " << dp << endl;
3417
3418 _pDBMng->bufferFix(bp, tabSetId, dp.getPageId(), fixMode, _pLockHandle);
3419
3420 ptr = (char*)bp.getPagePtr() + dp.getOffset();
3421 len = *(int*)((long long)bp.getPagePtr() + (long)dp.getOffset() - sizeof(int));
3422
3423 // return bp;
3424 }
3425
releaseDataPtrUnlocked(CegoBufferPage & bp,bool isDirty)3426 void CegoObjectManager::releaseDataPtrUnlocked(CegoBufferPage& bp, bool isDirty)
3427 {
3428 // cout << "Release unlocked : [" << bp.getFileId() << "," << bp.getPageId() << "]" << endl;
3429 if ( bp.getPageId() )
3430 _pDBMng->bufferUnfix(bp, isDirty, _pLockHandle);
3431 }
3432
releaseAndClaimDataPtrUnlocked(CegoBufferPage & bp,bool isDirty,int tabSetId,CegoBufferPool::FixMode fixMode,const CegoDataPointer & dp,char * & ptr,int & len,CegoBufferPage & nbp)3433 void CegoObjectManager::releaseAndClaimDataPtrUnlocked(CegoBufferPage& bp, bool isDirty, int tabSetId, CegoBufferPool::FixMode fixMode, const CegoDataPointer& dp, char*& ptr, int& len, CegoBufferPage& nbp)
3434 {
3435 // do we have to unfix and fix ?
3436 if ( bp.getPageId() == dp.getPageId() )
3437 {
3438 // same page id, so we just setup
3439 nbp = bp;
3440 ptr = (char*)nbp.getPagePtr() + dp.getOffset();
3441 len = *(int*)((long long)nbp.getPagePtr() + (long)dp.getOffset() - sizeof(int));
3442 }
3443 else
3444 {
3445 releaseDataPtrUnlocked(bp, isDirty);
3446 claimDataPtrUnlocked(tabSetId, fixMode, dp, ptr, len, nbp);
3447 }
3448 }
3449
freeObjectPages(int tabSetId,PageIdType pageId)3450 void CegoObjectManager::freeObjectPages(int tabSetId, PageIdType pageId)
3451 {
3452 bool lastPage = false;
3453
3454 while ( ! lastPage )
3455 {
3456 if ( pageId == 0 )
3457 {
3458 lastPage = true;
3459 }
3460 else
3461 {
3462 CegoBufferPage delPage;
3463
3464 _pDBMng->bufferFix(delPage,
3465 tabSetId,
3466 pageId,
3467 CegoBufferPool::SYNC, _pLockHandle);
3468
3469 pageId = delPage.getNextPageId();
3470
3471 _pDBMng->bufferRelease(delPage, _pLockHandle);
3472
3473 }
3474 }
3475 }
3476
traceObjectPages(int tabSetId,PageIdType pageId)3477 int CegoObjectManager::traceObjectPages(int tabSetId, PageIdType pageId)
3478 {
3479 bool lastPage = false;
3480
3481 int pageCount = 0;
3482
3483 while ( ! lastPage )
3484 {
3485 if ( pageId == 0 )
3486 {
3487 lastPage = true;
3488 }
3489 else
3490 {
3491 CegoBufferPage tracePage;
3492
3493 _pDBMng->bufferFix(tracePage,
3494 tabSetId,
3495 pageId,
3496 CegoBufferPool::SYNC, _pLockHandle);
3497
3498 _pDBMng->commitPageEntry(pageId);
3499
3500 pageCount++;
3501
3502 pageId = tracePage.getNextPageId();
3503
3504 _pDBMng->bufferUnfix(tracePage, false, _pLockHandle);
3505 }
3506 }
3507
3508 return pageCount;
3509 }
3510
3511
countObjectPages(int tabSetId,PageIdType pageId)3512 int CegoObjectManager::countObjectPages(int tabSetId, PageIdType pageId)
3513 {
3514 bool lastPage = false;
3515 int pageCount=0;
3516
3517 while ( ! lastPage )
3518 {
3519 if ( pageId == 0 )
3520 {
3521 lastPage = true;
3522 }
3523 else
3524 {
3525 CegoBufferPage countPage;
3526
3527 _pDBMng->bufferFix(countPage,
3528 tabSetId,
3529 pageId,
3530 CegoBufferPool::SYNC, _pLockHandle);
3531
3532 pageCount++;
3533
3534 int nextPageId = countPage.getNextPageId();
3535
3536 _pDBMng->bufferUnfix(countPage, false, _pLockHandle);
3537
3538 pageId = nextPageId;
3539 }
3540 }
3541
3542 return pageCount;
3543 }
3544
removeEmptyPages(int tabSetId,PageIdType pageId,PageIdType & newPageId,PageIdType & newLastPageId)3545 void CegoObjectManager::removeEmptyPages(int tabSetId, PageIdType pageId, PageIdType& newPageId, PageIdType& newLastPageId)
3546 {
3547 bool lastPage = false;
3548
3549 CegoBufferPage prevPage;
3550 CegoBufferPage chkPage;
3551
3552 newPageId = 0;
3553 newLastPageId = 0;
3554 bool isFirst = true;
3555
3556 while ( ! lastPage )
3557 {
3558 if ( pageId == 0 )
3559 {
3560 lastPage = true;
3561 }
3562 else
3563 {
3564 prevPage = chkPage;
3565
3566 bool isEmptyPage = true;
3567 PageIdType basePageId = pageId;
3568
3569 while ( isEmptyPage && ! lastPage )
3570 {
3571 _pDBMng->bufferFix(chkPage, tabSetId, pageId, CegoBufferPool::SYNC, _pLockHandle);
3572
3573 if ( chkPage.getNumEntries() > 0 )
3574 {
3575 isEmptyPage = false;
3576 if ( isFirst )
3577 {
3578 newPageId = pageId;
3579 isFirst = false;
3580 }
3581 newLastPageId = pageId;
3582 }
3583
3584 if ( isEmptyPage )
3585 {
3586 if ( chkPage.getNextPageId() == 0 )
3587 {
3588 lastPage = true;
3589 }
3590
3591 if ( isFirst == false || lastPage == false )
3592 {
3593 pageId = chkPage.getNextPageId();
3594 _pDBMng->bufferRelease(chkPage, _pLockHandle);
3595 }
3596 else
3597 {
3598 newPageId = pageId;
3599 }
3600 }
3601 }
3602
3603 if ( basePageId != pageId )
3604 {
3605 if ( prevPage.isFixed() )
3606 {
3607 prevPage.setNextPageId(pageId);
3608 _pDBMng->bufferUnfix(prevPage, true, _pLockHandle);
3609 }
3610 }
3611 else
3612 {
3613 if ( prevPage.isFixed() )
3614 {
3615 _pDBMng->bufferUnfix(prevPage, false, _pLockHandle);
3616 }
3617 }
3618 if ( lastPage == false )
3619 {
3620 pageId = chkPage.getNextPageId();
3621 }
3622 }
3623 }
3624
3625 if ( chkPage.isFixed() )
3626 {
3627 _pDBMng->bufferUnfix(chkPage, false, _pLockHandle);
3628 }
3629
3630 if ( newLastPageId == 0 )
3631 {
3632 newLastPageId = newPageId;
3633 }
3634 }
3635
insertPageData(int tabSetId,CegoObject::ObjectType type,PageIdType pageId,char * data,int dataSize,bool & isNewPage,bool allowWrite,bool doAppend)3636 CegoDataPointer CegoObjectManager::insertPageData(int tabSetId, CegoObject::ObjectType type, PageIdType pageId, char* data, int dataSize, bool& isNewPage, bool allowWrite, bool doAppend)
3637 {
3638 unsigned long long lockId = 0;
3639 CegoBufferPage bp;
3640
3641 try
3642 {
3643 isNewPage=false;
3644
3645 CegoBufferPool::FixMode fixMode = CegoBufferPool::SYNC;
3646
3647 if ( type == CegoObject::SYSTEM )
3648 {
3649 fixMode = CegoBufferPool::PERSISTENT;
3650 }
3651 if ( allowWrite )
3652 {
3653 fixMode = CegoBufferPool::NOSYNC;
3654 }
3655
3656 unsigned long long cpCount = _pDBMng->getCPCount();
3657
3658 _pDBMng->bufferFix(bp,
3659 tabSetId,
3660 pageId,
3661 fixMode, _pLockHandle);
3662
3663 bool inserted = false;
3664
3665 while ( ! inserted )
3666 {
3667 lockId = _pLockHandle->lockData(type, pageId, CegoLockHandler::WRITE);
3668
3669 char *pE = (char*)bp.newEntry(dataSize);
3670
3671 if (pE)
3672 {
3673 _pLockHandle->unlockData(type, lockId);
3674 lockId = 0;
3675
3676 memcpy(pE, data, dataSize);
3677 inserted = true;
3678
3679 CegoDataPointer dp(bp.getPageId(),
3680 (long long)pE - (long long)bp.getPagePtr());
3681
3682 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
3683
3684 /*
3685 if a checkpoint has occured before writing data to page,
3686 we have to force checkpoint again, since the log entry is ignored.
3687 This is important in case of crash recovery.
3688 */
3689
3690 if ( _pDBMng->getCPCount() > cpCount )
3691 {
3692 _pDBMng->log(_modId, Logger::NOTICE, Chain("Forced checkpoint by insertPageData"));
3693 _pDBMng->writeCheckPoint(tabSetId, true, Chain(""), 0, _pLockHandle);
3694 }
3695
3696 return dp;
3697 }
3698 else
3699 {
3700 // did we already allocate a new page with maximum available space
3701 // if so, the record len is too long
3702 if ( isNewPage == true )
3703 {
3704 throw Exception(EXLOC, Chain("Data entry of length ") + Chain(dataSize) + Chain(" exceeds maximum available space in page "));
3705 }
3706 pageId = bp.getNextPageId();
3707
3708 CegoBufferPage nbp;
3709
3710 if ( pageId == 0 )
3711 {
3712 getNewFilePage(nbp, tabSetId, type, allowWrite, doAppend);
3713
3714 isNewPage=true;
3715
3716 pageId = nbp.getPageId();
3717 bp.setNextPageId(pageId);
3718
3719 _pLockHandle->unlockData(type, lockId);
3720 lockId = 0;
3721
3722 _pDBMng->bufferUnfix(bp, true, _pLockHandle);
3723 }
3724 else
3725 {
3726 // release locked and fixed data page
3727 _pLockHandle->unlockData(type, lockId);
3728 lockId = 0;
3729
3730 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3731
3732 // fix next data page
3733 _pDBMng->bufferFix(nbp, tabSetId, pageId, fixMode, _pLockHandle);
3734 }
3735
3736 bp = nbp;
3737 }
3738 }
3739 throw Exception(EXLOC, Chain("Cannot allocate bufferpage"));
3740 }
3741 catch ( Exception e )
3742 {
3743 if ( bp.isFixed() )
3744 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3745
3746 if ( lockId )
3747 _pLockHandle->unlockData(type, lockId);
3748
3749 throw e;
3750 }
3751 }
3752
getNewFilePage(CegoBufferPage & bp,int tabSetId,CegoObject::ObjectType type,bool allowWrite,bool doAppend)3753 void CegoObjectManager::getNewFilePage(CegoBufferPage& bp, int tabSetId, CegoObject::ObjectType type, bool allowWrite, bool doAppend)
3754 {
3755 CegoBufferPool::FixMode fixMode;
3756 CegoFileHandler::FileType fileType;
3757
3758 if ( type == CegoObject::SYSTEM)
3759 {
3760 fixMode = CegoBufferPool::PERSISTENT;
3761 fileType = CegoFileHandler::SYSTEMFILE;
3762 }
3763 else if ( type == CegoObject::TABLE
3764 || type == CegoObject::UAVLTREE
3765 || type == CegoObject::PAVLTREE
3766 || type == CegoObject::AVLTREE
3767 || type == CegoObject::UBTREE
3768 || type == CegoObject::PBTREE
3769 || type == CegoObject::BTREE
3770 || type == CegoObject::VIEW)
3771 {
3772 if ( allowWrite )
3773 fixMode = CegoBufferPool::NOSYNC;
3774 else
3775 fixMode = CegoBufferPool::SYNC;
3776
3777 fileType = CegoFileHandler::DATAFILE;
3778 }
3779 else if ( type == CegoObject::RBSEG )
3780 {
3781 fixMode = CegoBufferPool::SYNC;
3782 fileType = CegoFileHandler::TEMP;
3783 }
3784 else
3785 {
3786 throw Exception(EXLOC, Chain("Invalid object type to allocate page"));
3787 }
3788
3789 _pDBMng->emptyFix(bp, tabSetId, fixMode, fileType, _pLockHandle, doAppend);
3790 }
3791
getPageCount(int tabSetId,const Chain & objName,CegoObject::ObjectType type)3792 int CegoObjectManager::getPageCount(int tabSetId, const Chain& objName, CegoObject::ObjectType type)
3793 {
3794 CegoBufferPage bp;
3795 unsigned long long lockId = 0;
3796
3797 try
3798 {
3799 int pageCount=0;
3800 bool notFound = true;
3801
3802 CegoBufferPool::FixMode lockMode;
3803 if ( type == CegoObject::SYSTEM )
3804 {
3805 lockMode = CegoBufferPool::PERSISTENT;
3806 }
3807 else
3808 {
3809 lockMode = CegoBufferPool::SYNC;
3810 }
3811
3812 PageIdType pageOffset;
3813
3814 if ( type == CegoObject::RBSEG )
3815 {
3816 pageOffset = _pDBMng->getTempPageOffset(tabSetId);
3817 }
3818 else
3819 {
3820 pageOffset = _pDBMng->getSysPageOffset(tabSetId);
3821 }
3822
3823 PageIdType lowPage;
3824 PageIdType highPage;
3825
3826 getHashPageId(objName, type, lowPage, highPage);
3827
3828 for ( PageIdType hashPage = lowPage; hashPage < highPage ; hashPage++)
3829 {
3830 PageIdType pageId = pageOffset + hashPage;
3831
3832 bool lastPage = false;
3833
3834 while ( ! lastPage && notFound )
3835 {
3836 _pDBMng->bufferFix(bp, tabSetId, pageId, lockMode, _pLockHandle);
3837
3838 lockId = _pLockHandle->lockSysPage(pageId, CegoLockHandler::READ);
3839
3840 char* pE = (char*)bp.getFirstEntry();
3841
3842 while (pE && notFound )
3843 {
3844 CegoObject obj;
3845
3846 int size;
3847 obj.decodeBase(pE, size);
3848
3849 bool typeMatch =
3850 ( type == CegoObject::AVLTREE && ( obj.getType() == CegoObject::AVLTREE
3851 || obj.getType() == CegoObject::PAVLTREE
3852 || obj.getType() == CegoObject::UAVLTREE )) ||
3853 ( type == CegoObject::BTREE && ( obj.getType() == CegoObject::BTREE
3854 || obj.getType() == CegoObject::PBTREE
3855 || obj.getType() == CegoObject::UBTREE ));
3856
3857 if ( ! typeMatch )
3858 typeMatch = obj.getType() == type;
3859
3860 if ( typeMatch && objName == obj.getName() )
3861 {
3862 if ( type == CegoObject::FKEY )
3863 {
3864 pageCount=0;
3865 }
3866 else if ( type == CegoObject::BTREE
3867 || type == CegoObject::PBTREE
3868 || type == CegoObject::UBTREE )
3869 {
3870 CegoBTreeObject bto;
3871
3872 bto.decode(pE);
3873
3874 _pLockHandle->unlockSysPage(lockId);
3875 lockId = 0;
3876
3877 notFound = false;
3878
3879 pageId = bto.getDataPageId();
3880
3881 CegoBTreeManager btreeMng(this, &bto);
3882
3883 if ( pageId == 0 )
3884 {
3885 pageCount=0;
3886 }
3887 else
3888 {
3889 pageCount = btreeMng.getNumPages();
3890 }
3891 }
3892 else
3893 {
3894 CegoTableObject to;
3895
3896 to.decode(pE);
3897
3898 _pLockHandle->unlockSysPage(lockId);
3899 lockId = 0;
3900
3901 notFound = false;
3902
3903 pageId = to.getDataPageId();
3904
3905 pageCount = countObjectPages(tabSetId, pageId);
3906 }
3907 }
3908 if ( notFound )
3909 pE = (char*)bp.getNextEntry();
3910 }
3911
3912 pageId = bp.getNextPageId();
3913
3914 if (notFound)
3915 {
3916 _pLockHandle->unlockSysPage(lockId);
3917 lockId = 0;
3918 }
3919
3920 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3921
3922 if ( pageId == 0 )
3923 {
3924 lastPage = true;
3925 }
3926 }
3927 }
3928
3929 if ( notFound )
3930 {
3931 Chain msg = Chain("Object ") + objName + Chain(" not found");
3932 throw Exception(EXLOC, msg);
3933 }
3934
3935 return pageCount;
3936 }
3937 catch ( Exception e )
3938 {
3939 if ( bp.isFixed() )
3940 _pDBMng->bufferUnfix(bp, false, _pLockHandle);
3941
3942 if ( lockId )
3943 _pLockHandle->unlockSysPage(lockId);
3944
3945 throw e;
3946 }
3947 }
3948
getHashPageId(const Chain & objName,const CegoObject::ObjectType objType,PageIdType & lowPageId,PageIdType & highPageId)3949 void CegoObjectManager::getHashPageId(const Chain& objName, const CegoObject::ObjectType objType, PageIdType& lowPageId, PageIdType& highPageId)
3950 {
3951 if ( objType == CegoObject::AVLTREE
3952 || objType == CegoObject::PAVLTREE
3953 || objType == CegoObject::UAVLTREE
3954 || objType == CegoObject::BTREE
3955 || objType == CegoObject::PBTREE
3956 || objType == CegoObject::UBTREE
3957 || objType == CegoObject::FKEY
3958 || objType == CegoObject::CHECK )
3959 {
3960 lowPageId = 0;
3961 highPageId = TABMNG_HASHSIZE;
3962 }
3963 else
3964 {
3965 lowPageId = objName.getHashPos(TABMNG_HASHSIZE);
3966 highPageId = lowPageId + 1;
3967 }
3968 }
3969