MergeTable


1   package com.daffodilwoods.daffodildb.server.datasystem.mergesystem;
2   
3   import com.daffodilwoods.daffodildb.server.sql99.dql.iterator._Iterator;
4   
5   import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
6   import com.daffodilwoods.daffodildb.server.datasystem.utility.*;
7   import com.daffodilwoods.daffodildb.server.datasystem.indexsystem._IndexInformation;
8   import com.daffodilwoods.database.resource.*;
9   import com.daffodilwoods.database.general.QualifiedIdentifier;
10  import com.daffodilwoods.daffodildb.utils.comparator.SuperComparator;
11  import com.daffodilwoods.daffodildb.utils.FieldUtility;
12  import com.daffodilwoods.database.general.SystemFields;
13  import com.daffodilwoods.daffodildb.server.sql99.fulltext.dml._FullTextIndexInformation;
14  import com.daffodilwoods.daffodildb.server.sessionsystem.sessionversioninfo.SessionVersionHandler;
15  
16  /**
17   *
18   * <p>Title: MergeTable </p>
19   * <p>Description: It handles all table level operations on both the file table and the memory table.
20   */
21  public class MergeTable implements _MergeTable {
22  
23     private _IndexTable fileTable;
24     private _IndexTable memoryTable;
25     QualifiedIdentifier tableName;
26     boolean isTableDropped = false;
27     static SuperComparator comparator = new KeyComparator();
28     private _DropTableInfo dropTableInfo;
29     SessionVersionHandler sessionVersionHandler;
30     _Iterator fileIterator;
31     private _Database mergeDatabase;
32     public boolean isToBeFinalized;
33     /**
34      * Constructs the merge table with two index tables
35      *
36      * @param fileMemoryTable0 instance of file memory table to manage the memory table operations
37      * @param fileTable0 instance of the file table to manage the file table operations.
38      */
39  
40     public MergeTable(QualifiedIdentifier tableName0, _IndexTable fileMemoryTable0, _IndexTable fileTable0, SessionVersionHandler sessionVersionHandler0, _Database mergeDatabase0) {
41        fileTable = fileTable0;
42        memoryTable = fileMemoryTable0;
43        mergeDatabase = mergeDatabase0;
44        tableName = tableName0;
45        sessionVersionHandler = sessionVersionHandler0;
46        dropTableInfo = new DropTableInfo(this);
47        try {
48           fileIterator = fileTable.getDefaultIterator();
49        } catch (DException ex) {}
50     }
51  
52     /**
53      * it transfers records from given conditional Iterator to file table and deletes record from memory table.it alligns
54      * all other iterators which are taken on this table that are iterating on the records which are shifted
55      * from memory to file.it is needed to inform other iterators that their current record is shifted from
56      * memory to file.
57      *
58      *
59      * @param user to write data in file
60      * @param newIterator iterator has records which has to transfer from memory to file
61      */
62  
63     static int cnt;
64  
65     public void makePersistentForInsertedXA(_DatabaseUser user, _Iterator newIterator) throws DException {
66        _Iterator fileIterator = fileTable.getDefaultIterator();
67        boolean boo = newIterator.first();
68        if (boo) {
69           int[] btreeColumns = (int[]) fileIterator.getUniqueColumnReference()[0];
70           SuperComparator comp = ( (_IndexIteratorInfo) ( (IteratorWrapper) fileIterator).getIndexIterator()).getComparator();
71           Object   valuesToInsert;
72           do {
73              valuesToInsert = newIterator.getColumnValues();
74              ( (_UserTableOperations) fileIterator).insert(user, newIterator.getColumnValues());
75              ( (_TableOperations) newIterator).delete();
76           } while (newIterator.next());
77        }
78     }
79  
80     public void makePersistentForInserted(_DatabaseUser user, _Iterator newIterator, Object   transactionId, boolean changeInCommittedRecord) throws DException {
81  
82        boolean boo = newIterator.first();
83        if (boo) {
84           Object  [] key = new Object  [1];
85           Object  [] valuesToInsert;
86           do {
87              valuesToInsert = (Object  []) newIterator.getColumnValues();
88              valuesToInsert[SystemFields.transactionId] = transactionId;
89              key[0] = valuesToInsert[0];
90              if (changeInCommittedRecord && fileIterator.seek(key)) {
91                 ( (_UserTableOperations) fileIterator).update(user, valuesToInsert);
92                 /*
93                                    Object[] currentValues = (Object[])fileIterator.getColumnValues();
94                                    int[] columns = new int[currentValues.length];
95                                    Object[] values = new Object[currentValues.length];
96                                    int updatedColumnCount=0;
97                                    for (int i = 0; i < currentValues.length; i++) {
98                                        if( valuesToInsert[i].equals(currentValues[i]) == false ){
99                                            columns[updatedColumnCount] = i;
100                                           values[updatedColumnCount] = valuesToInsert[i];
101                                           updatedColumnCount++;
102                                       }
103                                   }
104                                   int[] updatedColumns = new int[updatedColumnCount];
105                                   Object[] updatedValues = new Object[updatedColumnCount];
106                                   System.arraycopy(columns,0,updatedColumns,0,updatedColumnCount);
107                                   System.arraycopy(values,0,updatedValues,0,updatedColumnCount);
108                                   ((_UserTableOperations)fileIterator).update(user,updatedColumns,updatedValues);
109                 */
110             } else {
111                ( (_UserTableOperations) fileIterator).insert(user, valuesToInsert);
112             }
113          } while (newIterator.next());
114       }
115    }
116 
117    /**
118     * Used to transfer the updated records from memory to file which were already written in file with old
119     * values and deletes records from memory.it alligns all other iterators which are taken on this table
120     * that are iterating on the records which are shifted from memory to file.it is needed to inform other
121     * iterators that their current record is shifted from memory to file.
122     * @param user to write data in file
123     * @param memoryIterator iterator has updated records which has to transfer from memory to file
124     * @param fileIterator fileIterator having same index on which memoryIterator is taken
125     * @param columns index of columns whose values has to update
126     * @param values new values of columns
127     */
128 
129    public void makePersistentForUpdatedXA(_DatabaseUser user, _Iterator memoryIterator, _Iterator fileIterator, int[] columns, Object  [] values) throws DException {
130       if (memoryIterator.first()) {
131          int[] btreeColumns = (int[]) fileIterator.getUniqueColumnReference()[0];
132          SuperComparator comp = ( (_IndexIteratorInfo) ( (IteratorWrapper) fileIterator).getIndexIterator()).getComparator();
133          Object   actualKey, key;
134          do {
135             actualKey = ( (_IndexIteratorInfo) memoryIterator).getActualKey();
136             key = ( (_Key) actualKey).getKeyValue();
137             fileIterator.seek(key);
138             ( (_UserTableOperations) fileIterator).update(user, columns, values);
139 
140             ( (_TableOperations) memoryIterator).delete();
141          } while (memoryIterator.next());
142 
143       }
144    }
145 
146    public void makePersistentForUpdated(_DatabaseUser user, _Iterator memoryIterator, _Iterator fileIterator, int[] columns, Object  [] values) throws DException {
147       if (memoryIterator.first()) {
148          Object   actualKey, key;
149          boolean flag;
150          do {
151             actualKey = ( (_IndexIteratorInfo) memoryIterator).getActualKey();
152             key = ( (_Key) actualKey).getKeyValue();
153             flag = sessionVersionHandler.recordFound( (_Iterator) fileIterator, (Object  []) key);
154             if (flag) {
155                ( (_UserTableOperations) fileIterator).delete(user);
156             }
157          } while (memoryIterator.next());
158 
159       }
160    }
161 
162    /*
163         private UnionIterator[] getIteratorsToMove(_Record record, Object key , int[] btreeColumns,SuperComparator cmp) throws DException{
164            Object[] iterators = iteratorsMap.keySet().toArray();
165            ArrayList list = new ArrayList(1);
166            Object keyValue = ((_Key)key).getKeyValue();
167            for(int i = 0 ; i < iterators.length ; i++) {
168                try {
169                   if(iterators[i] == null)
170                      continue;
171                   Object obj = ((UnionIterator)iterators[i]).getKey();
172                   if(obj == null)
173                       continue;
174                   Object kee = getDefaultKeyToCompare(((_Key)obj).getKeyValue());
175                   if(kee == null)
176                       kee = ((UnionIterator)iterators[i]).getColumnValues(btreeColumns);
177                   int res = cmp.compare(kee,keyValue);
178                   if(res == 0)
179                     list.add(iterators[i]);
180                }
181                catch(DException ex) {
182                   if(! (ex.getDseCode().equalsIgnoreCase("DSE2004") || ex.getDseCode().equalsIgnoreCase("DSE2019") ) )
183                      throw ex;
184                }
185             }
186             return (UnionIterator[])list.toArray(new UnionIterator[0]);
187          }
188          private Object getDefaultKeyToCompare(Object kee) {
189              try {
190                Object[] key = (Object[])kee;
191                if(key.length > 3){
192                    Object[] keyToReturn = new Object[3];
193                    for(int i = key.length,j = 2 ; j >= 0 ; i--,j--) {
194                        keyToReturn[j] = key[i];
195                    }
196                    return keyToReturn;
197                }
198                else if(key.length == 3){
199                    return key;
200                }
201                else
202                    return null;
203            }
204            catch (Exception ex) {
205                return null;
206            }
207          }
208     */
209    /**
210     * To allign other iterators which are currently navigating on records which are shifted from memory
211     * to file.
212     *
213     * @param iterators Iterators which has to allign
214     * @param record Record which is shifted from memory to file
215     */
216 
217    void transferRecordFromMemoryToFile(UnionIterator[] iterators, _Record record) throws DException {
218       for (int i = 0; i < iterators.length; i++) {
219          int[] btreeColumns = (int[]) ( (_IndexIterator) iterators[i]).getUniqueColumnReference()[0];
220          Object   keyToCompare = record.getObject(btreeColumns);
221          ( (_UnionIterator) iterators[i]).reAdjustFirst(keyToCompare);
222       }
223    }
224 
225    public int getIndexType() throws DException {
226       return -1;
227    }
228 
229    public _TableCharacteristics getTableCharacteristics() throws DException {
230       return fileTable.getTableCharacteristics();
231    }
232 
233    /**
234     * returns index information of all the indexes on the table.
235     *
236     * @return index information of all the indexes on the table..
237     */
238 
239    public _IndexInformation[] getIndexInformations() throws DException {
240       return ( (_IndexTable) fileTable).getIndexInformations();
241    }
242 
243    /**
244     * Used to notify all the iterators on the memory table to readjust their keys to the given key.
245     * @param key key to which the iterators will move their current key.
246     */
247 
248    public _Record getBlankRecord() throws DException {
249       _TableCharacteristics tc = fileTable.getTableCharacteristics();
250       return new Record(tc, FieldUtility.getBlankFields(tc.getColumnTypes(), tc.getCollator()));
251    }
252 
253    /**
254     * returns Iterator on given index and puts its entry in map
255     *
256     * @param index index on which iterator is required
257     *
258     * @return Iterator on given index
259     */
260 
261    public _Iterator getIterator(int index) throws DException {
262       if (isTableDropped)
263          throw new DException("DSE5584", null);
264       _IndexIterator fileIterator = ( (IteratorWrapper) fileTable.getIterator(index)).getIndexIterator();
265       _IndexIterator fileMemoryIterator = ( (IteratorWrapper) memoryTable.getIterator(index)).getIndexIterator();
266       _IndexIterator defaultMemoryIterator = ( (IteratorWrapper) memoryTable.getDefaultIterator()).getIndexIterator();
267       _IndexIterator mergeIterator = new MergeIterator(defaultMemoryIterator, fileMemoryIterator, fileIterator, this, sessionVersionHandler);
268       IteratorWrapper iw = new IteratorWrapper(mergeIterator);
269       iw.setTableName(tableName);
270       return iw;
271    }
272 
273    public _IndexTable getFileTable() {
274       return fileTable;
275    }
276 
277    public _IndexTable getMemoryTable() {
278       return memoryTable;
279    }
280 
281    /**
282     * returns Iterator on index which is made on system fields(RowId,TransactionId,SessionId)
283     *
284     *
285     * @return Iterator on index which is made on system fields(RowId,TransactionId,SessionId)
286     */
287 
288    public _Iterator getDefaultIterator() throws com.daffodilwoods.database.resource.DException {
289       if (isTableDropped)
290          throw new DException("DSE5584", null);
291       _IndexIterator fileIterator = ( (IteratorWrapper) fileTable.getDefaultIterator()).getIndexIterator();
292       _IndexIterator fileMemoryIterator = ( (IteratorWrapper) memoryTable.getDefaultIterator()).getIndexIterator();
293       _IndexIterator defaultMemoryIterator = ( (IteratorWrapper) memoryTable.getDefaultIterator()).getIndexIterator();
294       _IndexIterator mergeIterator = new MergeIterator(defaultMemoryIterator, fileMemoryIterator, fileIterator, this, sessionVersionHandler);
295       IteratorWrapper iw = new IteratorWrapper(mergeIterator);
296       iw.setTableName(tableName);
297       return iw;
298    }
299 
300    public int getEstimatedRowCount() throws DException {
301       return memoryTable.getEstimatedRowCount() + fileTable.getEstimatedRowCount();
302    }
303 
304    /*
305      private void alignIterators( _Record record,Object keyValue) throws DException{
306          synchronized(iteratorsMap){
307              Iterator it = iteratorsMap.keySet().iterator();
308              int count =0 ;// for testing purpose
309              while(it.hasNext()){
310                  _UnionIterator unionIterator = (_UnionIterator)it.next();
311                  if(unionIterator == null)
312                      continue;
313                  Object obj = ((UnionIterator)unionIterator).getKey();
314                  if(obj == null)
315                      continue;
316                  Object kee = ((_Key)obj).getKeyValue();
317                  int res = comparator.compare(kee,keyValue);
318                  if(res == 0){
319                      int[] btreeColumns = (int[])((_IndexIterator)unionIterator).getUniqueColumnReference()[0];
320                      Object keyToCompare = record.getObject(btreeColumns);
321                      ((_UnionIterator)unionIterator).reAdjustFirst(keyToCompare);
322                      count++;
323                  }
324              }
325              if( count > 0 ){
326          ;//// Removed By Program **                   System.out.println(" Found iterator for alignment " + count);
327              }
328          }
329      }
330     */
331    public _FullTextIndexInformation[] getFullTextIndexInformation() throws DException {
332       return fileTable.getFullTextIndexInformation();
333    }
334 
335    public _Database getDatabase() throws DException {
336       return fileTable.getDatabase();
337    }
338 
339    public boolean hasRecordsInMemory() throws DException {
340         if (isTableDropped) {
341             throw new DException("DSE5584", null);
342          }
343          return ( (IteratorWrapper) getMemoryTable().getDefaultIterator()).hasAnyRecords();
344    }
345 
346    public void setDuplicateKeysAllowedInBtrees() throws DException {
347       throw new java.lang.UnsupportedOperationException  (
348           "Method setDuplicateKeysAllowedInBtrees() not yet implemented.");
349    }
350 
351    public _DropTableInfo getDropTableInfo() throws DException {
352       return dropTableInfo;
353    }
354 
355    public void setTableDropped(boolean tableDropped) throws DException {
356       isTableDropped = tableDropped;
357    }
358 
359    public boolean isTableDropped() throws DException {
360       return isTableDropped;
361    }
362 
363    protected void finalize() {
364       try {
365          ( (MergeDatabase) mergeDatabase).releaseTable(tableName, memoryTable);
366          isToBeFinalized = true;
367       } catch (DException ex) {
368       }
369    }
370 }
371
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags