?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
error in parsing date and time leads to wrong value being inserted into the table
[csql.git] / src / server / TableImpl.cxx
blob710e10f05a51b74337169ddeae422a8eaa2a5cb0
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(ret,"Unable to open the iterator");
145 return ret;
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 HashIndexInfo* info = (HashIndexInfo*) idxInfo[i];
177 FieldIterator iter = info->idxFldList.getIterator();
178 while(iter.hasElement())
179 {
180 FieldDef def = iter.nextElement();
181 if (pred->pointLookupInvolved(def.fldName_))
182 {
183 printDebug(DM_Predicate, "point lookup involved for field %s",def.fldName_);
184 scanType_ = hashIndexScan;
185 isPlanCreated = true;
186 useIndex_ = i;
187 }
188 else
189 {
190 useIndex_ = -1;
191 break;
192 }
193 }//while iter.hasElement()
194 if (useIndex_ != -1) return OK;
195 }//for
196 }
197 }
198 scanType_ = fullTableScan;
199 isPlanCreated = true;
200 return OK;
201 }
202
203 void* TableImpl::fetch()
204 {
205 fetchNoBind();
206 if (NULL == curTuple_) return curTuple_;
207 copyValuesToBindBuffer(curTuple_);
208 return curTuple_;
209 }
210 void* TableImpl::fetch(DbRetVal &rv)
211 {
212 fetchNoBind(rv);
213 if (NULL == curTuple_) return curTuple_;
214 copyValuesToBindBuffer(curTuple_);
215 return curTuple_;
216 }
217
218 void* TableImpl::fetchNoBind()
219 {
220 if (NULL == iter)
221 {
222 printError(ErrNotOpen,"Scan not open or Scan is closed\n");
223 return NULL;
224 }
225 void *prevTuple = curTuple_;
226 curTuple_ = iter->next();
227 if (NULL == curTuple_)
228 {
229 return NULL;
230 }
231 DbRetVal lockRet = OK;
232 if ((*trans)->isoLevel_ == READ_REPEATABLE) {
233 lockRet = lMgr_->getSharedLock(curTuple_, trans);
234 if (OK != lockRet)
235 {
236 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
237 curTuple_ = prevTuple;
238 return NULL;
239 }
240
241 }
242 else if ((*trans)->isoLevel_ == READ_COMMITTED)
243 {
244 //if iso level is read committed, operation duration lock is sufficent
245 //so release it here itself.
246 int tries = 5;
247 struct timeval timeout;
248 timeout.tv_sec = Conf::config.getMutexSecs();
249 timeout.tv_usec = Conf::config.getMutexUSecs();
250
251 bool status = false;
252 while(true) {
253 lockRet = lMgr_->isExclusiveLocked( curTuple_, trans, status);
254 if (OK != lockRet)
255 {
256 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
257 curTuple_ = prevTuple;
258 return NULL;
259 }
260 if (!status) break;
261 tries--;
262 if (tries == 0) break;
263 os::select(0, 0, 0, 0, &timeout);
264
265 }
266 if (tries == 0)
267 {
268 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
269 curTuple_ = prevTuple;
270 return NULL;
271 }
272 }
273 return curTuple_;
274 }
275
276 void* TableImpl::fetchNoBind(DbRetVal &rv)
277 {
278 rv = OK;
279 if (NULL == iter)
280 {
281 printError(ErrNotOpen,"Scan not open or Scan is closed\n");
282 rv = ErrNotOpen;
283 return NULL;
284 }
285 void *prevTuple = curTuple_;
286 curTuple_ = iter->next();
287 if (NULL == curTuple_)
288 {
289 return NULL;
290 }
291 DbRetVal lockRet = OK;
292 if ((*trans)->isoLevel_ == READ_REPEATABLE) {
293 lockRet = lMgr_->getSharedLock(curTuple_, trans);
294 if (OK != lockRet)
295 {
296 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
297 rv = ErrLockTimeOut;
298 curTuple_ = prevTuple;
299 return NULL;
300 }
301
302 }
303 else if ((*trans)->isoLevel_ == READ_COMMITTED)
304 {
305 //if iso level is read committed, operation duration lock is sufficent
306 //so release it here itself.
307 int tries = 5;
308 struct timeval timeout;
309 timeout.tv_sec = Conf::config.getMutexSecs();
310 timeout.tv_usec = Conf::config.getMutexUSecs();
311
312 bool status = false;
313 while(true) {
314 lockRet = lMgr_->isExclusiveLocked( curTuple_, trans, status);
315 if (OK != lockRet)
316 {
317 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
318 curTuple_ = prevTuple;
319 rv = ErrLockTimeOut;
320 return NULL;
321 }
322 if (!status) break;
323 tries--;
324 if (tries == 0) break;
325 os::select(0, 0, 0, 0, &timeout);
326
327 }
328 if (tries == 0)
329 {
330 printError(lockRet, "Unable to get the lock for the tuple %x", curTuple_);
331 curTuple_ = prevTuple;
332 rv = ErrLockTimeOut;
333 return NULL;
334 }
335 }
336 return curTuple_;
337 }
338
339 DbRetVal TableImpl::insertTuple()
340 {
341 DbRetVal ret =OK;
342 void *tptr = ((Chunk*)chunkPtr_)->allocate(db_, &ret);
343 if (NULL == tptr)
344 {
345 printError(ret, "Unable to allocate record from chunk");
346 return ret;
347 }
348 ret = lMgr_->getExclusiveLock(tptr, trans);
349 if (OK != ret)
350 {
351 ((Chunk*)chunkPtr_)->free(db_, tptr);
352 printError(ret, "Could not get lock for the insert tuple %x", tptr);
353 return ErrLockTimeOut;
354 }
355
356
357 ret = copyValuesFromBindBuffer(tptr);
358 if (ret != OK)
359 {
360 printError(ret, "Unable to copy values from bind buffer");
361 (*trans)->removeFromHasList(db_, tptr);
362 lMgr_->releaseLock(tptr);
363 ((Chunk*)chunkPtr_)->free(db_, tptr);
364 return ret;
365 }
366
367 int addSize = 0;
368 if (numFlds_ < 31)
369 {
370 addSize = 4;
371 *(int*)((char*)(tptr) + (length_-addSize)) = iNullInfo;
372 }
373 else
374 {
375 addSize = os::align(numFlds_);
376 os::memcpy(((char*)(tptr) + (length_-addSize)), cNullInfo, addSize);
377
378 }
379 //int tupleSize = length_ + addSize;
380 if (NULL != indexPtr_)
381 {
382 int i;
383 //it has index
384 for (i = 0; i < numIndexes_ ; i++)
385 {
386 ret = insertIndexNode(*trans, indexPtr_[i], idxInfo[i], tptr);
387 if (ret != OK) { printError(ret, "Error in inserting to index"); break;}
388 }
389 if (i != numIndexes_ )
390 {
391 for (int j = 0; j < i ; j++) {
392 printError(ErrWarning, "Deleting index node");
393 deleteIndexNode(*trans, indexPtr_[j], idxInfo[j], tptr);
394 }
395 lMgr_->releaseLock(tptr);
396 (*trans)->removeFromHasList(db_, tptr);
397 ((Chunk*)chunkPtr_)->free(db_, tptr);
398 //PRABA::TEMP
399 //printError(ret, "Unable to insert index node for tuple %x ", tptr);
400 printError(ret, "Unable to insert index node for tuple %x %d", tptr, *(int*)tptr);
401 return ret;
402 }
403 }
404 if (undoFlag)
405 ret = (*trans)->appendUndoLog(sysDB_, InsertOperation, tptr, length_);
406 if (ret != OK) {
407 printError(ret, "Unable to create undo log for %x %d", tptr, *(int*)tptr);
408 for (int j = 0; j < numIndexes_ ; j++) {
409 printError(ErrWarning, "Deleting index node");
410 deleteIndexNode(*trans, indexPtr_[j], idxInfo[j], tptr);
411 }
412 lMgr_->releaseLock(tptr);
413 (*trans)->removeFromHasList(db_, tptr);
414 ((Chunk*)chunkPtr_)->free(db_, tptr);
415 }
416 return ret;
417 }
418
419 DbRetVal TableImpl::deleteTuple()
420 {
421 if (NULL == curTuple_)
422 {
423 printError(ErrNotOpen, "Scan not open: No Current tuple");
424 return ErrNotOpen;
425 }
426 DbRetVal ret = lMgr_->getExclusiveLock(curTuple_, trans);
427 if (OK != ret)
428 {
429 printError(ret, "Could not get lock for the delete tuple %x", curTuple_);
430 return ErrLockTimeOut;
431 }
432
433 if (NULL != indexPtr_)
434 {
435 int i;
436 //it has index
437 for (i = 0; i < numIndexes_ ; i++)
438 {
439 ret = deleteIndexNode(*trans, indexPtr_[i], idxInfo[i], curTuple_);
440 if (ret != OK) break;
441 }
442 if (i != numIndexes_ )
443 {
444 for (int j = 0; j < i ; j++)
445 insertIndexNode(*trans, indexPtr_[j], idxInfo[j], curTuple_);
446 lMgr_->releaseLock(curTuple_);
447 (*trans)->removeFromHasList(db_, curTuple_);
448 printError(ret, "Unable to insert index node for tuple %x", curTuple_);
449 return ret;
450 }
451 }
452 ((Chunk*)chunkPtr_)->free(db_, curTuple_);
453 if (undoFlag)
454 ret = (*trans)->appendUndoLog(sysDB_, DeleteOperation, curTuple_, length_);
455 return ret;
456 }
457
458 int TableImpl::deleteWhere()
459 {
460 int tuplesDeleted = 0;
461 DbRetVal rv = OK;
462 rv = execute();
463 if (rv !=OK) return (int) rv;
464 while(true){
465 fetchNoBind( rv);
466 if (rv != OK) { tuplesDeleted = (int)rv; break; }
467 if (NULL == curTuple_) break;
468 rv = deleteTuple();
469 if (rv != OK) {
470 printError(rv, "Error: Could only delete %d tuples", tuplesDeleted);
471 close();
472 return (int) rv;
473 }
474 tuplesDeleted++;
475 }
476 close();
477 return tuplesDeleted;
478 }
479
480 int TableImpl::truncate()
481 {
482 //take exclusive lock on the table
483 //get the chunk ptr of the table
484 //traverse the tablechunks and free all the pages except the first one
485 //get the chunk ptr of all its indexes
486 //traverse the indexchunks and free all the pages except the first one
487 //release table lock
488
489 //TEMPORARY FIX
490 DbRetVal rv = OK;
491 Predicate* tmpPred = pred_;
492 pred_ = NULL;
493 isPlanCreated = false;
494 int tuplesDeleted = deleteWhere();
495 isPlanCreated = false;
496 pred_ = tmpPred;
497 return tuplesDeleted;
498 }
499
500 DbRetVal TableImpl::updateTuple()
501 {
502 if (NULL == curTuple_)
503 {
504 printError(ErrNotOpen, "Scan not open: No Current tuple");
505 return ErrNotOpen;
506 }
507 DbRetVal ret = lMgr_->getExclusiveLock(curTuple_, trans);
508 if (OK != ret)
509 {
510 printError(ret, "Could not get lock for the update tuple %x", curTuple_);
511 return ErrLockTimeOut;
512 }
513 if (NULL != indexPtr_)
514 {
515 //it has index
516 //TODO::If it fails while updating index node, we have to undo all the updates
517 //on other indexes on the table.Currently it will leave the database in an
518 //inconsistent state.
519 for (int i = 0; i < numIndexes_ ; i++)
520 {
521 ret = updateIndexNode(*trans, indexPtr_[i], idxInfo[i], curTuple_);
522 if (ret != OK)
523 {
524 lMgr_->releaseLock(curTuple_);
525 (*trans)->removeFromHasList(db_, curTuple_);
526 printError(ret, "Unable to update index node for tuple %x", curTuple_);
527 return ret;
528 }
529 }
530 }
531 if (undoFlag)
532 ret = (*trans)->appendUndoLog(sysDB_, UpdateOperation, curTuple_, length_);
533 if (ret != OK) return ret;
534 int addSize = 0;
535 if (numFlds_ < 31)
536 {
537 addSize = 4;
538 *(int*)((char*)(curTuple_) + (length_-addSize)) |= iNullInfo;
539 }
540 else
541 {
542 addSize = os::align(numFlds_);
543 //TODO::Do not do blind memcpy. It should OR each and every char
544 //os::memcpy(((char*)(curTuple_) + (length_-addSize)), cNullInfo, addSize);
545
546 }
547
548 DbRetVal rv = copyValuesFromBindBuffer(curTuple_, false);
549 if (rv != OK) {
550 lMgr_->releaseLock(curTuple_);
551 (*trans)->removeFromHasList(db_, curTuple_);
552 return rv;
553 }
554 return OK;
555 }
556
557 void TableImpl::printInfo()
558 {
559 printf(" <TableName> %s </TableName>\n", tblName_);
560 printf(" <TupleCount> %d </TupleCount>\n", numTuples());
561 printf(" <PagesUsed> %d </PagesUsed>\n", pagesUsed());
562 printf(" <SpaceUsed> %d </SpaceUsed>\n", spaceUsed());
563 printf(" <Indexes> %d <Indexes>\n", numIndexes_);
564 printf(" <TupleLength> %d </TupleLength>\n", length_);
565 printf(" <Fields> %d </Fields>\n", numFlds_);
566 printf(" <Indexes>\n");
567 for (int i =0; i<numIndexes_; i++)
568 printf("<IndexName> %s </IndexName>\n", CatalogTableINDEX::getName(indexPtr_[i]));
569 printf(" </Indexes>\n");
570
571 }
572
573 DbRetVal TableImpl::copyValuesFromBindBuffer(void *tuplePtr, bool isInsert)
574 {
575 //Iterate through the bind list and copy the value here
576 FieldIterator fIter = fldList_.getIterator();
577 char *colPtr = (char*) tuplePtr;
578 int fldpos=1;
579 while (fIter.hasElement())
580 {
581 FieldDef def = fIter.nextElement();
582 if (def.isNull_ && !def.isDefault_ && NULL == def.bindVal_ && isInsert)
583 {
584 printError(ErrNullViolation, "NOT NULL constraint violation for field %s\n", def.fldName_);
585 return ErrNullViolation;
586 }
587 if (def.isDefault_ && NULL == def.bindVal_ && isInsert)
588 {
589 void *dest = AllDataType::alloc(def.type_, def.length_);
590 AllDataType::convert(typeString, def.defaultValueBuf_, def.type_, dest, def.length_);
591 AllDataType::copyVal(colPtr, dest, def.type_, def.length_);
592 colPtr = colPtr + os::align(AllDataType::size(def.type_, def.length_));
593 fldpos++;
594 free (dest);
595 continue;
596 }
597 switch(def.type_)
598 {
599 case typeString:
600 if (NULL != def.bindVal_)
601 {
602 strcpy((char*)colPtr, (char*)def.bindVal_);
603 *(((char*)colPtr) + (def.length_-1)) = '\0';
604 }
605 else if (!def.isNull_ && isInsert) setNullBit(fldpos);
606 colPtr = colPtr + os::align(def.length_);
607 break;
608 case typeBinary:
609 if (NULL != def.bindVal_ ) {
610 DbRetVal rv = AllDataType::strToValue(colPtr, (char *) def.bindVal_, def.type_, def.length_);
611 if (rv != OK) return ErrBadArg;
612 }
613 else if (!def.isNull_ && isInsert) setNullBit(fldpos);
614 colPtr = colPtr + os::align(def.length_);
615 break;
616 default:
617 if (NULL != def.bindVal_)
618 AllDataType::copyVal(colPtr, def.bindVal_, def.type_);
619 else { if (!def.isNull_ && isInsert) setNullBit(fldpos); }
620 colPtr = colPtr + os::align(AllDataType::size(def.type_));
621 break;
622 }
623 fldpos++;
624 }
625 return OK;
626 }
627 void TableImpl::setNullBit(int fldpos)
628 {
629 if (isIntUsedForNULL)
630 SETBIT(iNullInfo, fldpos);
631 else
632 cNullInfo[fldpos-1] = 1;
633 }
634 DbRetVal TableImpl::copyValuesToBindBuffer(void *tuplePtr)
635 {
636 //Iterate through the bind list and copy the value here
637 FieldIterator fIter = fldList_.getIterator();
638 char *colPtr = (char*) tuplePtr;
639 while (fIter.hasElement())
640 {
641 FieldDef def = fIter.nextElement();
642 if (NULL != def.bindVal_)
643 AllDataType::copyVal(def.bindVal_, colPtr, def.type_, def.length_);
644 colPtr = colPtr + os::align(AllDataType::size(def.type_, def.length_));
645 }
646 return OK;
647 }
648
649 //-1 index not supported
650 DbRetVal TableImpl::insertIndexNode(Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple)
651 {
652 INDEX *iptr = (INDEX*)indexPtr;
653 DbRetVal ret = OK;
654 printDebug(DM_Table, "Inside insertIndexNode type %d", iptr->indexType_);
655 Index* idx = Index::getIndex(iptr->indexType_);
656 ret = idx->insert(this, tr, indexPtr, info, tuple,undoFlag);
657 return ret;
658 }
659
660 DbRetVal TableImpl::deleteIndexNode(Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple)
661 {
662 INDEX *iptr = (INDEX*)indexPtr;
663 DbRetVal ret = OK;
664 Index* idx = Index::getIndex(iptr->indexType_);
665 ret = idx->remove(this, tr, indexPtr, info, tuple, undoFlag);
666 return ret;
667 }
668 void TableImpl::printSQLIndexString()
669 {
670 CatalogTableINDEXFIELD cIndexField(sysDB_);
671 char fName[IDENTIFIER_LENGTH];
672 char *fldName = fName;
673 DataType type;
674 for (int i = 0; i < numIndexes_ ; i++)
675 {
676 INDEX *iptr = (INDEX*) indexPtr_[i];
677 //cIndexField.getFieldNameAndType((void*)iptr, fldName, type);
678 //printf("CREATE INDEX %s on %s ( %s ) ", iptr->indName_, getName(), fldName);
679 printf("CREATE INDEX %s on %s ( ", iptr->indName_, getName());
680 FieldList fldList;
681 cIndexField.getFieldInfo(iptr, fldList);
682 FieldIterator fIter = fldList.getIterator();
683 bool firstFld = true;
684 while(fIter.hasElement())
685 {
686 FieldDef def = fIter.nextElement();
687 if (firstFld) { printf(" %s ", def.fldName_); firstFld = false; }
688 else printf(" ,%s ", def.fldName_);
689 }
690 printf(" ) ");
691 if (((HashIndexInfo*) idxInfo[i])->isUnique) printf(" UNIQUE;\n"); else printf(";\n");
692 }
693 }
694
695
696 DbRetVal TableImpl::updateIndexNode(Transaction *tr, void *indexPtr, IndexInfo *info, void *tuple)
697 {
698 INDEX *iptr = (INDEX*)indexPtr;
699 DbRetVal ret = OK;
700 Index* idx = Index::getIndex(iptr->indexType_);
701 //TODO::currently it updates irrespective of whether the key changed or not
702 //because of this commenting the whole index update code. relook at it and uncomment
703
704 ret = idx->update(this, tr, indexPtr, info, tuple, undoFlag);
705
706 return ret;
707 }
708
709
710 void TableImpl::setTableInfo(char *name, int tblid, size_t length,
711 int numFld, int numIdx, void *chunk)
712 {
713 strcpy(tblName_, name);
714 tblID_ = tblid;
715 length_ = length;
716 numFlds_ = numFld;
717 numIndexes_ = numIdx;
718 chunkPtr_ = chunk;
719 }
720
721 long TableImpl::spaceUsed()
722 {
723 Chunk *chk = (Chunk*)chunkPtr_;
724 long totSize = chk->getTotalDataNodes() * chk->getSize();
725 totSize = totSize + (chk->totalPages() * sizeof (PageInfo));
726 return totSize;
727 }
728
729 int TableImpl::pagesUsed()
730 {
731 Chunk *chk = (Chunk*)chunkPtr_;
732 return chk->totalPages();
733 }
734
735 long TableImpl::numTuples()
736 {
737 return ((Chunk*)chunkPtr_)->getTotalDataNodes();
738 }
739
740 List TableImpl::getFieldNameList()
741 {
742 List fldNameList;
743 FieldIterator fIter = fldList_.getIterator();
744 while (fIter.hasElement())
745 {
746 FieldDef def = fIter.nextElement();
747 Identifier *elem = new Identifier();
748 strcpy(elem->name, def.fldName_);
749 fldNameList.append(elem);
750 }
751 return fldNameList;
752 }
753 DbRetVal TableImpl::close()
754 {
755 if (NULL == iter)
756 {
757 printError(ErrNotOpen,"Scan not open");
758 return ErrNotOpen;
759 }
760 iter->close();
761 delete iter;
762 iter = NULL;
763 return OK;
764 }
765 DbRetVal TableImpl::lock(bool shared)
766 {
767
768 DbRetVal ret = OK;
769 /*
770 if (shared)
771 ret = lMgr_->getSharedLock(chunkPtr_, NULL);
772 else
773 ret = lMgr_->getExclusiveLock(chunkPtr_, NULL);
774 if (OK != ret)
775 {
776 printError(ret, "Could not exclusive lock on the table %x", chunkPtr_);
777 }else {
778 //do not append for S to X upgrade
779 if (!ProcessManager::hasLockList.exists(chunkPtr_))
780 ProcessManager::hasLockList.append(chunkPtr_);
781 }
782 */
783 return ret;
784 }
785 DbRetVal TableImpl::unlock()
786 {
787 /*
788 if (!ProcessManager::hasLockList.exists(chunkPtr_)) return OK;
789 DbRetVal ret = lMgr_->releaseLock(chunkPtr_);
790 if (OK != ret)
791 {
792 printError(ret, "Could not release exclusive lock on the table %x", chunkPtr_);
793 }else
794 {
795 ProcessManager::hasLockList.remove(chunkPtr_);
796 }
797 */
798 return OK;
799 }
800
801 TableImpl::~TableImpl()
802 {
803 if (NULL != iter ) { delete iter; iter = NULL; }
804 if (NULL != indexPtr_) { delete[] indexPtr_; indexPtr_ = NULL; }
805 if (NULL != idxInfo)
806 {
807 for (int i = 0; i < numIndexes_; i++) delete idxInfo[i];
808 delete[] idxInfo;
809 idxInfo = NULL;
810 }
811 if (numFlds_ > 31 && cNullInfo != NULL) { free(cNullInfo); cNullInfo = NULL; }
812
813 fldList_.removeAll();
814
815 }
Main memory database SQL engine (cvs import)