/** implement the abstract method close() from super class Iterator to finish cleaning up */ public void close() { if (!closeFlag) { scan.closescan(); closeFlag = true; } }
// REMOVE INDEX ENTRY FROM CATALOG public void removeInfo(String relation, String attrName, IndexType accessType) throws IOException, Catalogmissparam, Catalogattrnotfound, IndexCatalogException { int recSize; RID rid = null; Scan pscan = null; IndexDesc record = null; if ((relation == null) || (attrName == null)) throw new Catalogmissparam(null, "MISSING_PARAM"); // OPEN SCAN try { pscan = new Scan(this); } catch (Exception e) { throw new IndexCatalogException(e, "scan failed"); } // SCAN FILE while (true) { try { tuple = pscan.getNext(rid); if (tuple == null) throw new Catalogattrnotfound(null, "Catalog: Attribute not Found!"); read_tuple(tuple, record); } catch (Exception e4) { throw new IndexCatalogException(e4, "read_tuple failed"); } if (record.relName.equalsIgnoreCase(relation) == true && record.attrName.equalsIgnoreCase(attrName) == true && (record.accessType == accessType)) { try { deleteRecord(rid); // FOUND - DELETE } catch (Exception e) { throw new IndexCatalogException(e, "deleteRecord() failed"); } break; } } return; };
// RETURN INFO ON AN INDEX public void getInfo(String relation, String attrName, IndexType accessType, IndexDesc record) throws Catalogmissparam, Catalogioerror, Cataloghferror, IOException, Catalogattrnotfound, Exception { int recSize; RID rid = null; Scan pscan = null; if ((relation == null) || (attrName == null)) throw new Catalogmissparam(null, "MISSING_PARAM"); // OPEN SCAN try { pscan = new Scan(this); } catch (IOException e) { System.err.println("Scan" + e); throw new IOException(""); } catch (Exception e1) { System.err.println("Scan" + e1); throw new Exception(""); } // SCAN FILE while (true) { try { tuple = pscan.getNext(rid); if (tuple == null) throw new Catalogattrnotfound(null, "Catalog: Attribute not Found!"); read_tuple(tuple, record); } catch (Exception e4) { throw new IndexCatalogException(e4, "read_tuple failed"); } if (record.relName.equalsIgnoreCase(relation) == true && record.attrName.equalsIgnoreCase(attrName) == true && (accessType == record.accessType)) break; // FOUND } return; };
/** * @return the result tuple * @exception JoinsException some join exception * @exception IOException I/O errors * @exception InvalidTupleSizeException invalid tuple size * @exception InvalidTypeException tuple type not valid * @exception PageNotReadException exception from lower layer * @exception PredEvalException exception from PredEval class * @exception UnknowAttrType attribute type unknown * @exception FieldNumberOutOfBoundException array out of bounds * @exception WrongPermat exception for wrong FldSpec argument */ public Tuple get_next() throws JoinsException, IOException, InvalidTupleSizeException, InvalidTypeException, PageNotReadException, PredEvalException, UnknowAttrType, FieldNumberOutOfBoundException, WrongPermat { RID rid = new RID(); ; while (true) { if ((tuple1 = scan.getNext(rid)) == null) { return null; } tuple1.setHdr(in1_len, _in1, s_sizes); if (PredEval.Eval(OutputFilter, tuple1, null, _in1, null) == true) { Projection.Project(tuple1, _in1, Jtuple, perm_mat, nOutFlds); return Jtuple; } } }
// GET ALL INDEXES FOR A RELATION // Return indexCnt. public int getRelInfo(String relation, int indexCnt, IndexDesc[] indexes) throws Catalogmissparam, Catalogioerror, Cataloghferror, Catalogindexnotfound, IOException, Catalognomem, Catalogattrnotfound, IndexCatalogException, RelCatalogException, Catalogrelnotfound { RelDesc record = null; int status; int recSize; RID rid = null; Scan pscan = null; int count = 0; if (relation == null) throw new Catalogmissparam(null, "MISSING_PARAM"); try { ExtendedSystemDefs.MINIBASE_RELCAT.getInfo(relation, record); } catch (Catalogioerror e) { System.err.println("Catalog I/O Error!" + e); throw new Catalogioerror(null, ""); } catch (Cataloghferror e1) { System.err.println("Catalog Heapfile Error!" + e1); throw new Cataloghferror(null, ""); } catch (Catalogmissparam e2) { System.err.println("Catalog Missing Param Error!" + e2); throw new Catalogmissparam(null, ""); } catch (Catalogrelnotfound e3) { System.err.println("Catalog: Relation not Found!" + e3); throw new Catalogrelnotfound(null, ""); } // SET INDEX COUNT BY REFERENCE indexCnt = record.indexCnt; if (indexCnt == 0) return indexCnt; // OPEN SCAN try { pscan = new Scan(this); } catch (Exception e) { throw new IndexCatalogException(e, "scan() failed"); } // ALLOCATE INDEX ARRAY indexes = new IndexDesc[indexCnt]; if (indexes == null) throw new Catalognomem(null, "Catalog: No Enough Memory!"); // SCAN THE FILE while (true) { try { tuple = pscan.getNext(rid); if (tuple == null) throw new Catalogindexnotfound(null, "Catalog: Index not Found!"); read_tuple(tuple, indexes[count]); } catch (Exception e4) { throw new IndexCatalogException(e4, " read_tuple() failed"); } if (indexes[count].relName.equalsIgnoreCase(relation) == true) count++; if (count == indexCnt) // IF ALL INDEXES FOUND break; } return indexCnt; };
// ADD INDEX TO A RELATION public void addIndex(String relation, String attrName, IndexType accessType, int buckets) throws IOException, Catalogioerror, Cataloghferror, Catalogmissparam, Catalogattrnotfound, Catalogbadtype, Catalognomem, Catalogindexnotfound, IndexCatalogException, java.lang.Exception { RID rid = null; IndexDesc indexRec = null; AttrDesc attrRec = null; int intKey = 0; float floatKey = (float) 0.0; String charKey = null; int attrCnt = 0; KeyClass key = null; int recSize = 0; Heapfile datafile = null; String indexName = null; Tuple tuple = null; BTreeFile btree = null; Scan pscan = null; AttrType[] typeArray = null; short[] sizeArray = null; // CHECK PARM if ((relation == null) || (attrName == null)) throw new Catalogmissparam(null, "MISSING_PARAM"); // CHECK FOR EXISTING INDEX try { getInfo(relation, attrName, accessType, indexRec); } catch (Catalogioerror e) { System.err.println("Catalog I/O Error!" + e); throw new Catalogioerror(null, ""); } catch (Cataloghferror e1) { System.err.println("Catalog Heapfile Error!" + e1); throw new Cataloghferror(null, ""); } catch (Catalogmissparam e2) { System.err.println("Catalog Missing Param Error!" + e2); throw new Catalogmissparam(null, ""); } // GET ATTRIBUTE INFO try { ExtendedSystemDefs.MINIBASE_ATTRCAT.getInfo(relation, attrName, attrRec); } catch (Exception e2) { throw new IndexCatalogException(e2, "getInfo() failed"); } // Can only index on int's and strings currently if ((attrRec.attrType.attrType != AttrType.attrInteger) && (attrRec.attrType.attrType != AttrType.attrString)) throw new Catalogbadtype(null, "Catalog: BAD TYPE!"); // UPDATE ATTRIBUTE INFO attrRec.indexCnt++; try { ExtendedSystemDefs.MINIBASE_ATTRCAT.removeInfo(relation, attrName); ExtendedSystemDefs.MINIBASE_ATTRCAT.addInfo(attrRec); } catch (Exception e) { throw new IndexCatalogException(e, "add/remove info failed"); } // BUILD INDEX FILE NAME indexName = buildIndexName(relation, attrName, accessType); // ADDED BY BILL KIMMEL - DELETE LATER System.out.println("Index name is " + indexName); // IF BTREE if (accessType.indexType == IndexType.B_Index) { btree = new BTreeFile(indexName, attrRec.attrType.attrType, attrRec.attrLen, 0); } // ADD ENTRY IN INDEXCAT indexRec.relName = new String(relation); indexRec.attrName = new String(attrName); indexRec.accessType = accessType; if (accessType.indexType == IndexType.B_Index) indexRec.order = new TupleOrder(TupleOrder.Ascending); else indexRec.order = new TupleOrder(TupleOrder.Random); indexRec.distinctKeys = DISTINCTKEYS; indexRec.clustered = 0; // 0 means non-clustered!!!! indexRec.indexPages = INDEXPAGES; try { addInfo(indexRec); } catch (Exception e) { throw new IndexCatalogException(e, "addInfo() failed"); } // PREPARE TO SCAN DATA FILE try { datafile = new Heapfile(relation); if (datafile == null) throw new Catalognomem(null, "NO Enough Memory!"); } catch (Exception e) { throw new IndexCatalogException(e, "create heapfile failed"); } try { pscan = datafile.openScan(); } catch (Exception e) { throw new IndexCatalogException(e, "openScan() failed"); } // PREPARE TUPLE try { ExtendedSystemDefs.MINIBASE_ATTRCAT.getTupleStructure( relation, attrCnt, typeArray, sizeArray); } catch (Exception e) { throw new IndexCatalogException(e, "getTupleStructure"); } tuple = new Tuple(Tuple.max_size); if (tuple == null) throw new Catalognomem(null, "Catalog, No Enough Memory!"); try { tuple.setHdr((short) attrCnt, typeArray, sizeArray); } catch (Exception e) { throw new IndexCatalogException(e, "setHdr() failed"); } recSize = tuple.size(); // NOW PROCESS THE HEAPFILE AND INSERT KEY,RID INTO INDEX while (true) { try { tuple = pscan.getNext(rid); if (tuple == null) return; } catch (Exception e) { throw new IndexCatalogException(e, "getNext() failed"); } // PULL OUT THE KEY VALUE FROM HEAPFILE RECORD if (attrRec.attrType.attrType == AttrType.attrInteger) { intKey = tuple.getIntFld(attrRec.attrPos); key = new IntegerKey(intKey); } else if (attrRec.attrType.attrType == AttrType.attrReal) { floatKey = tuple.getFloFld(attrRec.attrPos); key = new IntegerKey((int) floatKey); } else if (attrRec.attrType.attrType == AttrType.attrString) { charKey = new String(tuple.getStrFld(attrRec.attrPos)); key = new StringKey(charKey); } // NOW INSERT RECORD INTO INDEX if (accessType.indexType == IndexType.B_Index) { try { btree.insert(key, rid); } catch (Exception e) { throw new IndexCatalogException(e, "insert failed"); } } } };
// GET ALL INDEXES INLUDING A SPECIFIED ATTRIBUTE public int getAttrIndexes(String relation, String attrName, int indexCnt, IndexDesc[] indexes) throws Catalogmissparam, Catalogioerror, Cataloghferror, IOException, Catalognomem, Catalogindexnotfound, Catalogattrnotfound, IndexCatalogException { AttrDesc record = null; int status; int recSize; RID rid = null; Scan pscan = null; int count = 0; if (relation == null) throw new Catalogmissparam(null, "MISSING_PARAM"); try { ExtendedSystemDefs.MINIBASE_ATTRCAT.getInfo(relation, attrName, record); } catch (Catalogioerror e) { throw e; } catch (Cataloghferror e1) { throw e1; } catch (Catalogmissparam e2) { throw e2; } catch (Catalogattrnotfound e3) { throw e3; } catch (Exception e4) { throw new IndexCatalogException(e4, "getInfo() failed"); } // ASSIGN INDEX COUNT indexCnt = record.indexCnt; if (indexCnt == 0) return 0; // OPEN SCAN try { pscan = new Scan(this); } catch (Exception e) { throw new IndexCatalogException(e, "scan failed"); } // ALLOCATE INDEX ARRAY indexes = new IndexDesc[indexCnt]; if (indexes == null) throw new Catalognomem(null, "Catalog: No Enough Memory!"); // SCAN FILE while (true) { try { tuple = pscan.getNext(rid); if (tuple == null) throw new Catalogindexnotfound(null, "Catalog: Index not Found!"); read_tuple(tuple, indexes[count]); } catch (Exception e4) { throw new IndexCatalogException(e4, "pascan.getNext() failed"); } if (indexes[count].relName.equalsIgnoreCase(relation) == true && indexes[count].attrName.equalsIgnoreCase(attrName) == true) count++; if (count == indexCnt) // if all indexes found break; } return indexCnt; };