1 /***************************************************************************
2 * Copyright (C) 2007 by www.databasecache.com *
3 * Contact: praba_tuty@databasecache.com *
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. *
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. *
15 ***************************************************************************/
19 void* TreeIter::getFirstElement()
21 if (NULL
== iter
) return NULL
;
22 TreeNode
*node
= iter
;
24 if(NULL
== node
->prev_
) break;
27 if (node
== NULL
) printf("Node returned is NULL\n");
28 if (0 == node
->noElements_
) return NULL
;
29 char **rec
= (char**)((char*)node
+ sizeof(TreeNode
));
30 int loc
= 0; //first element
31 char **tuple
= (char**)((char*)rec
+ (loc
* sizeof(void *)));
35 void* TreeIter::getLastElement()
37 if (NULL
== iter
) return NULL
;
38 TreeNode
*node
= iter
;
39 while(node
!= NULL
) {
40 if(NULL
== node
->next_
) break;
43 if (node
== NULL
) printf("Node returned is NULL\n");
44 if (0 == node
->noElements_
) return NULL
;
45 char **rec
= (char**)((char*)node
+ sizeof(TreeNode
));
46 int loc
= node
->noElements_
-1; //last element
47 char **tuple
= (char**)((char*)rec
+ (loc
* sizeof(void *)));
51 void* TreeIter::prev()
60 if (NULL
== iter
) return NULL
;
61 nodeOffset
= iter
->noElements_
;
63 char **rec
= (char**)((char*)iter
+ sizeof(TreeNode
));
64 rec
= (char**)((char *)rec
+ ((nodeOffset
) * sizeof(void **)));
67 void TreeIter::nextNode()
69 if (recordsOver
) return ;
70 if (NULL
== iter
) return ;
71 TreeNode
*tmpIter
= iter
;
74 DbRetVal ret
= TreeIndex::getTreeNodeMutex(iter
, procSlot
);
77 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
78 tmpIter
->mutex_
.releaseShareLock(procSlot
);
82 tmpIter
->mutex_
.releaseShareLock(procSlot
);
86 void TreeIter::reset()
88 if(iter
&& !firstCall
) iter
->mutex_
.releaseShareLock(procSlot
);
94 void* TreeIter::next()
98 if(iter
) iter
->mutex_
.releaseShareLock(procSlot
);
102 if (NULL
== iter
) return NULL
;
105 if (OpLessThan
==op
|| OpLessThanEquals
== op
)
109 char **rec
= (char**)((char*) iter
+ sizeof(TreeNode
));
110 DbRetVal ret
= TreeIndex::getTreeNodeMutex(iter
, procSlot
);
113 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
116 //iter->displayAll(fldOffset);
119 else if (OpGreaterThan
== op
)
121 char *rec
= (char*)locateNode();
124 bool result
= AllDataType::compareVal(searchKey
, rec
+fldOffset
,
125 OpEquals
, type
, length
);
126 //equals comparision does not apply to float and double
127 if (result
|| type
==typeFloat
|| type
== typeDouble
) return next();
130 }else if (OpGreaterThanEquals
== op
)
132 void *rec
= locateNode();
135 }else if (OpEquals
== op
)
137 void *rec
= locateNode();
139 if(isUnique
) recordsOver
= true;
145 if (nodeOffset
== iter
->noElements_
)
147 if (NULL
== iter
->next_
) {
149 iter
->mutex_
.releaseShareLock(procSlot
);
153 char* record
= ((char*)iter
->next_
->min_
)+ fldOffset
;
154 bool result
= AllDataType::compareVal(searchKey
, record
,
157 if (!result
&& (OpLessThan
==op
|| OpLessThanEquals
== op
))
159 //Case: search key 10 , next node first record is 20
160 //condition is < or <=
162 iter
->mutex_
.releaseShareLock(procSlot
);
165 }else if (result
&& (OpGreaterThan
== op
||
166 OpGreaterThanEquals
== op
))
168 //Case: search key 20 , next node first record is 10
169 //condition is > or >=
171 iter
->mutex_
.releaseShareLock(procSlot
);
175 TreeNode
*tmpIter
= iter
;
177 DbRetVal ret
= TreeIndex::getTreeNodeMutex(iter
, procSlot
);
180 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
181 tmpIter
->mutex_
.releaseShareLock(procSlot
);
185 tmpIter
->mutex_
.releaseShareLock(procSlot
);
186 printDebug(DM_TreeIndex
,"\n Moving Node next");
189 char **rec
= (char**)((char*)iter
+ sizeof(TreeNode
));
190 rec
= (char**)((char *)rec
+ ((nodeOffset
) * sizeof(void **)));
192 //TEMP::UNCOMMENT THIS if any issue
194 iter->mutex_.releaseShareLock(procSlot);
200 void* TreeIter::locateNode()
202 TreeNode
*tnode
=NULL
;
203 TreeNode
*fiter
= (TreeNode
*)fstLTnode
;
205 ret
= TreeIndex::getTreeNodeMutex(fiter
, procSlot
);
208 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
213 printDebug(DM_TreeIndex
,"\n Search in first level start");
214 tnode
= (TreeNode
*)*((char**)((char*)((char*)fiter
+ sizeof(TreeNode
))+ ((fiter
->noElements_
-1)*sizeof(void *))));
215 char *record
= ((char*)tnode
->max_
)+ fldOffset
;
216 bool result
= AllDataType::compareVal(searchKey
, record
,OpLessThanEquals
,type
, length
);
222 printDebug(DM_TreeIndex
,"\n Search in first level next");
223 TreeNode
* tmpIter
= fiter
;
224 if(fiter
->next_
!= NULL
){
225 fiter
= fiter
->next_
;
226 ret
= TreeIndex::getTreeNodeMutex(fiter
, procSlot
);
229 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
230 tmpIter
->mutex_
.releaseShareLock(procSlot
);
234 tmpIter
->mutex_
.releaseShareLock(procSlot
);
236 tmpIter
->mutex_
.releaseShareLock(procSlot
);
248 int loc
=0, middle
=0, start
=0, end
=fiter
->noElements_
-1;
249 char **rec
= (char**)((char*)fiter
+ sizeof(TreeNode
));
251 if(fiter
->noElements_
==1)
253 tNode
= ((TreeNode
*)*(char**)((char*)rec
+ (loc
* sizeof(void *))));
255 fiter
->mutex_
.releaseShareLock(procSlot
);
256 void *rec1
= locateElement();
259 for(middle
= (start
+ end
) / 2; start
<= end
; middle
= (start
+end
)/2)
262 tNode
= (TreeNode
*)*((char**)((char*)((char*)fiter
+ sizeof(TreeNode
))+ (loc
*sizeof(void *))));
263 char *record
= ((char*)tNode
->max_
)+ fldOffset
;
265 bool res
= AllDataType::compareVal(searchKey
, record
, OpLessThan
,
273 res
= AllDataType::compareVal(searchKey
, record
, OpGreaterThan
,
284 printDebug(DM_TreeIndex
,"\n Search in fisrt level end loc =%d\n",loc
);
285 tNode
= ((TreeNode
*)*(char**)((char*)rec
+ (loc
* sizeof(void *))));
287 fiter
->mutex_
.releaseShareLock(procSlot
);
288 void *rec1
= locateElement();
292 void* TreeIter::locateElement()
294 //do binary search and locate the element
295 int loc
=0, middle
=0, start
=0, end
=iter
->noElements_
-1;
296 char **rec
= (char**)((char*)iter
+ sizeof(TreeNode
));
297 DbRetVal ret
= TreeIndex::getTreeNodeMutex(iter
, procSlot
);
300 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
303 for(middle
= (start
+ end
) / 2; start
<= end
; middle
= (start
+end
)/2)
306 char *record
= ((char*)*(rec
+middle
)) + fldOffset
;
307 bool res
= AllDataType::compareVal(searchKey
, record
, OpLessThan
,
315 res
= AllDataType::compareVal(searchKey
, record
, OpGreaterThan
,
327 char **tuple
= (char**)((char*)rec
+ (loc
* sizeof(void *)));
329 //iter->mutex_.releaseShareLock(procSlot);