?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
memory leak removed.
[csql.git] / src / server / TableImpl.cxx
blob290ee5b9d2d929dab42cb0ac1295a3e37af58397
1 /***************************************************************************
2 * Copyright (C) 2007 by www.databasecache.com *
3 * Contact: praba_tuty@databasecache.com *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 ***************************************************************************/
16 #include<Index.h>
17 #include<CatalogTables.h>
18 #include<Lock.h>
19 #include<Debug.h>
20 #include<Table.h>
21 #include<TableImpl.h>
22 #include<Predicate.h>
23 #include<PredicateImpl.h>
24 #include<Index.h>
25 #include<Config.h>
26
27 DbRetVal TableImpl::bindFld(const char *name, void *val)
28 {
29 //set it in the field list
30 DbRetVal rv = fldList_.updateBindVal(name, val);
31 if (OK != rv) {
32 printError(ErrNotExists, "Field %s does not exist", name);
33 return rv;
34 }
35 return OK;
36 }
37
38 bool TableImpl::isFldNull(const char *name){
39 int colpos = fldList_.getFieldPosition(name);
40 if (-1 == colpos)
41 {
42 printError(ErrNotExists, "Field %s does not exist", name);
43 return false;
44 }
45
46 return isFldNull(colpos);
47 }
48
49 bool TableImpl::isFldNull(int colpos)
50 {
51 if (!curTuple_) return false;
52 if (colpos <1 || colpos > numFlds_) return false;
53 char *nullOffset = (char*)curTuple_ - 4;
54 if (isIntUsedForNULL) {
55 int nullVal = *(int*)((char*)curTuple_ + (length_ - 4));
56 if (BITSET(nullVal, colpos)) return true;
57 }
58 else {
59 char *nullOffset = (char*)curTuple_ - os::align(numFlds_);
60 if (nullOffset[colpos-1]) return true;
61 }
62 return false;
63 }
64 void TableImpl::markFldNull(char const* name)
65 {
66 int colpos = fldList_.getFieldPosition(name);
67 if (-1 == colpos)
68 {
69 printError(ErrNotExists, "Field %s does not exist", name);
70 return;
71 }
72 markFldNull(colpos);
73 }
74
75 void TableImpl::markFldNull(int fldpos)
76 {
77 if (fldpos <1 || fldpos > numFlds_) return;
78 if (isIntUsedForNULL) {
79 if (!BITSET(iNotNullInfo, fldpos)) SETBIT(iNullInfo, fldpos);
80 }
81 else
82 if (!BITSET(iNotNullInfo, fldpos)) cNullInfo[fldpos-1] = 1;
83 return;
84 }
85
86 void TableImpl::clearFldNull(const char *name)
87 {
88 int colpos = fldList_.getFieldPosition(name);
89 if (-1 == colpos)
90 {
91 printError(ErrNotExists, "Field %s does not exist", name);
92 return;
93 }
94
95 clearFldNull(colpos);
96 }
97
98 void TableImpl::clearFldNull(int colpos)
99 {
100 if (colpos <1 || colpos > numFlds_) return;
101 if (isIntUsedForNULL) {
102 CLEARBIT(iNullInfo, colpos);
103 }
104 else
105 cNullInfo[colpos-1] = 0;
106 return;
107 }
108
109
110 DbRetVal TableImpl::execute()
111 {
112 if (NULL != iter)
113 {
114 printError(ErrAlready,"Scan already open:Close and re execute");
115 return ErrAlready;
116 }
117 //table ptr is set in predicate because it needs to access the
118 //type and length to evaluate
119 if( NULL != pred_)
120 {
121 PredicateImpl *pred = (PredicateImpl*) pred_;
122 pred->setTable(this);
123 }
124 DbRetVal ret = OK;
125
126 ret = createPlan();
127 if (OK != ret)
128 {
129 printError(ErrSysInternal,"Unable to create the plan");
130 return ErrSysInternal;
131 }
132 if (useIndex_ >= 0)
133 iter = new TupleIterator(pred_, scanType_, idxInfo[useIndex_], chunkPtr_, sysDB_->procSlot);
134 else if (scanType_ == fullTableScan)
135 iter = new TupleIterator(pred_, scanType_, NULL, chunkPtr_, sysDB_->procSlot);
136 else
137 {
138 printError(ErrSysFatal,"Unable to create tuple iterator");//should never happen
139 return ErrSysFatal;
140 }
141 ret = iter->open();
142 if (OK != ret)
143 {
144 printError(ErrSysInternal,"Unable to open the iterator");
145 return ErrSysInternal;
146 }
147 return OK;
148 }
149
150
151 DbRetVal TableImpl::createPlan()
152 {
153 if (isPlanCreated) {
154 //will do early return here. plan is generated only when setPredicate is called.
155 if (scanType_ == unknownScan) return ErrSysFatal; //this should never happen
156 else return OK;
157 }
158 useIndex_ = -1;
159 //if there are no predicates then go for full scan
160 //if there are no indexes then go for full scan
161 if (NULL == pred_ || NULL == indexPtr_)
162 {
163 scanType_ = fullTableScan;
164 isPlanCreated = true;
165 return OK;
166 }
167 if (NULL != indexPtr_)
168 {
169 PredicateImpl *pred = (PredicateImpl*)pred_;
170 printDebug(DM_Predicate, "predicate does not involve NOT , OR operator");
171 if (!pred->isNotOrInvolved())
172 {
173 printDebug(DM_Predicate, "predicate does not involve NOT , OR operator");
174 for (int i =0; i < numIndexes_; i++)
175 {
176 char *fName = ((SingleFieldHashIndexInfo*)idxInfo[i])->fldName;
177 if (pred->pointLookupInvolved(fName))
178 {
179 printDebug(DM_Predicate, "point lookup involved for field %s",fName);
180 scanType_ = hashIndexScan;
181 useIndex_ = i;
182 isPlanCreated = true;
183 return OK;
184 }
185 }
186 }
187 }
188 scanType_ = fullTableScan;
189 isPlanCreated = true;
190 return OK;
191 }
192
193 void* TableImpl::fetch()
194 {
195 fetchNoBind();
196 if (NULL == curTuple_) return curTuple_;
197 copyValuesToBindBuffer(curTuple_);
198 return curTuple_;
199 }
200 void* TableImpl::fetch(DbRetVal &rv)
201 {
202 fetchNoBind(rv);
203 if (NULL == curTuple_) return curTuple_;
204 copyValuesToBindBuffer(curTuple_);
205 return curTuple_;
206 }
207
208 void* TableImpl::fetchNoBind()
209 {
210 if (NULL == iter)
211 {
212 printError(ErrNotOpen,"Scan not open or Scan is closed\n");
213 return NULL;
214 }
215 curTuple_ = iter->next();
216 if (NULL == curTuple_)
217 {
218 return NULL;
219 }
220 DbRetVal lockRet = OK;
221 if ((*trans)->isoLevel_ == READ_REPEATABLE) {
222 lockRet = lMgr_->getSharedLock(curTuple_, trans);
223 if (OK != lockRet)
224 {
225 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
226 curTuple_ = NULL;
227 return NULL;
228 }
229
230 }
231 else if ((*trans)->isoLevel_ == READ_COMMITTED)
232 {
233 //if iso level is read committed, operation duration lock is sufficent
234 //so release it here itself.
235 int tries = 5;
236 struct timeval timeout;
237 timeout.tv_sec = Conf::config.getMutexSecs();
238 timeout.tv_usec = Conf::config.getMutexUSecs();
239
240 bool status = false;
241 while(true) {
242 lockRet = lMgr_->isExclusiveLocked( curTuple_, trans, status);
243 if (OK != lockRet)
244 {
245 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
246 curTuple_ = NULL;
247 return NULL;
248 }
249 if (!status) break;
250 tries--;
251 if (tries == 0) break;
252 os::select(0, 0, 0, 0, &timeout);
253
254 }
255 if (tries == 0)
256 {
257 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
258 curTuple_ = NULL;
259 return NULL;
260 }
261 }
262 return curTuple_;
263 }
264
265 void* TableImpl::fetchNoBind(DbRetVal &rv)
266 {
267 rv = OK;
268 if (NULL == iter)
269 {
270 printError(ErrNotOpen,"Scan not open or Scan is closed\n");
271 rv = ErrNotOpen;
272 return NULL;
273 }
274 curTuple_ = iter->next();
275 if (NULL == curTuple_)
276 {
277 return NULL;
278 }
279 DbRetVal lockRet = OK;
280 if ((*trans)->isoLevel_ == READ_REPEATABLE) {
281 lockRet = lMgr_->getSharedLock(curTuple_, trans);
282 if (OK != lockRet)
283 {
284 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
285 curTuple_ = NULL;
286 rv = ErrLockTimeOut;
287 return NULL;
288 }
289
290 }
291 else if ((*trans)->isoLevel_ == READ_COMMITTED)
292 {
293 //if iso level is read committed, operation duration lock is sufficent
294 //so release it here itself.
295 int tries = 5;
296 struct timeval timeout;
297 timeout.tv_sec = Conf::config.getMutexSecs();
298 timeout.tv_usec = Conf::config.getMutexUSecs();
299
300 bool status = false;
301 while(true) {
302 lockRet = lMgr_->isExclusiveLocked( curTuple_, trans, status);
303 if (OK != lockRet)
304 {
305 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
306 curTuple_ = NULL;
307 rv = ErrLockTimeOut;
308 return NULL;
309 }
310 if (!status) break;
311 tries--;
312 if (tries == 0) break;
313 os::select(0, 0, 0, 0, &timeout);
314
315 }
316 if (tries == 0)
317 {
318 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
319 curTuple_ = NULL;
320 rv = ErrLockTimeOut;
321 return NULL;
322 }
323 }
324 return curTuple_;
325 }
326
327 DbRetVal TableImpl::insertTuple()
328 {
329 DbRetVal ret =OK;
330 void *tptr = ((Chunk*)chunkPtr_)->allocate(db_, &ret);
331 if (NULL == tptr)
332 {
333 printError(ret, "Unable to allocate from chunk");
334 return ret;
335 }
336
337 ret = lMgr_->getExclusiveLock(tptr, trans);
338 if (OK != ret)
339 {
340 ((Chunk*)chunkPtr_)->free(db_, tptr);
341 printError(ret, "Could not get lock for the insert tuple %x", tptr);
342 return ErrLockTimeOut;
343 }
344
345
346 ret = copyValuesFromBindBuffer(tptr);
347 if (ret != OK)
348 {
349 printError(ret, "Unable to copy values from bind buffer");
350 (*trans)->removeFromHasList(db_, tptr);
351 lMgr_->releaseLock(tptr);
352 ((Chunk*)chunkPtr_)->free(db_, tptr);
353 return ret;
354 }
355
356 int addSize = 0;
357 if (numFlds_ < 31)
358 {
359 addSize = 4;
360 *(int*)((char*)(tptr) + (length_-addSize)) = iNullInfo;
361 }
362 else
363 {
364 addSize = os::align(numFlds_);
365 os::memcpy(((char*)(tptr) + (length_-addSize)), cNullInfo, addSize);
366
367 }
368 //int tupleSize = length_ + addSize;
369 if (NULL != indexPtr_)
370 {
371 int i;
372 //it has index
373 for (i = 0; i < numIndexes_ ; i++)
374 {
375 ret = insertIndexNode(*trans, indexPtr_[i], idxInfo[i], tptr);
376 if (ret != OK) { printError(ret, "Error in inserting to index"); break;}
377 }
378 if (i != numIndexes_ )
379 {
380 for (int j = 0; j < i ; j++)
381 deleteIndexNode(*trans, indexPtr_[j], idxInfo[j], tptr);
382 lMgr_->releaseLock(tptr);
383 (*trans)->removeFromHasList(db_, tptr);
384 ((Chunk*)chunkPtr_)->free(db_, tptr);
385 printError(ret, "Unable to insert index node for tuple %x", tptr);
386 return ret;
387 }
388 }
389 if (undoFlag)
390 ret = (*trans)->appendUndoLog(sysDB_, InsertOperation, tptr, length_);
391 return ret;
392 }
393
394 DbRetVal TableImpl::deleteTuple()
395 {
396 if (NULL == curTuple_)
397 {
398 printError(ErrNotOpen, "Scan not open: No Current tuple");
399 return ErrNotOpen;
400 }
401 DbRetVal ret = lMgr_->getExclusiveLock(curTuple_, trans);
402 if (OK != ret)
403 {
404 printError(ret, "Could not get lock for the delete tuple %x", curTuple_);
405 return ErrLockTimeOut;
406 }
407
408 if (NULL != indexPtr_)
409 {
410 int i;
411 //it has index
412 for (i = 0; i < numIndexes_ ; i++)
413 {
414 ret = deleteIndexNode(*trans, indexPtr_[i], idxInfo[i], curTuple_);
415 if (ret != OK) break;
416 }
417 if (i != numIndexes_ )
418 {
419 for (int j = 0; j < i ; j++)
420 insertIndexNode(*trans, indexPtr_[j], idxInfo[j], curTuple_);
421 lMgr_->releaseLock(curTuple_);
422 (*trans)->removeFromHasList(db_, curTuple_);
423 printError(ret, "Unable to insert index node for tuple %x", curTuple_);
424 return ret;
425 }
426 }
427 ((Chunk*)chunkPtr_)->free(db_, curTuple_);
428 if (undoFlag)
429 ret = (*trans)->appendUndoLog(sysDB_, DeleteOperation, curTuple_, length_);
430 return ret;
431 }
432
433 int TableImpl::deleteWhere()
434 {
435 int tuplesDeleted = 0;
436 DbRetVal rv = OK;
437 rv = execute();
438 if (rv !=OK) return (int) rv;
439 while(true){
440 fetchNoBind( rv);
441 if (rv != OK) { tuplesDeleted = (int)rv; break; }
442 if (NULL == curTuple_) break;
443 rv = deleteTuple();
444 if (rv != OK) {
445 printError(rv, "Error: Could only delete %d tuples", tuplesDeleted);
446 close();
447 return (int) rv;
448 }
449 tuplesDeleted++;
450 }
451 close();
452 return tuplesDeleted;
453 }
454
455 int TableImpl::truncate()
456 {
457 //take exclusive lock on the table
458 //get the chunk ptr of the table
459 //traverse the tablechunks and free all the pages except the first one
460 //get the chunk ptr of all its indexes
461 //traverse the indexchunks and free all the pages except the first one
462 //release table lock
463
464 //TEMPORARY FIX
465 DbRetVal rv = OK;
466 Predicate* tmpPred = pred_;
467 pred_ = NULL;
468 isPlanCreated = false;
469 int tuplesDeleted = deleteWhere();
470 isPlanCreated = false;
471 pred_ = tmpPred;
472 return tuplesDeleted;
473 }
474
475 DbRetVal TableImpl::updateTuple()
476 {
477 if (NULL == curTuple_)
478 {
479 printError(ErrNotOpen, "Scan not open: No Current tuple");
480 return ErrNotOpen;
481 }
482 DbRetVal ret = lMgr_->getExclusiveLock(curTuple_, trans);
483 if (OK != ret)
484 {
485 printError(ret, "Could not get lock for the update tuple %x", curTuple_);
486 return ErrLockTimeOut;
487 }
488 if (NULL != indexPtr_)
489 {
490 //it has index
491 //TODO::If it fails while updating index node, we have to undo all the updates
492 //on other indexes on the table.Currently it will leave the database in an
493 //inconsistent state.
494 for (int i = 0; i < numIndexes_ ; i++)
495 {
496 ret = updateIndexNode(*trans, indexPtr_[i], idxInfo[i], curTuple_);
497 if (ret != OK)
498 {
499 lMgr_->releaseLock(curTuple_);
500 (*trans)->removeFromHasList(db_, curTuple_);
501 printError(ret, "Unable to update index node for tuple %x", curTuple_);
502 return ret;
503 }
504 }
505 }
506 if (undoFlag)
507 ret = (*trans)->appendUndoLog(sysDB_, UpdateOperation, curTuple_, length_);
508 if (ret != OK) return ret;
509 int addSize = 0;
510 if (numFlds_ < 31)
511 {
512 addSize = 4;
513 *(int*)((char*)(curTuple_) + (length_-addSize)) |= iNullInfo;
514 }
515 else
516 {
517 addSize = os::align(numFlds_);
518 //TODO::Do not do blind memcpy. It should OR each and every char
519 //os::memcpy(((char*)(curTuple_) + (length_-addSize)), cNullInfo, addSize);
520
521 }
522
523 DbRetVal rv = copyValuesFromBindBuffer(curTuple_, false);
524 if (rv != OK) {
525 lMgr_->releaseLock(curTuple_);
526 (*trans)->removeFromHasList(db_, curTuple_);
527 return rv;
528 }
529 return OK;
530 }
531
532 void TableImpl::printInfo()
533 {
534 printf(" <TableName> %s </TableName>\n", tblName_);
535 printf(" <TupleCount> %d </TupleCount>\n", numTuples());
536 printf(" <PagesUsed> %d </PagesUsed>\n", pagesUsed());
537 printf(" <SpaceUsed> %d </SpaceUsed>\n", spaceUsed());
538 printf(" <Indexes> %d <Indexes>\n", numIndexes_);
539 printf(" <TupleLength> %d </TupleLength>\n", length_);
540 printf(" <Fields> %d </Fields>\n", numFlds_);
541 printf(" <Indexes>\n");
542 for (int i =0; i<numIndexes_; i++)
543 printf("<IndexName> %s </IndexName>\n", CatalogTableINDEX::getName(indexPtr_[i]));
544 printf(" </Indexes>\n");
545
546 }
547
548 DbRetVal TableImpl::copyValuesFromBindBuffer(void *tuplePtr, bool isInsert)
549 {
550 //Iterate through the bind list and copy the value here
551 FieldIterator fIter = fldList_.getIterator();
552 char *colPtr = (char*) tuplePtr;
553 int fldpos=1;
554 while (fIter.hasElement())
555 {
556 FieldDef def = fIter.nextElement();
557 if (def.isNull_ && !def.isDefault_ && NULL == def.bindVal_ && isInsert)
558 {
559 printError(ErrNullViolation, "NOT NULL constraint violation for field %s\n", def.fldName_);
560 return ErrNullViolation;
561 }
562 if (def.isDefault_ && NULL == def.bindVal_ && isInsert)
563 {
564 void *dest = AllDataType::alloc(def.type_, def.length_);
565 AllDataType::convert(typeString, def.defaultValueBuf_, def.type_, dest);
566 AllDataType::copyVal(colPtr, dest, def.type_, def.length_);
567 colPtr = colPtr + os::align(AllDataType::size(def.type_, def.length_));
568 fldpos++;
569 free (dest);
570 continue;
571 }
572 switch(def.type_)
573 {
574 case typeString:
575 if (NULL != def.bindVal_)
576 {
577 strcpy((char*)colPtr, (char*)def.bindVal_);
578 *(((char*)colPtr) + (def.length_-1)) = '\0';
579 }
580 else if (!def.isNull_ && isInsert) setNullBit(fldpos);
581 colPtr = colPtr + os::align(def.length_);
582 break;
583 case typeBinary:
584 if (NULL != def.bindVal_ )
585 os::memcpy((char*)colPtr, (char*)def.bindVal_, def.length_);
586 else if (!def.isNull_ && isInsert) setNullBit(fldpos);
587 colPtr = colPtr + os::align(def.length_);
588 break;
589 default:
590 if (NULL != def.bindVal_)
591 AllDataType::copyVal(colPtr, def.bindVal_, def.type_);
592 else { if (!def.isNull_ && isInsert) setNullBit(fldpos); }
593 colPtr = colPtr + os::align(AllDataType::size(def.type_));
594 break;
595 }
596 fldpos++;
597 }
598 return OK;
599 }
600 void TableImpl::setNullBit(int fldpos)
601 {
602 if (isIntUsedForNULL)
603 SETBIT(iNullInfo, fldpos);
604 else
605 cNullInfo[fldpos-1] = 1;
606 }
607 DbRetVal TableImpl::copyValuesToBindBuffer(void *tuplePtr)
608 {
609 //Iterate through the bind list and copy the value here
610 FieldIterator fIter = fldList_.getIterator();
611 char *colPtr = (char*) tuplePtr;
612 while (fIter.hasElement())
613 {
614 FieldDef def = fIter.nextElement();
615 switch(def.type_)
616 {
617 case typeString:
618 if (NULL != def.bindVal_)
619 strcpy((char*)def.bindVal_, (char*)colPtr);
620 colPtr = colPtr + os::align(def.length_);
621 break;
622 case typeBinary:
623 if (NULL != def.bindVal_)
624 os::memcpy((char*)def.bindVal_, (char*)colPtr, def.length_);
625 colPtr = colPtr + os::align(def.length_);
626 break;
627 default:
628 if (NULL != def.bindVal_)
629 AllDataType::copyVal(def.bindVal_, colPtr, def.type_);
630 colPtr = colPtr + os::align(AllDataType::size(def.type_));
631 break;
632 }
633 }
634 return OK;
635 }
636
637 //-1 index not supported
638 DbRetVal TableImpl::insertIndexNode(Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple)
639 {
640 INDEX *iptr = (INDEX*)indexPtr;
641 DbRetVal ret = OK;
642 printDebug(DM_Table, "Inside insertIndexNode type %d", iptr->indexType_);
643 Index* idx = Index::getIndex(iptr->indexType_);
644 ret = idx->insert(this, tr, indexPtr, info, tuple,undoFlag);
645 return ret;
646 }
647
648 DbRetVal TableImpl::deleteIndexNode(Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple)
649 {
650 INDEX *iptr = (INDEX*)indexPtr;
651 DbRetVal ret = OK;
652 Index* idx = Index::getIndex(iptr->indexType_);
653 ret = idx->remove(this, tr, indexPtr, info, tuple, undoFlag);
654 return ret;
655 }
656 void TableImpl::printSQLIndexString()
657 {
658 CatalogTableINDEXFIELD cIndexField(sysDB_);
659 char fName[IDENTIFIER_LENGTH];
660 char *fldName = fName;
661 DataType type;
662 for (int i = 0; i < numIndexes_ ; i++)
663 {
664 INDEX *iptr = (INDEX*) indexPtr_[i];
665 cIndexField.getFieldNameAndType((void*)iptr, fldName, type);
666 printf("CREATE INDEX %s on %s ( %s ) ", iptr->indName_, getName(), fldName);
667 if (((SingleFieldHashIndexInfo*) idxInfo[i])->isUnique) printf(" UNIQUE;\n"); else printf(";\n");
668 }
669 }
670
671
672 DbRetVal TableImpl::updateIndexNode(Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple)
673 {
674 INDEX *iptr = (INDEX*)indexPtr;
675 DbRetVal ret = OK;
676 Index* idx = Index::getIndex(iptr->indexType_);
677 //TODO::currently it updates irrespective of whether the key changed or not
678 //because of this commenting the whole index update code. relook at it and uncomment
679
680 //ret = idx->update(this, tr, indexPtr, info, tuple, undoFlag);
681
682 return ret;
683 }
684
685
686 void TableImpl::setTableInfo(char *name, int tblid, size_t length,
687 int numFld, int numIdx, void *chunk)
688 {
689 strcpy(tblName_, name);
690 tblID_ = tblid;
691 length_ = length;
692 numFlds_ = numFld;
693 numIndexes_ = numIdx;
694 chunkPtr_ = chunk;
695 }
696
697 long TableImpl::spaceUsed()
698 {
699 Chunk *chk = (Chunk*)chunkPtr_;
700 long totSize = chk->getTotalDataNodes() * chk->getSize();
701 totSize = totSize + (chk->totalPages() * sizeof (PageInfo));
702 return totSize;
703 }
704
705 int TableImpl::pagesUsed()
706 {
707 Chunk *chk = (Chunk*)chunkPtr_;
708 return chk->totalPages();
709 }
710
711 long TableImpl::numTuples()
712 {
713 return ((Chunk*)chunkPtr_)->getTotalDataNodes();
714 }
715
716 List TableImpl::getFieldNameList()
717 {
718 List fldNameList;
719 FieldIterator fIter = fldList_.getIterator();
720 while (fIter.hasElement())
721 {
722 FieldDef def = fIter.nextElement();
723 Identifier *elem = new Identifier();
724 strcpy(elem->name, def.fldName_);
725 fldNameList.append(elem);
726 }
727 return fldNameList;
728 }
729 DbRetVal TableImpl::close()
730 {
731 if (NULL == iter)
732 {
733 printError(ErrNotOpen,"Scan not open");
734 return ErrNotOpen;
735 }
736 iter->close();
737 delete iter;
738 iter = NULL;
739 return OK;
740 }
741 DbRetVal TableImpl::lock(bool shared)
742 {
743
744 DbRetVal ret = OK;
745 /*
746 if (shared)
747 ret = lMgr_->getSharedLock(chunkPtr_, NULL);
748 else
749 ret = lMgr_->getExclusiveLock(chunkPtr_, NULL);
750 if (OK != ret)
751 {
752 printError(ret, "Could not exclusive lock on the table %x", chunkPtr_);
753 }else {
754 //do not append for S to X upgrade
755 if (!ProcessManager::hasLockList.exists(chunkPtr_))
756 ProcessManager::hasLockList.append(chunkPtr_);
757 }
758 */
759 return ret;
760 }
761 DbRetVal TableImpl::unlock()
762 {
763 /*
764 if (!ProcessManager::hasLockList.exists(chunkPtr_)) return OK;
765 DbRetVal ret = lMgr_->releaseLock(chunkPtr_);
766 if (OK != ret)
767 {
768 printError(ret, "Could not release exclusive lock on the table %x", chunkPtr_);
769 }else
770 {
771 ProcessManager::hasLockList.remove(chunkPtr_);
772 }
773 */
774 return OK;
775 }
776
777 TableImpl::~TableImpl()
778 {
779 if (NULL != iter ) { delete iter; iter = NULL; }
780 if (NULL != indexPtr_) { delete[] indexPtr_; indexPtr_ = NULL; }
781 if (NULL != idxInfo)
782 {
783 for (int i = 0; i < numIndexes_; i++) delete idxInfo[i];
784 delete[] idxInfo;
785 idxInfo = NULL;
786 }
787 if (numFlds_ > 31 && cNullInfo != NULL) { free(cNullInfo); cNullInfo = NULL; }
788
789 fldList_.removeAll();
790
791 }
Main memory database SQL engine (cvs import)