TableManager


1   package com.daffodilwoods.daffodildb.server.datasystem.persistentsystem ;
2   
3   import java.text.*;
4   import java.util.*;
5   
6   import com.daffodilwoods.daffodildb.server.datadictionarysystem.*;
7   import com.daffodilwoods.daffodildb.server.datasystem.indexsystem.*;
8   import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
9   import com.daffodilwoods.daffodildb.server.datasystem.interfaces.Utility;
10  import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.versioninfo.*;
11  import com.daffodilwoods.daffodildb.utils.*;
12  import com.daffodilwoods.daffodildb.utils.byteconverter.*;
13  import com.daffodilwoods.daffodildb.utils.comparator.*;
14  import com.daffodilwoods.database.general.*;
15  import com.daffodilwoods.database.resource.*;
16  
17  /**
18   * It manages all the tables related to a particular database.It maintains the map of all tables which are in use, Initializes
19   * all System Tables , user Tables and index on TableInfo and ColumnInfoTable. All read and write
20   * operations on TableInfo and ColumnInfo System Table are performed here.
21   */
22  
23  public class TableManager implements Datatype,DatabaseConstants {
24  
25      /**
26       * Maintains lists of all ables which are Currently in use having mapping with table name
27       */
28  
29      private HashMap tablesMap;
30  
31      /**
32       * Database for which it is managing the tables
33       */
34  
35      private PersistentDatabase persistentDatabase;
36  
37      /**
38       * For maintaing the free clusters in database file.
39       */
40  
41      private FreeClusterList freeClusterList;
42  
43      /**
44       * For creating TableCharacteristics of tables
45       */
46  
47      private TableCharacteristicsGenerator charGenerator;
48  
49      /**
50       * Index on TableInfo,for fast searching
51       */
52  
53      private _Index indexOnTableInfo;
54  
55      /**
56       * Index on ColumnInfo,for fast searching
57       */
58  
59      private _Index indexOnColumnInfo;
60  
61      /**
62       * for comparing two tableNames
63       */
64  
65      private ByteComparator nameComparator;
66  
67      /**
68       * Contains the database property for a particular database
69       */
70  
71      DatabaseProperties databaseProperties;
72      /**
73       * Version handler according to database version for getting database constants which
74       * are varied according to database version.
75       */
76      VersionHandler versionHandler;
77  
78      boolean isTempDatabase;
79      /**
80       * Constructs TableManager and initializes its attributes
81       */
82  
83      public TableManager(PersistentDatabase persistentDatabase0,DatabaseProperties databaseProperties0,VersionHandler versionHandler0) {
84          persistentDatabase = persistentDatabase0;
85          databaseProperties = databaseProperties0;
86          tablesMap = new HashMap();
87          charGenerator = new TableCharacteristicsGenerator(this);
88          CTusjohJoTfotjujwfDpnqbsbups stringComparator = new CTusjohJoTfotjujwfDpnqbsbups();
89          nameComparator = new ByteComparator(new boolean[] {true,true,true},new SuperComparator[] {stringComparator,stringComparator,stringComparator});
90          versionHandler = versionHandler0;
91          isTempDatabase = persistentDatabase.getDatabaseName().equalsIgnoreCase(DatabaseConstants.TEMPDATABASE )  ;
92  
93        }
94  
95      /**
96       * Initializes TableInfo,ColumnInfo,ClusterInfo,DatabaseIndexInfo,DatabaseIndexColumns,FreeSpaceInfo
97       * system tables and if database is sytemDatabase it Initializes two more System Tables DatabaseInfo
98       * and DatabaseFileInfo and makes their Entry in tablesMap.It also initializes freeClusterList
99       * StartClusteraddress and LastCluster address of these Tables is written in first Cluster at
100      * positions ->
101      *
102      *  TableInfoFirstClusterAddress     CLUSTERSIZE
103      *  ColumnInfoFirstClusterAddress    2*CLUSTERSIZE
104      *  ClusterInfoFirstClusterAddress   3*CLUSTERSIZE
105      *  DatabaseIndexInfo                4*CLUSTERSIZE
106      *  DatabaseIndexColumns             5*CLUSTERSIZE
107      *  freeSpaceinfo                    6*CLUSTERSIZE
108      *  DatabaseInfo                     7*CLUSTERSIZE
109      *  DatabaseFileInfo                 8*CLUSTERSIZE
110      * @param startCluster First Cluster of database file
111      */
112 
113     void initializeSystemTables(Cluster startCluster,_DatabaseUser user)  throws DException {
114         byte[] bytes = startCluster.getBytes();
115         String   databaseName = persistentDatabase.getDatabaseName();
116         addSystemTables(SystemTables.TABLEINFO,user,1,bytes);
117         addSystemTables(SystemTables.COLUMNINFO,user,3,bytes);
118         addSystemTables(SystemTables.CLUSTERINFO,user,5,bytes);
119         addSystemTables(SystemTables.DATABASEINDEXINFO,user,7,bytes);
120         addSystemTables(SystemTables.DATABASEINDEXCOLUMNS,user,9,bytes);
121         addSystemTables(SystemTables.FREESPACEINFO,user,11,bytes);
122         addSystemTables(SystemTables.DATABASEFULLTEXTINFO,user,13,bytes);
123         if(databaseName.equalsIgnoreCase(DatabaseConstants.SYSTEMDATABASE)){
124             addSystemTables(SystemTables.DATABASEINFO,user,15,bytes);
125             addSystemTables(SystemTables.DATABASEFILEINFO,user,17,bytes);
126             addSystemTables(SystemTables.SCHEDULEINFO,user,19,bytes);
127         }
128         addSystemTables(SystemTables.DATABASEFULLTEXTCOLUMNINFO,user,21,bytes);
129         freeClusterList = new FreeClusterList(getTable(SystemTables.CLUSTERINFO));
130     }
131 
132     /**
133      * Initializes system table and puts tables with tableName in tablesMap.If very first time these tables
134      * are initialized then initializes there first clusters also.
135      *
136      * @param tableName Name of System table
137      * @param user to initilise clusters of system Tables
138      * @param start address where address of first cluster of this table is written in very first cluster of database file
139      * @param bytes bytes of very first cluster of database file
140      */
141 
142     public void addSystemTables(QualifiedIdentifier tableName,_DatabaseUser user,int start,byte[] bytes) throws DException{
143       int startAddress = (int) CCzufDpowfsufs.getLongValue(bytes,start*versionHandler.ADDRESSLENGTH);
144 
145         if (startAddress == 0){
146           return;
147         }
148 
149         int endAddress   = (int)CCzufDpowfsufs.getLongValue(bytes,(start+1)*versionHandler.ADDRESSLENGTH);
150 
151         ClusterCharacteristics firstCC = new ClusterCharacteristics(startAddress,false);
152         ClusterCharacteristics lastCC = new ClusterCharacteristics(endAddress,false);
153         if(user != null){
154             Cluster clusterStart = persistentDatabase.getClusterManager().getStartClusterForWriteFirst(user,firstCC,false);
155             persistentDatabase.updateNextInsertableAddressOfCluster(tableName,user,clusterStart);
156             clusterStart.initializeParameters();
157         }
158         Object  [] tables = charGenerator.getTableCharacteristicsForSystemTable(tableName);
159         ((TableCharacteristics)tables[0]).setCollator(null);
160         ColumnBytesTable columnBytesTable = new ColumnBytesTable(tableName,4,(TableProperties)tables[1],(_TableCharacteristics)tables[0],persistentDatabase.getVersionHandler());
161         columnBytesTable.setTable(new PersistentTable(tableName,persistentDatabase,firstCC,lastCC));
162         _Table columnInfoTable = new Table(tableName,persistentDatabase,columnBytesTable);
163         tablesMap.put(tableName,columnInfoTable);
164     }
165 
166     /**
167      * Read all the information for the tableName passed from system tables and returns the appropriate table.
168      *
169      * @param tableName
170      * @throws DException If Table doesn't exist.
171      */
172 
173     _Table getTable(QualifiedIdentifier tableName) throws DException {
174         _Table table =(_Table)tablesMap.get(tableName);
175         if(table != null){
176           return table;
177         }
178         BufferRange[] bytes = Utility.getBufferRangeForTableName(tableName);
179         _DataTable tableInfoTable = (_DataTable)getTable(SystemTables.TABLEINFO);
180         DatabaseUserTableIterator tableInfoIterator =(DatabaseUserTableIterator)tableInfoTable.getIterator();
181         if(tableInfoIterator.first()){
182             try{
183                 seek(indexOnTableInfo,bytes);
184             }
185             catch(DException de){
186                 _IndexKey btreeKey = null;
187                 try {
188                     btreeKey = (_IndexKey)de.getParameters()[0];
189                 }
190                 catch (ClassCastException   ex) {
191                     indexOnTableInfo.showBTree();
192                     throw ex;
193                 }
194                   Object  [] tables = charGenerator.getTableCharacteristicsForUserTable(bytes);
195                 tableInfoIterator.move(btreeKey.getValue());
196                  bytes = (BufferRange[])tableInfoIterator.getColumnValues();
197                 ClusterCharacteristics firstCC = new ClusterCharacteristics(CCzufDpowfsufs.getIntValue(bytes[3].getBytes(),0),false) ;
198                 String   language = bytes[4].getNull() ? null : new String  (bytes[4].getBytes());
199                 String   country = bytes[5].getNull() ? null : new String  (bytes[5].getBytes());
200                 Collator collator = country == null ? null : Collator.getInstance(new Locale(language,country));
201                 ((TableCharacteristics)tables[0]).setCollator(collator);
202                 _TableList columnBytesTable = new ColumnBytesTable(tableName,4,(TableProperties)tables[1],(_TableCharacteristics)tables[0],persistentDatabase.getVersionHandler());
203                 columnBytesTable.setTable(new PersistentTable(tableName, persistentDatabase,firstCC, firstCC));
204                           table = new Table(tableName,persistentDatabase,columnBytesTable);
205          tablesMap.put(tableName,table);
206                 return table;
207             }
208         }
209         throw new DException("DSE959",new Object  [] {tableName.toString() });
210     }
211 
212 
213     /**
214      * Stores all Information of table In tableInfo and columnInfo system Tables.
215 
216      * @param tableName Name of table
217      * @param columnInfo Column Information of new table
218      * @throws DException If a Table Already exist with this name
219      */
220 
221     void createTable(QualifiedIdentifier tableName, Object   columnInfo) throws DException {
222         BufferRange[] bytes = Utility.getBufferRangeForTableName(tableName);
223         DatabaseUserTableIterator tableInfoIterator = (DatabaseUserTableIterator)((_DataTable)getTable(SystemTables.TABLEINFO)).getIterator();
224         try{
225             seek(indexOnTableInfo,bytes);
226         }
227         catch(DException de){
228             if(!de.getDseCode().equalsIgnoreCase("DSE2037"))
229                 throw de;
230             throw new DException("DSE1135",new Object  [] {tableName.toString() });
231         }
232         ArrayList list = new ArrayList();
233         list.add(SystemTables.TABLEINFO);
234         list.add(SystemTables.COLUMNINFO);
235         _DatabaseUser user = persistentDatabase.getDatabaseUser(list);
236         try{
237             ColumnInformation columnInformation = ((ColumnInformation)columnInfo);
238             BufferRange add = new BufferRange(CCzufDpowfsufs.getBytes(persistentDatabase.createClusterCharacteristics(user,tableName).getStartAddress()));
239             String   country = columnInformation.getCountry();
240             String   langauge = columnInformation.getLanguage();
241             BufferRange nameBuffer = country == null ? FieldUtility.NULLBUFFERRANGE : new BufferRange(CCzufDpowfsufs.getBytes(country,-1,false));
242             BufferRange langBuffer = langauge == null ? FieldUtility.NULLBUFFERRANGE : new BufferRange(CCzufDpowfsufs.getBytes(langauge,-1,false));
243 
244             BufferRange[] bytesForTableInfo = new BufferRange[] {bytes[0],bytes[1],bytes[2],add,langBuffer,nameBuffer};
245             tableInfoIterator.insert(user,bytesForTableInfo);
246             indexOnTableInfo.insert(user,bytes,tableInfoIterator.getKey());
247             _DataTable columnInfoTable = (_DataTable)getTable(SystemTables.COLUMNINFO);
248             _TableIterator columnInfoIterator = columnInfoTable.getIterator();
249             Object  [][] columnInfoArray = columnInformation.getObjects();
250             ArrayList blobClobAddressList = new ArrayList();
251             for(int i = 0 ,blobAddresss = -1,len = columnInfoArray.length; i < len ; i++){
252                  blobAddresss = -1;
253                 if(Utility.isBlobClob(columnInfoArray[i][1].hashCode())){
254                   Cluster cluster = persistentDatabase.getNewCluster(user,tableName);
255                   blobAddresss = cluster.getClusterAddress();
256                     blobClobAddressList.add(new Long  (blobAddresss)) ;
257                   cluster.updateBytes(3*versionHandler.LENGTH,CCzufDpowfsufs.getBytes(blobAddresss));
258                 }
259                 BufferRange[] bytesForColumnInfo = new BufferRange[] {bytes[0],bytes[1],bytes[2],new BufferRange( ((String  )columnInfoArray[i][0]).getBytes()),
260                     new BufferRange(CCzufDpowfsufs.getBytes((Long  )columnInfoArray[i][1])),
261                     new BufferRange(CCzufDpowfsufs.getBytes((Integer  )columnInfoArray[i][2])),
262                     new BufferRange(CCzufDpowfsufs.getBytes((Long  )columnInfoArray[i][3])),new BufferRange(CCzufDpowfsufs.getBytes(blobAddresss)) };
263 
264                 ((_UserTableOperations)columnInfoIterator).insert(user,bytesForColumnInfo);
265                 BufferRange[] ciBytes = new BufferRange[] {bytes[0],bytes[1],bytes[2],new BufferRange(CCzufDpowfsufs.getBytes((Long  )columnInfoArray[i][3]))};
266                     indexOnColumnInfo.insert(user,ciBytes,columnInfoIterator.getKey());
267             }
268             user.writeToFile();
269             ClusterCharacteristics firstCC = new ClusterCharacteristics(CCzufDpowfsufs.getIntValue(add.getBytes() ,0),false) ;
270                   Collator collator = country == null ? null : Collator.getInstance(new Locale(langauge,country));
271                    Object  [] tables = charGenerator.getTableCharacteristicsFromColumnInformation(columnInformation ,false,blobClobAddressList.size() > 0 ? (Long  [])blobClobAddressList.toArray(new Long  [0]  ) : new Long  [0]) ;
272                   ((TableCharacteristics)tables[0]).setCollator(collator);
273                   _TableList columnBytesTable = new ColumnBytesTable(tableName,4,(TableProperties)tables[1],(_TableCharacteristics)tables[0],persistentDatabase.getVersionHandler());
274                   columnBytesTable.setTable(new PersistentTable(tableName, persistentDatabase,firstCC, firstCC));
275                   Table table;
276                        table = new Table(tableName,persistentDatabase,columnBytesTable);
277 
278                   tablesMap.put(tableName,table);
279 
280         }
281         finally{
282             user.releaseCluster();
283         }
284     }
285 /*     bytes = (BufferRange[])tableInfoIterator.getColumnValues();
286        ClusterCharacteristics firstCC = new ClusterCharacteristics(CCzufDpowfsufs.getIntValue(bytes[3].getBytes(),0),false) ;
287                     String language = bytes[4].getNull() ? null : new String(bytes[4].getBytes());
288                     String country = bytes[5].getNull() ? null : new String(bytes[5].getBytes());
289                     Collator collator = country == null ? null : Collator.getInstance(new Locale(language,country));
290                     ((TableCharacteristics)tables[0]).setCollator(collator);
291                     _TableList columnBytesTable = new ColumnBytesTable(tableName,4,(TableProperties)tables[1],(_TableCharacteristics)tables[0],persistentDatabase.getVersionHandler());
292                     columnBytesTable.setTable(new PersistentTable(tableName, persistentDatabase,firstCC, firstCC));
293                     table = new Table(tableName,persistentDatabase,columnBytesTable);
294                     tablesMap.put(tableName,table);
295 
296      */
297     /**
298      * It removes all the information of table From TABLEINFO and COLUMNINFO System Table. It gets all
299      * clusters allocted to this table and puts addresses of these clusters in CLUSTERINFO SystemTable
300 
301      * @param tableName Name of Table
302      * @throws DException if table is used by another user or table does not exists
303      */
304 
305     void dropTable(QualifiedIdentifier tableName) throws DException {
306         if(tablesMap.containsKey(tableName)){
307           throw new DException("DSE1211", null);
308         }
309         BufferRange[] bytes = Utility.getBufferRangeForTableName(tableName);
310         _DataTable tableInfoTable = (_DataTable)getTable(SystemTables.TABLEINFO);
311         DatabaseUserTableIterator tableInfoIterator =(DatabaseUserTableIterator)tableInfoTable.getIterator();
312         _DatabaseUser databaseUser = null;
313         if(tableInfoIterator.first()){
314             try{
315                 seek(indexOnTableInfo,bytes);
316             }
317             catch(DException de) {
318                 ArrayList list = new ArrayList();
319                 list.add(SystemTables.TABLEINFO);
320                 list.add(SystemTables.COLUMNINFO);
321                 databaseUser = persistentDatabase.getDatabaseUser(list);
322                 _IndexKey btreeKey = (_IndexKey) de.getParameters()[0];
323                 tableInfoIterator.move(btreeKey.getValue());
324                 try{
325                     BufferRange array = (BufferRange)tableInfoIterator.getColumnValues(versionHandler.TABLEINFO_STARTCLUSTERADDRESS);
326                     int firstClusterAddress = CCzufDpowfsufs.getIntValue(array.getBytes(),0);
327                     removeClusters(firstClusterAddress,databaseUser,tableName);
328 
329                     TableCharacteristics tc = (TableCharacteristics)(charGenerator.getTableCharacteristicsForUserTable(Utility.getBufferRangeForTableName(tableName)))[0];
330                     int[] startAddressBlobColumns = new int[tc.isBlobClobTable()];
331                     if(tc.isBlobClobTable()>0)
332                       startAddressBlobColumns =  tc.getStartAddressesOfBlobColumns();
333                      for (int i = 0; i < startAddressBlobColumns.length; i++) {
334                       if(startAddressBlobColumns[i]!=-1){
335                         removeClusters(startAddressBlobColumns[i], databaseUser,
336                                        tableName);
337                       }
338                      }
339                      indexOnTableInfo.delete(databaseUser,bytes,tableInfoIterator.getKey());
340                     ((_UserTableOperations)tableInfoIterator).delete(databaseUser);
341                     removeFromColumnInfoTable(bytes,databaseUser);
342                     databaseUser.writeToFile();
343                     return;
344                 }finally{
345                     databaseUser.releaseCluster();
346                 }
347 
348             }
349         }
350         throw new DException("DSE959",new Object  [] {tableName.toString() });
351     }
352 
353     /**
354      * Renames the Table with new name by Updating name in TABLEINFO and COLUMNINFO System Table.
355      *
356      * @param oldTableName : Old Name of table
357      * @param newTableName : New Name of table
358      * @throws DException if Table does not exists or table is used by another user
359      */
360 
361     void renameTable(QualifiedIdentifier oldTableName,QualifiedIdentifier newTableName) throws DException{
362         if(tablesMap.containsKey(oldTableName))
363             throw new DException("DSE1211",null);
364         BufferRange[] bytes = Utility.getBufferRangeForTableName(oldTableName);
365         BufferRange[] newBytes = Utility.getBufferRangeForTableName(newTableName);
366         _DataTable tableInfoTable = (_DataTable)getTable(SystemTables.TABLEINFO);
367         DatabaseUserTableIterator tableInfoIterator =(DatabaseUserTableIterator)tableInfoTable.getIterator();
368         _DatabaseUser user = null;
369         if(tableInfoIterator.first()){
370             try {
371                 seek(indexOnTableInfo,bytes);
372             }
373             catch (DException ex) {
374                 ArrayList list = new ArrayList();
375                 list.add(SystemTables.TABLEINFO);
376                 list.add(SystemTables.COLUMNINFO);
377                 user = persistentDatabase.getDatabaseUser(list);
378                 try{
379                     Object   key = ex.getParameters()[0];
380                      tableInfoIterator.move(((_IndexKey)key).getValue());
381                     Object   oldBTreeValue = tableInfoIterator.getKey();
382                     ((_UserTableOperations)tableInfoIterator).update(user,new int[] {versionHandler.TABLEINFO_CATALOGNAME,versionHandler.TABLEINFO_SCHEMANAME,versionHandler.TABLEINFO_TABLENAME},newBytes);
383                     indexOnTableInfo.update(user,bytes,newBytes,oldBTreeValue,tableInfoIterator.getKey());
384                     updateColumnInfoTable(bytes,newBytes,user);
385                     user.writeToFile();
386                     return;
387                 }finally{
388                     user.releaseCluster();
389                 }
390 
391             }
392         }
393         throw new DException("DSE959",new Object  [] {oldTableName.toString() });
394     }
395     /**
396      * @param tableName to be removed.
397      */
398     void removeTable(QualifiedIdentifier tableName){
399         tablesMap.remove(tableName);
400     }
401     /**
402      * It checks free cluster list if any free cluster address exists than it
403      *  will return it else -1 is reurn
404      * @param user _DatabaseUser
405      * @throws DException
406      * @return int
407      */
408     int checkFreeClusterList(_DatabaseUser user) throws DException{
409         return freeClusterList.checkFreeClusterList(user);
410     }
411     /**
412      * It adds this passed cluster address into free list.
413      *
414      * @param user _DatabaseUser - database user
415      * @param address int        - address of free cluster.
416      * @throws DException
417      */
418     void addFreeCluster(_DatabaseUser user, int address)throws DException{
419         freeClusterList.addFreeCluster(user,address);
420     }
421     /**
422      * It checks tableName into iterator and if found any match than throw an
423      * excpetion.
424      * @param iterator _TableIterator        -  iterator on index info table.
425      * @param tableName QualifiedIdentifier  -  name of table.
426      * @throws DException
427      */
428     private void evaluate(_TableIterator iterator,QualifiedIdentifier tableName) throws DException{
429         BufferRange[] bytes = Utility.getBufferRangeForTableName(tableName);
430         BufferRange[] array;
431         do{
432             array = (BufferRange[])iterator.getColumnValues(new int[] {0,1,2});
433             if(nameComparator.compare(bytes,array) == 0)
434                 throw new DException("DSE2037",new Object  [] {tableName.toString() });
435         }while(iterator.next());
436     }
437 
438 
439     /**
440      * It creats index on system tables tableInfo and columnInfo.
441      * If flag is true means there is no information of these indexes in DATABASE INDEX INFO
442      *
443      * @param flag
444      */
445 
446     _Index createIndexOnSystemTable(QualifiedIdentifier tableName,boolean flag) throws DException{
447         QualifiedIdentifier temp = new QualifiedIdentifier(tableName.catalog,tableName.schema,tableName.name+"TEMP");
448         _DatabaseUser user = null;
449         _Table srcTable = getTable(tableName);
450         _Table indexInfoTable = getTable(SystemTables.DATABASEINDEXINFO);
451         _TableIterator iterator = ((_DataTable)indexInfoTable).getIterator();
452         _TableCharacteristics tcOfIndexInfo = indexInfoTable.getTableCharacteristics();
453         String   indexName = tableName.name+"TEMP";
454         if(flag){
455             ArrayList list = new ArrayList();
456             list.add(SystemTables.TABLEINFO);
457             list.add(SystemTables.COLUMNINFO);
458             user = persistentDatabase.getDatabaseUser(list);
459 
460             int clusterAddress = persistentDatabase.getControlCluster(user).getStartAddress();
461             try{
462                 BufferRange[] ranges = Utility.getBufferRangeForTableName(tableName);
463                 BufferRange[] val = new BufferRange[] {ranges[0],ranges[1],ranges[2],
464                     new BufferRange(indexName.getBytes()),new BufferRange(CCzufDpowfsufs.getBytes(clusterAddress)),new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE))};
465                 ((_UserTableOperations)iterator).insert(user,val);
466                 user.writeToFile();
467             }finally{
468                 user.releaseCluster();
469             }
470         }else{
471             try {
472                 if(iterator.first()){
473                     evaluate(iterator,tableName);
474                 }
475                 new Exception  (" ********** IT'S IMPOSSIBLE ************* ").printStackTrace();
476             }catch(Exception   ex) {
477             }
478         }
479         SuperComparator comparator = null; /*tableName.equals(SystemTables.FREESPACEINFO) ? getComparator(false,new boolean[] {true,true,true,true},srcTable.getTableCharacteristics().getColumnTypes())
480                                       : getComparator(false,new boolean[] {true,true,true},srcTable.getTableCharacteristics().getColumnTypes());*/
481         if(tableName.equals(SystemTables.FREESPACEINFO)){
482             comparator = getComparator(new boolean[] {true,true,true,true},srcTable.getTableCharacteristics().getColumnTypes(new int[] {0,1,2,3}));
483         }
484         else if(tableName.equals(SystemTables.COLUMNINFO)){
485             comparator = getComparator(new boolean[] {true,true,true,true},srcTable.getTableCharacteristics().getColumnTypes(new int[] {0,1,2,6}));
486         }
487         else{
488             comparator = getComparator(new boolean[] {true,true,true},srcTable.getTableCharacteristics().getColumnTypes(new int[] {0,1,2}));
489         }
490 
491           _IndexInformation iinf = versionHandler.getIndexInformation(tableName,indexName,temp,iterator,tcOfIndexInfo) ;
492         IndexColumnInformation indexColumnInformation = new IndexColumnInformation(srcTable.getTableCharacteristics(),iinf.getColumnInformation(),iinf.isVariableColumn());
493         _Index btree = versionHandler.getIndex(comparator,null,indexColumnInformation,persistentDatabase,iinf.getControlClusterAddress(),new CUbcmfLfzIboemfs(),true);
494         btree.setIndexInformation(iinf);
495         btree.setDuplicateAllowed(false);
496         return btree;
497     }
498 
499 
500     /**
501      * It seeks passed key into btree if found than an exception is thrown.
502      *
503      * @param btree _Index            - btree in which key is to be searched.
504      * @param indexKey BufferRange[]
505      * @throws DException
506      */
507     void seek(_Index btree,BufferRange[] indexKey) throws DException{
508         Object   obj = btree.seek(indexKey);
509         if(obj != null){
510             throw new DException("DSE2037",new Object  [] {obj});
511         }
512     }
513 
514     /**
515      * If flag is true means there is no information of these indexes in DATABASE INDEX INFO
516      */
517 
518     void initializeSystemTableIndexes(boolean flag) throws DException{
519         indexOnTableInfo = createIndexOnSystemTable(SystemTables.TABLEINFO,flag);
520         indexOnColumnInfo = createIndexOnSystemTable(SystemTables.COLUMNINFO,flag);
521     }
522     /**
523      * @return _Index of columnInfo table.
524      */
525     _Index getIndexOnColumnInfo() {
526         return indexOnColumnInfo;
527     }
528 
529     /**
530      *  To get super comperator.
531      * @param orderColumns boolean[]
532      * @param types int[]
533      * @throws DException
534      * @return SuperComparator
535      */
536     private SuperComparator getComparator(boolean[] orderColumns,int[] types) throws DException{
537        int len = types.length ;
538       SuperComparator[] comparator = new SuperComparator[len];
539         for(int i = 0 ; i < len ; i++ )
540             comparator[i] = GetByteComparator.getComparator(types[i],true,null);
541         return new ByteComparator(orderColumns,comparator);
542     }
543     /**
544      * It seeks index key into passed btree from bottom relative.
545      *
546      * @param btree _Index               - btree in which index key is to be searched.
547      * @param indexKey BufferRange[]     - key to be searched.
548      * @throws DException
549      */
550     private void seekBottom(_Index btree,BufferRange[] indexKey) throws DException{
551         Object   obj = btree.seekFromBottomRelative(null,indexKey);
552         if(obj != null){
553             throw new DException("DSE2037",new Object  [] {obj});
554         }
555     }
556 
557     /**
558      * Add all the clusters of the table into free cluster list.
559      *
560      * @param firstClusterAddress FirstCluster address Of Table
561      * @param databaseUser        Database User
562      * @param tableName           Name Of Table
563      */
564 
565     private void removeClusters( int firstClusterAddress, _DatabaseUser databaseUser,QualifiedIdentifier tableName) throws DException{
566         while(firstClusterAddress != 0){
567             ClusterCharacteristics cc = new ClusterCharacteristics(firstClusterAddress,false);
568             Cluster cluster = persistentDatabase.getClusterForWrite(databaseUser,cc);
569             int temp = firstClusterAddress;
570             firstClusterAddress = CCzufDpowfsufs.getIntValue(cluster.getBytes(),databaseProperties.NEXTCLUSTERADDRESS);
571             persistentDatabase.addFreeCluster(databaseUser,temp);
572         }
573 
574     }
575     /**
576      * It removes all informations of columns of a table.
577      * It seeks in index and move iterator of table according to key found.
578      * and delete from index and table and comparing next entry if it is matched
579      * than it also deleted from table and index  untill a match failures.
580      *
581      * @param bytes BufferRange[]               - name of table whoose columns info to be removed.
582      * @param databaseUser _DatabaseUser
583      * @throws DException
584      */
585     private void removeFromColumnInfoTable(BufferRange[] bytes,_DatabaseUser databaseUser)throws DException{
586         _DataTable columnInfoTable = (_DataTable)getTable(SystemTables.COLUMNINFO);
587         DatabaseUserTableIterator columnInfoIterator = (DatabaseUserTableIterator)columnInfoTable.getIterator();
588         try {
589             seek(indexOnColumnInfo,bytes);
590         }
591         catch(DException ex) {
592            columnInfoIterator.move(((_IndexKey)ex.getParameters()[0]).getValue());
593             boolean flag = true;
594             BufferRange[] brs;
595             do{
596                  brs = new BufferRange[] {bytes[0],bytes[1],bytes[2],(BufferRange)columnInfoIterator.getColumnValues(6)};
597                 indexOnColumnInfo.delete(databaseUser,brs,columnInfoIterator.getKey());
598                 ((_UserTableOperations)columnInfoIterator).delete(databaseUser);
599                 flag = columnInfoIterator.next();
600                 if(flag){
601                     BufferRange[] arr = (BufferRange[])columnInfoIterator.getColumnValues(new int[] {0,1,2});
602                     flag = nameComparator.compare(bytes,arr) == 0;
603                 }
604             } while(flag);
605         }
606     }
607     /**
608      * It is used in rename table to update tableName in columnInfo table.
609        It seeks in index and move iterator of table according to key found.
610      * and update into index and table and comparing next entry if it is matched
611      * than it also updated into table and index untill a match failures.
612 
613      * @param bytes BufferRange[]          - old tableName bytes.
614      * @param newBytes BufferRange[]       - new tableName bytes
615      * @param user _DatabaseUser
616      * @throws DException
617      */
618     private void updateColumnInfoTable(BufferRange[] bytes,BufferRange[] newBytes,_DatabaseUser user) throws DException{
619           _TableIterator columnInfoIterator = ((_DataTable)getTable(SystemTables.COLUMNINFO)).getIterator();
620         try {
621             seekBottom(indexOnColumnInfo,bytes);
622         }
623         catch (DException de) {
624             Object   key = de.getParameters()[0];
625              columnInfoIterator.move(((_IndexKey)key).getValue());
626             boolean flag = true;
627             BufferRange oldB,newB;
628             BufferRange[] oldBrs,newBrs;
629             do{
630                 Object   oldbtValue = columnInfoIterator.getKey();
631                  oldB = new BufferRange(((BufferRange)columnInfoIterator.getColumnValues(6)).getBytes());
632                 ((_UserTableOperations)columnInfoIterator).update(user,new int []{versionHandler.COLUMNINFO_CATALOGNAME,versionHandler.COLUMNINFO_SCHEMANAME,versionHandler.COLUMNINFO_TABLENAME},newBytes);
633                  newB = new BufferRange(((BufferRange)columnInfoIterator.getColumnValues(6)).getBytes());
634                  oldBrs = new BufferRange[] {bytes[0],bytes[1],bytes[2],oldB};
635                  newBrs = new BufferRange[] {newBytes[0],newBytes[1],newBytes[2],newB};
636                 indexOnColumnInfo.update(user,oldBrs,newBrs,oldbtValue,columnInfoIterator.getKey());
637                 flag = columnInfoIterator.previous();
638                 if(flag){
639                     BufferRange[] arr = (BufferRange[])columnInfoIterator.getColumnValues(new int[] {0,1,2});
640                     flag = nameComparator.compare(bytes,arr) == 0;
641                 }
642             }while(flag);
643         }
644     }
645 
646     /**
647      * For Testing Purpose
648      */
649 
650     _Table getTableInfo() throws DException{
651         _Table table =(_Table)tablesMap.get(SystemTables.TABLEINFO);
652         return table;
653     }
654 
655     /**
656      * Methods Written Below are Not Used Now
657      */
658 
659 
660 
661     ClusterCharacteristics getLastClusterClaracteristics(QualifiedIdentifier tableName) throws DException{
662         _TableIterator iterator = ((_DataTable)getTable(SystemTables.TABLEINFO)).getIterator();
663         try {
664             seek(indexOnTableInfo,Utility.getBufferRangeForTableName(tableName));
665         }
666         catch (DException ex) {
667             _IndexKey element = (_IndexKey)ex.getParameters()[0];
668             iterator.move(element.getValue());
669             return new ClusterCharacteristics(CCzufDpowfsufs.getIntValue(((BufferRange)iterator.getColumnValues(4)).getBytes(),0),false);
670         }
671         throw new DException("DSE959",new Object  []{tableName.toString() });
672     }
673     /**
674      * @return HashMap which contains all tables of database.
675      */
676     public HashMap getTableMap(){
677       return tablesMap ;
678     }
679     /**
680      * To initialize free cluster list.
681      * @throws DException
682      */
683     public void initializeFreeClusterList() throws DException {
684       freeClusterList = new FreeClusterList(getTable(SystemTables.CLUSTERINFO));
685     }
686     /**
687      * It is used for testing to show all free cluster addresses.
688      * @throws DException
689      */
690     public void showFreeClusterList() throws DException{
691       freeClusterList.showFreeClusterList( );
692     }
693     /**
694      * @return FreeClusterList which has information of free clusters.
695      */
696     public FreeClusterList getFreeClusterList(){
697        return freeClusterList;
698     }
699 }
700
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags