|
1 package com.daffodilwoods.daffodildb.server.datasystem.indexsystem;
2
3 import java.util.*;
4
5 import com.daffodilwoods.daffodildb.server.datadictionarysystem.*;
6 import com.daffodilwoods.daffodildb.server.datasystem.btree.*;
7 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
8 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.*;
9 import com.daffodilwoods.daffodildb.server.datasystem.utility.*;
10 import com.daffodilwoods.daffodildb.server.sql99.common.*;
11 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.*;
12 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.order.*;
13 import com.daffodilwoods.daffodildb.server.sql99.dql.queryexpression.orderbyclause.*;
14 import com.daffodilwoods.daffodildb.utils.*;
15 import com.daffodilwoods.daffodildb.utils.byteconverter.*;
16 import com.daffodilwoods.daffodildb.utils.field.*;
17 import com.daffodilwoods.database.general.*;
18 import com.daffodilwoods.database.resource.*;
19 import com.daffodilwoods.database.utility.*;
20
21 public class TempIndexDatabase extends IndexDatabase {
22 public int tableNumber = 1000;
23 public HashMap tempBTreeList = new HashMap();
24 private int totalNoTables = 0;
25
26 public TempIndexDatabase(_Database database0) throws DException {
27 super(database0,false);
28 }
29
30 public void createTable(QualifiedIdentifier tableName, Object  columnInfo) throws DException {
31 super.createTable(tableName, columnInfo);
32 if( totalNoTables % 50 == 0 ){
33 for (Iterator iter = super.indexTablesMap.keySet() .iterator(); iter.hasNext(); ) {
34 Object item = (Object )iter.next();
35 if(super.indexTablesMap.get(item) instanceof _TempDataUser ){
36 _TempDataUser table1 = (_TempDataUser)super.indexTablesMap.get(item) ;
37 if( table1 != null){
38 table1.getDatabaseUser().writeToFileWithLock() ;
39 }
40 }
41 }
42 }
43
44 }
45
46
52
53 public synchronized void dropTable(QualifiedIdentifier tableName) throws DException {
54 _TempDataUser table = (_TempDataUser) indexTablesMap.remove(tableName);
55 if (table != null) {
56 _DatabaseUser user = table.getDatabaseUser();
57 user.writeToFile();
58
59 }
60 try {
61 database.removeTable(tableName);
62 database.dropTable(tableName);
63 } catch (DException ex) {
64 if (!ex.getDseCode().equalsIgnoreCase("DSE959"))
65 throw ex;
66 }
67 }
68
69 public void removeTable(QualifiedIdentifier tableName) throws DException {
70 dropTable(tableName);
71 totalNoTables--;
72 }
73
74 public synchronized void dropTemporaryIndex(QualifiedIdentifier tableName, String indexName) throws DException {
75 _IndexTableList table = (_IndexTableList) indexTablesMap.get(tableName);
76 if (table != null) {
77 ArrayList tables = new ArrayList();
78 tables.add(SystemTables.CLUSTERINFO);
79 _DatabaseUser user = getDatabaseUser(tables);
80 try {
81 removeBtreeFromIndexTable(table, indexName, user);
82 user.writeToFile();
83 } catch (DException de) {
84 user.rollback();
85 } finally {
86 user.releaseCluster();
87 }
88 }
89 }
90
91
94
95 public void createTemporaryIndex(QualifiedIdentifier tableName, String indexName, _IndexInformation info) throws DException {
96 _IndexInformation iinf = new IndexInformations(tableName, info.getIndexName(), info.getControlClusterAddress(), info.isVariableColumn(), info.getColumnInformation(),versionHandler);
97 try {
98 createPermanantIndex(tableName, indexName, iinf);
99 } catch (DException de) {
100 return;
101 }
102 }
103
104 public void createPermanantIndex(QualifiedIdentifier tableName, String indexName, _IndexInformation indexInformationGetter) throws DException {
105 if (indexTablesMap.get(tableName)== null)
106 return;
107 _TempDataUser table = (_TempDataUser) indexTablesMap.get(tableName);
108 _DatabaseUser user = table.getDatabaseUser();
109 createPermanentIndex1(tableName, indexName, indexInformationGetter, user);
110 user.writeToFileWithLock();
111 }
112
113 public synchronized _Table getTable(QualifiedIdentifier tableName, _IndexInformation[] info) throws DException {
114 _Table table = (_Table) indexTablesMap.get(tableName);
115 if (table != null)
116 return table;
117 if( totalNoTables % 50 == 0 ){
118 for (Iterator iter = super.indexTablesMap.keySet() .iterator(); iter.hasNext(); ) {
119 Object item = (Object )iter.next();
120 if(super.indexTablesMap.get(item) instanceof _TempDataUser ){
121 _TempDataUser table1 = (_TempDataUser)super.indexTablesMap.get(item) ;
122 if( table1 != null){
123 table1.getDatabaseUser().writeToFileWithLock() ;
124 }
125 }
126 }
127 }
128 totalNoTables++;
129 _Table tab = database.getTable(tableName);
130 int length = info == null ? 0 : info.length;
131
132 _Index[] indexes = new _Index[length];
133 ArrayList list = new ArrayList();
134 list.add(tableName);
135 _DatabaseUser user = database.getDatabaseUser(list);
136 _IndexInformation iinf;
137 for (int i = 0; i < length; i++) {
138 iinf = new IndexInformations(tableName, info[i].getIndexName(), info[i].getControlClusterAddress(), info[i].isVariableColumn(), info[i].getColumnInformation(),versionHandler);
139 createPermanentIndex1(tableName, iinf.getIndexName(), iinf, user);
140 indexes[i] = super.getPermanantIndex(tableName, iinf);
141 }
142 user.writeToFileWithLock();
143 _IndexTable columnObjectTable = null;
144 TableCharacteristics tc = (TableCharacteristics) tab.getTableCharacteristics();
145 boolean isBlobClobTable = (tc.isBlobClobTable() == 0);
146 LobManager lobManager = isBlobClobTable
147 ? null : new LobManager( (PersistentDatabase) database, tc.getStartAddressesOfBlobColumns());
148 if (!isBlobClobTable)
149 columnObjectTable = new TempBlobClobColumnObjectsTable(user, (_DataTable) tab, tableName, lobManager);
150 else
151 columnObjectTable = new TempColumnObjectsTable(user, (_DataTable) tab, tableName, lobManager);
152 ( (_IndexTableList) columnObjectTable).setTable(new TempIndexTable(user, tableName, indexes));
153 indexTablesMap.put(tableName, columnObjectTable);
154 return columnObjectTable;
155 }
156
157 private void createPermanentIndex1(QualifiedIdentifier tableName, String indexName, _IndexInformation iinf, _DatabaseUser user) throws DException {
158 iinf.setControlClusterAddress(-1);
159 createPermanantIndexes(tableName, (IndexInformations) iinf, user);
160 }
161
162 public synchronized void getStatus() throws DException {
163 PersistentDatabase persistentDatabase = (PersistentDatabase) database;
164 HashMap tablesMap = persistentDatabase.getTablesMap();
165 int totalTables = tablesMap.size();
166 Set keySet = tablesMap.keySet();
167 Iterator iterator = keySet.iterator();
168 if (iterator.hasNext()) {
169 do {
170 QualifiedIdentifier tableName = (QualifiedIdentifier) iterator.next();
171 Table table = (Table)persistentDatabase.getTable(tableName) ;
172 int numberOfClusterUsedInTable = ((PersistentTable)((ColumnBytesTable)table.getTable()).getTable()).getClusterIterator().getNumberOfClustersUsed() ;
173 _IndexTable indexTable = null;
174 boolean isIndexInfoRelatedTable = false;
175 try {
176 indexTable = (_IndexTable) getTable(tableName);
177 } catch (NullPointerException np) {
178 if (tableName.getName().equalsIgnoreCase("COLUMNINFO"))
179 ; } catch (ClassCastException ex1) {
181 if (tableName.getName().equalsIgnoreCase("DATABASEINDEXINFO")) {
182 ; } else if (tableName.getName().equalsIgnoreCase("DATABASEINDEXCOLUMNS")) {
184 ; } else if (tableName.getName().equalsIgnoreCase("DATABASEFULLTEXTINFO")) {
186 ; } else if (tableName.getName().equalsIgnoreCase("DATABASEFULLTEXTCOLUMNINFO")) {
188 ; } else
190 throw ex1;
191
192 isIndexInfoRelatedTable = true;
193 }
194 try {
195 if (!isIndexInfoRelatedTable) {
196 int noOfIndexes = indexTable.getIndexInformations().length;
197 for (int i = 0; i < noOfIndexes; i++) {
198 _Index btree = ( (IndexTableIterator) ( (IteratorWrapper) (
199 indexTable).getIterator(i)).getIndexIterator()).getBtree();
200 String columnNames[] = btree.getColumnNames();
201 int size = btree.getTotalNumberOfClusterLoadedInMemory();
202
203 }
204 }
205 } catch (NullPointerException ex) {
206 }
207
208 } while (iterator.hasNext());
209
210 }
211 persistentDatabase.showFreeClusterList() ;
212
213 }
214
215
216 public _Index makeBTree(TemporaryIndexIterator temporaryIndexIterator) throws DException {
217 _Iterator iterator = temporaryIndexIterator.getUnderlyingIterator();
218 if(!iterator.first())
219 return new DummyBTree();
220 if(tempBTreeList.size() > 0){
221 removeTempBTree();
222 }
223
224 ArrayList list = new ArrayList();
225 QualifiedIdentifier lockObject = new QualifiedIdentifier("btree", "btree", "" + getNextTableNumber());
226 _DatabaseUser user = null;
227 try {
228 if (temporaryIndexIterator.getBtree() != null){
229 list.add(lockObject);
230 list.add(SystemTables.CLUSTERINFO);
231 user = database.getDatabaseUser(list);
232 temporaryIndexIterator.getBtree().releaseResource(user,true);
233 user.writeToFile();
234 }
235 _ExpressionOrderValues order = temporaryIndexIterator.getOrder();
236 ColumnDetails[] columnDetails = order.getKeyColumnDetails();
237 IndexColumnInformation indexColumnInformation = new IndexColumnInformation(columnDetails, order);
238 IndexInformations iinf = new IndexInformations(order.getColumns(),versionHandler);
239 list = new ArrayList();
240 list.add(lockObject);
241
242 user = database.getDatabaseUser(list);
243 _AbstractBTreeValue abstractBtreeValue = null;
244 _Index btree = null;
245 if (temporaryIndexIterator.getBtreeValueHandler().isVariable()) {
246 btree = versionHandler.getIndex(order.getComparatorForBufferRange(), null, indexColumnInformation, (_ClusterProvider) database, -1, new CUbcmfLfzIboemfs(),false);
247 btree.setIndexInformation(iinf);
248 if (temporaryIndexIterator.getAbstractBtreeValue() != null) {
249 QualifiedIdentifier tableName = ( (TableKeyValue) temporaryIndexIterator.getAbstractBtreeValue()).getTableName();
250 if (tableName != null)
251 (temporaryIndexIterator.getTempIndexDatabase()).dropTable(tableName);
252 }
253 abstractBtreeValue = insertRecordForVariableBtree(user, iterator, btree, order, indexColumnInformation);
254 } else {
255
256 btree = versionHandler.getIndex(order.getComparatorForBufferRange(), null, indexColumnInformation, (_ClusterProvider) database, -1, temporaryIndexIterator.getBtreeValueHandler(),false);
257 btree.setIndexInformation(iinf);
258 abstractBtreeValue = insertRecordForFixedBtree(user, temporaryIndexIterator, iterator, btree, order);
259 }
260 temporaryIndexIterator.setAbstractBtreeValue(abstractBtreeValue);
261 user.writeToFile();
262 return btree;
263 }catch(DException e){
264 throw e;
265 } finally {
266 if(user!=null)
267 user.releaseCluster();
268 }
269
270 }
271
272 private _AbstractBTreeValue insertRecordForFixedBtree(_DatabaseUser user, TemporaryIndexIterator temporaryIndexIterator, _Iterator iterator, _Index btree, _ExpressionOrderValues order) throws DException {
273 _AbstractBTreeValue abstractBtreeValue = (_AbstractBTreeValue)new SameKeyValue();
274 int recordInserted = 0;
275 if (iterator.first()) {
276 Object value = iterator.getByteKey();
277 temporaryIndexIterator.getBtreeValueHandler().getBytes(value);
278 Object obj;
279 do {
280 obj = order.getOrderValues(null);
281 value = iterator.getByteKey();
282 btree.insert(user, getBufferRanges(obj), value);
283 recordInserted++;
284 recordInserted = checkMemory(user, recordInserted);
285 } while (iterator.next());
286
287 }
288 return abstractBtreeValue;
289 }
290
291 private _AbstractBTreeValue insertRecordForVariableBtree(_DatabaseUser user, _Iterator iterator, _Index btree, _ExpressionOrderValues order, IndexColumnInformation indexColumnInformation) throws DException {
292 QualifiedIdentifier tableName = new QualifiedIdentifier("users", "users", "" + getNextTableNumber());
293 ColumnInformation columnInfo = new ColumnInformation();
294 Object [][] columnsDetail = new Object [][] { {"value", new Long (Datatype.VARBINARY), new Integer (4192), new Long (0)}
295 };
296
297 columnInfo.setObjects( (Object [][]) columnsDetail);
298 database.createTable(tableName, columnInfo);
299 DatabaseUserTableIterator databaseUserTableIterator = (DatabaseUserTableIterator) ( ( (Table) database.getTable(tableName)).getIterator());
300 _AbstractBTreeValue abstractBtreeValue = (_AbstractBTreeValue)new TableKeyValue(databaseUserTableIterator, tableName);
301 int recordInserted = 0;
302 if (iterator.first()) {
303 Object obj;
304 byte[] value;
305 do {
306 obj = order.getOrderValues(null);
307 value = (byte[]) iterator.getByteKey();
308 databaseUserTableIterator.insert(user, new BufferRange[] {new BufferRange(value, 0, value.length)});
309 btree.insert(user, getBufferRanges(obj), databaseUserTableIterator.getKey());
310 recordInserted++;
311 recordInserted = checkMemory(user, recordInserted);
312 } while (iterator.next());
313
314 }
315 return abstractBtreeValue;
316 }
317
318 private Object getBufferRanges(Object fieldBases) throws DException {
319 Object [] fb = (Object []) fieldBases;
320 int length = fb.length;
321 int recordLength = 0;
322 Object [] result = new BufferRange[length];
323 for (int i = 0; i < length; i++) {
324 result[i] = ( (FieldBase) fb[i]).getBufferRange();
325 recordLength +=( (BufferRange)result[i]).getLength() ;
326 } if(recordLength > 1024 )
328 throw new DException("DSE2056", null);
329
330 return length == 1 ? result[0] : result;
331 }
332
333
334 private int checkMemory(_DatabaseUser user, int recordInserted) throws DException {
335 if (recordInserted > 50 || user.getSize() > 4) {
336 user.writeToFileWithLock();
337 return 0;
338 }
339 return recordInserted;
340 }
341
342
343 private synchronized int getNextTableNumber() {
344 return tableNumber++;
345 }
346
347 private void createPermanantIndexes(QualifiedIdentifier tableName, IndexInformations iinf, _DatabaseUser user) throws DException {
348 _TableIterator iterator = ( (_DataTable) database.getTable(tableName)).getIterator();
349 String [] columns = iinf.getColumns();
350 _Index btree = getPermanantIndex(tableName, iinf);
351 insertRecordsInBTree(iterator, btree, columns, user);
352 updateBTreesInIndexTable(tableName, btree);
353 }
354
355 private synchronized void removeTempBTree() throws DException{
356 _DatabaseUser user = null;
357 Set set = tempBTreeList.entrySet();
358 Iterator i =set.iterator();
359 if(i.hasNext()){
360 Map.Entry m = (Map.Entry)i.next();
361 _Index btree = (_Index)m.getKey();
362 QualifiedIdentifier tableName = (QualifiedIdentifier)m.getValue();
363 i.remove();
364 ArrayList list = new ArrayList();
365 list.add(SystemTables.CLUSTERINFO);
366 try {
367 user = getDatabaseUser(list);
368 btree.releaseResource(user,true);
369 user.writeToFile();
370 }
371 catch (DException ex) {
372 }
373 catch(NullPointerException np){
374 btree.showBTree() ;
375 throw np;
376 }
377 finally{
378 if(user!= null)
379 user.releaseCluster();
380 }
381 if(tableName!= null){
382 dropTable(tableName);
383 }
384
385 }
386 }
387
388 public synchronized void putTempBTree(_Index btree,QualifiedIdentifier tableName){
389 tempBTreeList.put(btree,tableName);
390 }
391 }
392 |
Popular Tags |
Java API By Example, From Geeks To Geeks.