Java > Open Source Codes > com > daffodilwoods > daffodildb > server > datasystem > indexsystem > TableScanIterator


1 package com.daffodilwoods.daffodildb.server.datasystem.indexsystem;
2
3
4 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
5 import com.daffodilwoods.daffodildb.server.datasystem.utility.*;
6 import com.daffodilwoods.daffodildb.server.datasystem.utility._Record;
7 import com.daffodilwoods.daffodildb.server.sql99.common.*;
8 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
9 import com.daffodilwoods.daffodildb.utils.*;
10 import com.daffodilwoods.daffodildb.utils.comparator.*;
11 import com.daffodilwoods.daffodildb.utils.field.*;
12 import com.daffodilwoods.database.general.*;
13 import com.daffodilwoods.database.resource.*;
14 import com.daffodilwoods.daffodildb.server.datasystem.btree.TableScanKey;
15
16 /**
17  *
18  * <p>Title: IndexTableIterator</p>
19  * <p>Description: This class is required to access the records of IndexTable.
20  * When more than one user works on the table then each one is provided with the
21  * iterator .Every user can access the records of the Persistent table through
22  * their respective iterators. </p>
23  */
24
25 public class TableScanIterator implements _IndexIterator,_UserTableOperations,_TableOperations, _SingleIterator, _IndexIteratorInfo, _UniqueIterator{
26
27     /**
28      * Table on which Iterator navigates.
29      */
30
31     private _IndexTableList indexTable;
32     private IndexTableIterator indexTableIterator;
33
34     /**
35      * Rank Of Index acording to their time of creation
36      */
37
38     /**
39      * UnderLying Iterator.
40      */
41
42     private _TableIterator iterator;
43
44
45     /**
46      * Index On Which Iterator is taken.
47      */
48
49
50
51
52     /**
53      * status = -1 ::::::: Invalid state before First
54      * status = 0 ::::::: Valid state
55      * status = 1 ::::::: Invalid state after Last
56      */
57
58     private int status;
59
60
61
62
63
64     public TableScanIterator(IndexTableIterator indexTableIterator0 ,_TableIterator iterator0,_IndexTableList indexTable0) {
65         iterator = iterator0;
66         indexTable = indexTable0;
67         indexTableIterator = indexTableIterator0;
68         status = -1;
69     }
70     public TableScanIterator(IndexTableIterator indexTableIterator0 ) {
71            indexTableIterator = indexTableIterator0;
72            iterator = indexTableIterator.getUnderlyingIterator() ;
73            indexTable = indexTableIterator.getIndexTable() ;
74
75            status = -1;
76        }
77
78
79     /**
80      * updates current key of Iterator on firstKey of Btree otherwise null
81      * @return true if FirstKey exists otherwise false
82      * @throws DException
83      */
84
85     public boolean first() throws DException {
86      return iterator.first() ? setKeyAndStatus(0,true,"first") : setKeyAndStatus(-1,false,"first");
87       /* try{
88             readWriteLock.lockRowForRead(monitor);
89             return btreeNavigator.first() ? setKeyAndStatus(0,true,"first") : setKeyAndStatus(-1,false,"first");
90         }finally{
91               readWriteLock.releaseRowForRead(monitor);
92         }*/
93     }
94
95     /**
96      * updates current key of Iterator on LastKey of BTree otherwise null
97      * @return true if LastKey exists otherwise false
98      * @throws DException
99      */
100
101     public boolean last() throws DException {
102       return iterator.last() ? setKeyAndStatus(0,true,"last") : setKeyAndStatus(1,false,"last");
103    /* try{
104             readWriteLock.lockRowForRead(monitor);
105             return btreeNavigator.last() ? setKeyAndStatus(0,true,"last")
106                     : setKeyAndStatus(1,false,"last");
107         }finally{
108             readWriteLock.releaseRowForRead(monitor);
109         }*/
110     }
111
112     /**
113      * updates current key of Iterator on next BTreeKey of currentKey If Exists
114      * otherwise null
115      * @return true if NextKey exists otherwise false
116      * @throws DException
117      */
118
119     public boolean next() throws DException {
120
121         if(status != 0) return status == 1 ? false : first();
122         boolean next = iterator.next() ;
123         return next ? setKeyAndStatus(0,true,"next") : setKeyAndStatus(1,false,"next");
124       /* try{
125             readWriteLock.lockRowForRead(monitor);
126             return btreeNavigator.next() ? setKeyAndStatus(0,true,"next") : setKeyAndStatus(1,false,"next");
127          }finally{
128               readWriteLock.releaseRowForRead(monitor);
129         }
130     */
131     }
132
133     /**
134      * updates current key of Iterator on Previous BtreeKey of currentKey If Exists
135      * otherwise null
136      * @return true if PreviousKey exists otherwise false
137      * @throws DException
138      */
139
140     public boolean previous() throws DException {
141         if(status != 0) return status == -1 ? false : last();
142          return iterator.previous() ? setKeyAndStatus(0,true,"previous") : setKeyAndStatus(-1,false,"previous");
143      /* try{
144             readWriteLock.lockRowForRead(monitor);
145             return btreeNavigator.previous() ? setKeyAndStatus(0,true,"previous") : setKeyAndStatus(-1,false,"previous");
146         }finally{
147               readWriteLock.releaseRowForRead(monitor);
148         }
149 */
150     }
151
152     /**
153      * Inserts Values in Index table
154      * @param user _DatabaseUser
155      * @param value values which has to insert
156      * @throws DException
157      */
158
159     public void insert(Object value) throws DException {
160        indexTableIterator.insert(value);
161        iterator.move( indexTableIterator.getPhysicalAddress() );
162
163     }
164
165
166     /**
167      * update values in Indextable
168      * @param value new Values
169      * @throws DException
170      */
171
172     public void update(Object value) throws DException {
173       if(indexTableIterator.seek(getColumnValues(SystemFields.rowId ) ) )
174         indexTableIterator.update(value );
175        /*
176       try{
177             readWriteLock.lockTable();
178             if(status != 0){
179                 throw new DException("DSE2019",new Object[] {new Integer(status)});
180             }
181             iterator.move(btreeNavigator.getValue());
182         }finally{
183             readWriteLock.releaseTable();
184         }
185 */
186     }
187
188     /**
189      * update values in given columns
190      * @param columns columns whose values has to update
191      * @param value new values
192      * @throws DException
193      */
194
195     public void update(int[] columns, Object [] value) throws DException {
196       if(indexTableIterator.seek(getColumnValues(SystemFields.rowId ) ) )
197         indexTableIterator.update(columns,value);
198     /*
199       if(columns.length != value.length)
200             throw DatabaseConstants.COLUMN_VALUES_NOTEQUAL_EXCEPTION;
201         if(status != 0){
202             throw new DException("DSE2019",new Object[] {new Integer(status)});
203         }
204         Object key = null;
205         try{
206             key = btreeNavigator.getValue();
207                 readWriteLock.lockTable();
208            iterator.move(key);
209          }finally{
210                     readWriteLock.releaseTable();
211
212         }*/
213     }
214
215     /**
216      * delete values from Index table
217      * @throws DException
218      */
219
220     public void delete() throws DException {
221       if(indexTableIterator.seek(getColumnValues(SystemFields.rowId ) ) )
222       indexTableIterator.delete() ;
223        /* try{
224             readWriteLock.lockTable();
225             if(status != 0){
226                 throw new DException("DSE2019",new Object[] {new Integer(status)});
227             }
228             iterator.move(btreeNavigator.getValue());
229          }finally{
230             readWriteLock.releaseTable();
231         }
232 */
233     }
234
235     /**
236      * tells the currentPointer of Iterator
237      * @return currentPointer of Iterator
238      * @throws DException
239      */
240
241
242     public Object getKey() throws DException {
243       if(status != 0){
244           return null;
245       }
246
247       TableScanKey tskey = new TableScanKey(getColumnValues(SystemFields.rowId ));
248       return tskey;
249     }
250
251     /**
252      * returns values of desired Columns
253      * @param columns Columns array for which values are required
254      * @return values of desired Columns
255      * @throws DException
256      */
257     public Object getColumnValues(int[] columns) throws DException {
258       try {
259         if(status != 0){
260           throw new DException("DSE2019", new Object [] {new Integer (status)});
261         }
262         BufferRange[] buff = columns == null ? (BufferRange[])iterator.getColumnValues() : (BufferRange[])iterator.getColumnValues(columns);
263         FieldBase[] array = new FieldBase[buff.length];
264         _TableCharacteristics tc = indexTable.getTableCharacteristics();
265         boolean flag = columns == null;
266         for (int i = 0; i < buff.length; i++) {
267           array[i] = (FieldBase)tc.getObject(flag ? i : columns[i],buff[i]);
268         }
269         return array;
270       }
271       catch (DException ex) {
272         if(!ex.getDseCode().equals("DSE2045"))
273           throw ex;
274       }
275       return null;
276     /*
277       if(status != 0)
278             throw new DException("DSE2019",new Object[] {new Integer(status)});
279         try{
280             readWriteLock.lockRowForRead(btreeNavigator.getValue());
281             moveIterator();
282             FieldBase[] buffers = columns == null ? (FieldBase[])indexTable.getColumnObjects(iterator) : (FieldBase[])indexTable.getColumnObjects(iterator,columns);
283             return buffers;
284           }finally{
285               readWriteLock.releaseRowForRead(btreeNavigator.getValue());
286         }
287 */
288     }
289
290     public boolean seekFromTop(_IndexPredicate[] condition ) throws DException {
291      return indexTableIterator.seekFromTop(condition);
292      /*
293       try{
294             readWriteLock.lockRowForRead(monitor);
295             _IndexKey key = (_IndexKey)btree.seekFromTopRelative(condition);
296             if(key != null){
297                 move(key);
298                 return true;
299             }
300             return false;
301         }finally{
302               readWriteLock.releaseRowForRead(monitor);
303         }
304 */
305     }
306
307     public boolean seekFromBottom(_IndexPredicate[] condition ) throws DException {
308       return indexTableIterator.seekFromBottom(condition);
309        /* try{
310             readWriteLock.lockRowForRead(monitor);
311             _IndexKey key = (_IndexKey)btree.seekFromBottomRelative(condition);
312             if(key != null){
313                 move(key);
314                 return true;
315             }
316             return false;
317         }finally{
318            readWriteLock.releaseRowForRead(monitor);
319         }
320 */
321     }
322
323     public Object [] show(boolean flag) throws DException{
324      /*
325       btree.showBTree();
326         ArrayList list = new ArrayList();
327         if(first()){
328             do{
329                 Object[] value = (Object[])getColumnValues();
330                 if(flag)
331          ;//// Removed By Program ** System.out.println("Key = " + " #### " + Arrays.asList((Object[])value));
332                 list.add(value);
333             } while(next());
334         }else
335          ;//// Removed By Program ** System.out.println(" NO RECORD IN TABLE ");
336         return list.size() == 0 ? new Object[0] : list.toArray();
337       }
338      */ return null;
339   }
340
341     /**
342      * Inserts Values in Index table
343      * @param columns columns in which has to insert
344      * @param user _DatabaseUser
345      * @param value values which has to insert
346      * @throws DException
347      */
348
349     public void insert(_DatabaseUser user, Object value) throws DException {
350       indexTableIterator.insert(user,value);
351       iterator.move( indexTableIterator.getPhysicalAddress() );
352
353       /* try{
354             readWriteLock.lockTable();
355             Object key = indexTable.insert(iterator,user,(Object[])value,index);
356             move(key);
357         }finally{
358             readWriteLock.releaseTable();
359         }*/
360     }
361
362     /**
363      * update values in Indextable
364      * @param user _DatabaseUser
365      * @param value new Values
366      * @throws DException
367      */
368
369     public void update(_DatabaseUser user, Object value) throws DException {
370       if(indexTableIterator.seek(getColumnValues(SystemFields.rowId ) ) )
371       indexTableIterator.update(user,value);
372       /* try{
373             readWriteLock.lockTable();
374             if(status != 0){
375                 throw new DException("DSE2019",new Object[] {new Integer(status)});
376             }
377             Object obj = btreeNavigator.getValue();
378             iterator.move(obj);
379             indexTable.update(iterator,user,(Object[])value,index);
380         }finally{
381             readWriteLock.releaseTable();
382         }
383 */
384     }
385
386     /**
387      * update values in given columns
388      * @param user _DatabaseUser
389      * @param columns columns whose values has to update
390      * @param value new values
391      * @throws DException
392      */
393
394     public void update(_DatabaseUser user, int[] columns, Object [] value) throws DException {
395       if(indexTableIterator.seek(getColumnValues(SystemFields.rowId ) ) )
396       indexTableIterator.update(user,columns,value );
397       /* if(columns.length != value.length)
398             throw DatabaseConstants.COLUMN_VALUES_NOTEQUAL_EXCEPTION;
399         if(status != 0){
400             throw new DException("DSE2019",new Object[] {new Integer(status)});
401         }
402         Object key = null;
403         try{
404             key = btreeNavigator.getValue();
405                 readWriteLock.lockTable();
406             iterator.move(key);
407             indexTable.update(iterator,user,columns,value,index);
408         }finally{
409                 readWriteLock.releaseTable();
410         }*/
411     }
412
413     /**
414      * delete values from Index table
415      * @param user _DatabaseUser
416      * @throws DException_index
417      */
418
419     public void delete(_DatabaseUser user) throws DException {
420       if(indexTableIterator.seek(getColumnValues(SystemFields.rowId ) ) )
421       indexTableIterator.delete(user);
422       /* try{
423             readWriteLock.lockTable();
424             if(status != 0){
425                 throw new DException("DSE2019",new Object[] {new Integer(status)});
426             }
427             iterator.move(btreeNavigator.getValue());
428             indexTable.delete(iterator,user,index);
429         }finally{
430             readWriteLock.releaseTable();
431         }*/
432     }
433
434     public _Record getRecord() throws DException {
435         _Record record = new Record(indexTable.getTableCharacteristics(),null);
436         record.setObject((Object [])getColumnValues());
437         return record;
438     }
439
440     public Object getColumnValues(_Reference[] references) throws DException {
441       if(status != 0){
442             throw new DException("DSE2019",new Object [] {new Integer (status)});
443         }
444         int[] columns = new int[references.length];
445         _TableCharacteristics tc = indexTable.getTableCharacteristics();
446         for (int i = 0; i < references.length; i++)
447             columns[i] = getColumn(references[i],tc);
448         return getColumnValues(columns);
449 /*
450         ReadWriteLock rw = indexTable.getLock();
451         try{
452             rw.readLock().acquire();
453             if(status != 0){
454                 throw new DException("DSE2019",new Object[] {new Integer(status)});
455             }
456             int[] columns = new int[references.length];
457             _TableCharacteristics tc = indexTable.getTableCharacteristics();
458             for (int i = 0; i < references.length; i++)
459                 columns[i] = getColumn(references[i],tc);
460             return getColumnValues(columns);
461         }catch(InterruptedException ie){
462             throw new DException("DSE0",new Object[]{ie.getMessage()});
463         }finally{
464             rw.readLock().release();
465         }
466 */
467     }
468
469     public boolean seek(Object indexKey ) throws DException {
470      if(indexTableIterator.seek(indexKey)) {
471       iterator.move( indexTableIterator.getPhysicalAddress() );
472       setKeyAndStatus(0,true,"seek");
473      }
474       /* try{
475             readWriteLock.lockRowForRead(monitor);
476             Object key = indexTable.seek(btree,indexKey);
477             if(key != null){
478                 btreeNavigator.move(key);
479                 return setKeyAndStatus(0,true,"seek");
480             }
481             return false;
482         }finally{
483           readWriteLock.releaseRowForRead(monitor);
484         }
485 */ return false;
486     }
487
488     public _KeyColumnInformation[] getKeyColumnInformations() throws DException {
489      return indexTableIterator.getKeyColumnInformations() ;
490      /* String[] columns = btree.getIndexInformation().getColumns();
491         boolean[] orders = btree.getIndexInformation().getOrderOfColumns();
492         int len = columns.length;
493         _KeyColumnInformation[] columnInformations = new _KeyColumnInformation[len];
494         _TableCharacteristics tc = indexTable.getTableCharacteristics();
495
496         int[] columnSize = tc.getColumnSizes();
497         int[] columnTypes = tc.getColumnTypes();
498         ColumnDetails cd;
499         for (int i = 0; i < len; i++) {
500              cd = new ColumnDetails();
501             cd.setColumn(new String[] {columns[i]});
502             cd.setType(TypeConstants.REFERENCE);
503             cd.setDatatype(columnTypes[(tc.getIndexForColumnName(columns[i]))]);
504             cd.setSize(columnSize[tc.getIndexForColumnName(columns[i])]);
505             columnInformations[i] = new TableKeyColumnInformation(cd,orders[i]);
506         }
507         return columnInformations;
508       */
509     }
510
511
512     public Object [] getUniqueColumnReference() throws DException{
513         return indexTableIterator.getUniqueColumnReference();
514     }
515
516     public int getBtreeIndex() throws DException{
517            return indexTableIterator.getBtreeIndex() ;
518     }
519
520     public SuperComparator getComparator() {
521         return indexTableIterator.getComparator();
522     }
523
524     public boolean readjust(Object updatedKey,Object secondKey) throws DException {
525       return indexTableIterator.readjust(updatedKey,secondKey);
526     /*
527       SuperComparator comparator = getComparator();
528         if( comparator.compare(((_Key)updatedKey).getKeyValue(),btreeNavigator.getKey()) < 0 && comparator.compare(((_Key)updatedKey).getKeyValue(), ((_Key)secondKey).getKeyValue()) > 0){
529             move(updatedKey);
530             return true;
531         }
532         return false;
533      */
534     }
535
536     public boolean seekFromTopRelative(Object indexKey) throws com.daffodilwoods.database.resource.DException {
537     /* try{
538             readWriteLock.lockRowForRead(monitor);
539             Object kee = btreeNavigator.getCurrentKey();
540             _IndexKey key = (_IndexKey)indexTable.seekFromTopRelative(btree,kee,indexKey);
541             if(key != null){
542                 if(kee == null)
543                     btreeNavigator.move(key);
544                 return setKeyAndStatus(0,true,"seekFromTopRelative");
545             }
546             else{
547                 if(kee != null)
548                     btreeNavigator.setNodeAndPosition(null,0);
549                 return setKeyAndStatus(-1,false,"seekFromTopRelative");
550             }
551         }finally{
552              readWriteLock.releaseRowForRead(monitor);
553         }
554 */ return false;
555     }
556
557     public boolean seekFromBottomRelative(Object indexKey) throws com.daffodilwoods.database.resource.DException {
558      /* try{
559             readWriteLock.lockRowForRead(monitor);
560             Object kee = btreeNavigator.getCurrentKey();
561             _IndexKey key = (_IndexKey)indexTable.seekFromBottomRelative(btree,kee,indexKey);
562             if(key != null){
563                 if(kee == null)
564                     btreeNavigator.move(key);
565                 return setKeyAndStatus(0,true,"seekFromBottomRelative");
566             }
567             else{
568                 if(kee != null)
569                     btreeNavigator.setNodeAndPosition(null,0);
570                 return setKeyAndStatus(-1,false,"seekFromBottomRelative");
571             }
572         }finally{
573               readWriteLock.releaseRowForRead(monitor);
574         }
575 */ return false;
576     }
577
578     public _TableCharacteristics getTableCharacteristics() throws DException{
579         return indexTable.getTableCharacteristics();
580     }
581
582     public _IndexInformation[] getUniqueInformation() throws DException{
583         return indexTable.getIndexInformations();
584     }
585
586     protected boolean setKeyAndStatus(int num,boolean flag,String str) throws DException{
587         status = num;
588         return flag;
589     }
590
591     public boolean locateKey(Object indexKey,boolean flag) throws com.daffodilwoods.database.resource.DException {
592      /* try{
593             readWriteLock.lockRowForRead(monitor);
594             _IndexKey key = (_IndexKey)indexTable.locateKey(btree,indexKey,flag);
595             if(key != null)
596                 btreeNavigator.move(key);
597             else
598                 btreeNavigator.move(btree.keyInstance() );
599             if(flag)
600                 return key != null ? setKeyAndStatus(0,true,"locateKey") : setKeyAndStatus(1,false,"locateKey");
601             else
602                 return key != null ? setKeyAndStatus(0,true,"locateKey") : setKeyAndStatus(-1,false,"locateKey");
603         }finally{
604                readWriteLock.releaseRowForRead(monitor);
605         }
606 */ return false;
607     }
608
609     public Object getColumnValues(int column) throws DException {
610        return ((Object [])getColumnValues(new int[]{column}))[0];
611        /* if(status != 0)
612             throw new DException("DSE2019",new Object[] {new Integer(status)});
613         try{
614             readWriteLock.lockRowForRead(btreeNavigator.getValue());
615         try {
616                 BufferRange buff = (BufferRange)iterator.getColumnValues(column);
617                 return indexTable.getTableCharacteristics().getObject(column,buff);
618             }
619             catch (DException ex) {
620                 if(!ex.getDseCode().equals("DSE2045"))
621                     throw ex;
622             }
623             moveIterator();
624             FieldBase buffer = (FieldBase)indexTable.getColumnObjects(iterator,column);
625             return buffer;
626         }finally{
627                readWriteLock.releaseRowForRead(btreeNavigator.getValue());
628         }*/
629     }
630
631     public Object getColumnValues() throws DException {
632       try {
633         if(status != 0)
634           throw new DException("DSE2019",new Object [] {new Integer (status)});
635         BufferRange[] buff = (BufferRange[])iterator.getColumnValues() ;
636         FieldBase[] array = new FieldBase[buff.length];
637         _TableCharacteristics tc = indexTable.getTableCharacteristics();
638         for (int i = 0; i < buff.length; i++) {
639           array[i] = (FieldBase)tc.getObject(i,buff[i]);
640         }
641         return array;
642       }
643       catch (DException ex) {
644         if(!ex.getDseCode().equals("DSE2045"))
645           throw ex;
646       }
647       return null;
648
649      /* if(status != 0)
650             throw new DException("DSE2019",new Object[] {new Integer(status)});
651         try{
652             readWriteLock.lockRowForRead(btreeNavigator.getValue());
653             moveIterator();
654             return indexTable.getColumnObjects(iterator) ;
655         }finally{
656             readWriteLock.releaseRowForRead(btreeNavigator.getValue());
657         }*/
658     }
659
660
661
662     public Object getColumnValues(_Reference references) throws com.daffodilwoods.database.resource.DException {
663         return getColumnValues(new _Reference[]{references});
664       /* if(status != 0){
665             throw new DException("DSE2019",new Object[] {new Integer(status)});
666         }
667         _TableCharacteristics tc = indexTable.getTableCharacteristics();
668         return getColumnValues(getColumn(references,tc));
669 /*
670         ReadWriteLock rw = indexTable.getLock();
671         try{
672             rw.readLock().acquire();
673             if(status != 0){
674                 throw new DException("DSE2019",new Object[] {new Integer(status)});
675             }
676             _TableCharacteristics tc = indexTable.getTableCharacteristics();
677             int column = getColumn(references,tc);
678             return getColumnValues(column);
679         }catch(InterruptedException ie){
680             throw new DException("DSE0",new Object[]{ie.getMessage()});
681         }finally{
682             rw.readLock().release();
683         }
684 */
685     }
686
687     public SuperComparator getObjectComparator() throws DException{
688         return indexTableIterator.getComparator();
689     }
690
691     public boolean seekKeyAddress(Object parm1) throws com.daffodilwoods.database.resource.DException {
692         iterator.move(parm1);
693         Object seekKey = iterator.getColumnValues((int[])getUniqueColumnReference()[0]);
694         return seek(seekKey);
695     }
696
697     public Object getPhysicalAddress() throws com.daffodilwoods.database.resource.DException {
698         return indexTableIterator.getPhysicalAddress();
699     }
700
701     public void ensureRecordInMemory() throws com.daffodilwoods.database.resource.DException {
702         /**@todo Implement this com.daffodilwoods.daffodildb.server.datasystem.interfaces._IndexIteratorInfo method*/
703         throw new java.lang.UnsupportedOperationException ("Method ensureRecordInMemory() not yet implemented.");
704     }
705
706     public void moveOnActualKey(Object parm1) throws com.daffodilwoods.database.resource.DException {
707         /**@todo Implement this com.daffodilwoods.daffodildb.server.datasystem.interfaces._IndexIteratorInfo method*/
708         throw new java.lang.UnsupportedOperationException ("Method moveOnActualKey() not yet implemented.");
709     }
710
711     public Object getActualKey() throws com.daffodilwoods.database.resource.DException {
712         /**@todo Implement this com.daffodilwoods.daffodildb.server.datasystem.interfaces._IndexIteratorInfo method*/
713         throw new java.lang.UnsupportedOperationException ("Method getActualKey() not yet implemented.");
714     }
715
716
717
718     private int getColumn(_Reference references,_TableCharacteristics tc )throws DException{
719       int column = -1;
720         try{
721             column = references.getIndex();
722         }
723         catch(DException de) {
724             if(!de.getDseCode().equalsIgnoreCase("DSE565"))
725                 throw de;
726             column = tc.getIndexForColumnName(references.getColumn());
727             references.setIndex(column);
728         }
729         return column;
730       }
731
732     public void move(Object value)throws DException{
733          indexTableIterator.seek(value);
734          iterator.move( indexTableIterator.getPhysicalAddress() );
735         status = 0;
736
737     }
738
739     public FieldBase field(_Reference reference) throws com.daffodilwoods.database.resource.DException {
740         if(status != 0){
741             throw new DException("DSE2019",new Object [] {new Integer (status)});
742         }
743         return field(getColumn(reference,indexTable.getTableCharacteristics()));
744
745
746     }
747
748     public FieldBase[] fields(_Reference[] references) throws com.daffodilwoods.database.resource.DException {
749       int[] columns = new int[references.length];
750         _TableCharacteristics tc = indexTable.getTableCharacteristics();
751         for (int i = 0; i < references.length; i++)
752             columns[i] = getColumn(references[i],tc);
753         return fields(columns);
754     }
755
756     public FieldBase[] fields(int[] columns) throws com.daffodilwoods.database.resource.DException {
757         return (FieldBase[])getColumnValues(columns);
758     }
759
760     public FieldBase field(int column) throws DException {
761         return (FieldBase)getColumnValues(column);
762   }
763
764     public void setFieldsValue(int[] columns, FieldBase[] values) throws DException {
765       indexTableIterator.setFieldsValue(columns,values);
766   /* try{
767             readWriteLock.lockRowForRead(btreeNavigator.getValue());
768             moveIterator();
769             Object[] buffers = (Object[])iterator.getColumnValues(columns);
770             for (int i = 0; i < buffers.length; i++) {
771                 try {
772                     values[i].setBufferRange((BufferRange)buffers[i]);
773                 }
774                 catch (ClassCastException ex) {
775                     values[i] = (FieldBase)buffers[i];//.setBufferRange((BufferRange)buffers[i]);
776                 }
777             }
778         }finally{
779               readWriteLock.releaseRowForRead(btreeNavigator.getValue());
780         }
781    */
782     }
783
784     public void setFieldValue(int column, FieldBase value) throws DException {
785       indexTableIterator.setFieldValue(column ,value);
786       /* try{
787             readWriteLock.lockRowForRead(btreeNavigator.getValue());
788           try {
789                 value.setBufferRange((BufferRange)btreeNavigator.getColumnValues(column));
790             }catch (DException ex) {
791                 if(!ex.getDseCode().equals("DSE2045"))
792                     throw ex;
793             }
794             moveIterator();
795             Object buffer = iterator.getColumnValues(column);
796             try {
797                 value.setBufferRange((BufferRange)buffer);
798             }
799             catch (ClassCastException ex) {
800                 value = (FieldBase)buffer;
801             }
802         }finally{
803               readWriteLock.releaseRowForRead(btreeNavigator.getValue());
804         }*/
805     }
806
807     public _Index getBtree(){
808           return indexTableIterator.getBtree() ;
809         }
810
811     public byte[] getByteKey() throws DException{
812       throw new java.lang.UnsupportedOperationException (
813         "Method getByteKey() not yet implemented.");
814    }
815    public void moveByteKey(byte[] key) throws DException{
816      throw new java.lang.UnsupportedOperationException (
817         "Method moveByteKey() not yet implemented.");
818        }
819
820         public boolean hasAnyRecords() throws DException {
821              return iterator.first() ? setKeyAndStatus(0,true,"first") : setKeyAndStatus(-1,false,"first");
822         }
823        public void deleteBlobClobRecord(_DatabaseUser user) throws DException {
824          indexTableIterator.deleteBlobClobRecord(user);
825       /* try{
826                   readWriteLock.lockTable();
827                   if(status != 0){
828                       throw new DException("DSE2019",new Object[] {new Integer(status)});
829                   }
830                   iterator.move(btreeNavigator.getValue());
831                   indexTable.deleteBlobClobRecord(iterator,user,index);
832               }finally{
833                   readWriteLock.releaseTable();
834               }
835 */
836           }
837
838
839 }
840

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags