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 **)));
68 void TreeIter::nextNode()
70 if (recordsOver
) return ;
71 if (NULL
== iter
) return ;
72 TreeNode
*tmpIter
= iter
;
75 DbRetVal ret
= TreeIndex::getTreeNodeMutex(iter
, procSlot
);
78 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
79 tmpIter
->mutex_
.releaseShareLock(procSlot
);
83 tmpIter
->mutex_
.releaseShareLock(procSlot
);
87 void TreeIter::reset()
89 if(iter
&& !firstCall
) iter
->mutex_
.releaseShareLock(procSlot
);
95 void* TreeIter::next()
99 if(iter
) iter
->mutex_
.releaseShareLock(procSlot
);
103 if (NULL
== iter
) return NULL
;
106 if (OpLessThan
==op
|| OpLessThanEquals
== op
)
110 char **rec
= (char**)((char*) iter
+ sizeof(TreeNode
));
111 DbRetVal ret
= TreeIndex::getTreeNodeMutex(iter
, procSlot
);
114 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
117 //iter->displayAll(fldOffset);
120 else if (OpGreaterThan
== op
)
122 char *rec
= (char*)locateNode();
125 bool result
= AllDataType::compareVal(searchKey
, rec
+fldOffset
,
126 OpEquals
, type
, length
);
127 //equals comparision does not apply to float and double
128 if (result
|| type
==typeFloat
|| type
== typeDouble
) return next();
131 }else if (OpGreaterThanEquals
== op
)
133 void *rec
= locateNode();
136 }else if (OpEquals
== op
)
138 void *rec
= locateNode();
140 if(isUnique
) recordsOver
= true;
146 if (nodeOffset
== iter
->noElements_
)
148 if (NULL
== iter
->next_
) {
150 iter
->mutex_
.releaseShareLock(procSlot
);
154 char* record
= ((char*)iter
->next_
->min_
)+ fldOffset
;
155 bool result
= AllDataType::compareVal(searchKey
, record
,
158 if (!result
&& (OpLessThan
==op
|| OpLessThanEquals
== op
))
160 //Case: search key 10 , next node first record is 20
161 //condition is < or <=
163 iter
->mutex_
.releaseShareLock(procSlot
);
166 }else if (result
&& (OpGreaterThan
== op
||
167 OpGreaterThanEquals
== op
))
169 //Case: search key 20 , next node first record is 10
170 //condition is > or >=
172 iter
->mutex_
.releaseShareLock(procSlot
);
176 TreeNode
*tmpIter
= iter
;
178 DbRetVal ret
= TreeIndex::getTreeNodeMutex(iter
, procSlot
);
181 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
182 tmpIter
->mutex_
.releaseShareLock(procSlot
);
186 tmpIter
->mutex_
.releaseShareLock(procSlot
);
187 printDebug(DM_TreeIndex
,"\n Moving Node next");
190 char **rec
= (char**)((char*)iter
+ sizeof(TreeNode
));
191 rec
= (char**)((char *)rec
+ ((nodeOffset
) * sizeof(void **)));
193 //TEMP::UNCOMMENT THIS if any issue
195 iter->mutex_.releaseShareLock(procSlot);
202 void* TreeIter::locateNode()
204 TreeNode
*tnode
=NULL
;
205 TreeNode
*fiter
= (TreeNode
*)fstLTnode
;
207 ret
= TreeIndex::getTreeNodeMutex(fiter
, procSlot
);
210 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
215 printDebug(DM_TreeIndex
,"\n Search in first level start");
216 tnode
= (TreeNode
*)*((char**)((char*)((char*)fiter
+ sizeof(TreeNode
))+ ((fiter
->noElements_
-1)*sizeof(void *))));
217 char *record
= ((char*)tnode
->max_
)+ fldOffset
;
218 bool result
= AllDataType::compareVal(searchKey
, record
,OpLessThanEquals
,type
, length
);
224 printDebug(DM_TreeIndex
,"\n Search in first level next");
225 TreeNode
* tmpIter
= fiter
;
226 if(fiter
->next_
!= NULL
){
227 fiter
= fiter
->next_
;
228 ret
= TreeIndex::getTreeNodeMutex(fiter
, procSlot
);
231 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
232 tmpIter
->mutex_
.releaseShareLock(procSlot
);
236 tmpIter
->mutex_
.releaseShareLock(procSlot
);
238 tmpIter
->mutex_
.releaseShareLock(procSlot
);
250 int loc
=0, middle
=0, start
=0, end
=fiter
->noElements_
-1;
251 char **rec
= (char**)((char*)fiter
+ sizeof(TreeNode
));
253 if(fiter
->noElements_
==1)
255 tNode
= ((TreeNode
*)*(char**)((char*)rec
+ (loc
* sizeof(void *))));
257 fiter
->mutex_
.releaseShareLock(procSlot
);
258 void *rec1
= locateElement();
261 for(middle
= (start
+ end
) / 2; start
<= end
; middle
= (start
+end
)/2)
264 tNode
= (TreeNode
*)*((char**)((char*)((char*)fiter
+ sizeof(TreeNode
))+ (loc
*sizeof(void *))));
265 char *record
= ((char*)tNode
->max_
)+ fldOffset
;
267 bool res
= AllDataType::compareVal(searchKey
, record
, OpLessThan
,
275 res
= AllDataType::compareVal(searchKey
, record
, OpGreaterThan
,
286 printDebug(DM_TreeIndex
,"\n Search in fisrt level end loc =%d\n",loc
);
287 tNode
= ((TreeNode
*)*(char**)((char*)rec
+ (loc
* sizeof(void *))));
289 fiter
->mutex_
.releaseShareLock(procSlot
);
290 void *rec1
= locateElement();
294 void* TreeIter::locateElement()
296 //do binary search and locate the element
297 int loc
=0, middle
=0, start
=0, end
=iter
->noElements_
-1;
298 char **rec
= (char**)((char*)iter
+ sizeof(TreeNode
));
299 DbRetVal ret
= TreeIndex::getTreeNodeMutex(iter
, procSlot
);
302 printError(ErrLockTimeOut
,"Unable to lock the tree node. Retry...");
305 for(middle
= (start
+ end
) / 2; start
<= end
; middle
= (start
+end
)/2)
308 char *record
= ((char*)*(rec
+middle
)) + fldOffset
;
309 bool res
= AllDataType::compareVal(searchKey
, record
, OpLessThan
,
317 res
= AllDataType::compareVal(searchKey
, record
, OpGreaterThan
,
329 char **tuple
= (char**)((char*)rec
+ (loc
* sizeof(void *)));
331 //iter->mutex_.releaseShareLock(procSlot);