/** * This method loads the .dbf file represented by the file argument and puts all the data found * inside the file into a DBFTable object, which it returns. * * @param file File location of .dbf to load. * @return A constructed and initialized DBF table containing the data found in the file. * @throws IOException Thrown when an error is encountered reading the .dbf file. Likely problems * are that the File is not in the location specified or that it is spelled differently. */ public DBFTable loadDBF(File file) throws IOException { // THIS IS THE TABLE WE'RE GOING TO FILL AND THEN RETURN DBFTable mapTable = new DBFTable(); // WE ARE GOING TO READ RAW BYTE DATA // InputStreamReader is = new InputStreamReader(); // DataInputStream dis = new DataInputStream(iss); FileInputStream fis = new FileInputStream(file); DataInputStream dis = new DataInputStream(fis); // LOAD THE FIRST 32 BYTES OF THE HEADER loadHeader(dis, mapTable); // SUBRECORDS (32-(positionOfFirstDataRecorded-3)) loadFields(dis, mapTable); // HEADER RECORD TERMINATOR (SHOULD BE 0x0D) byte terminator = dis.readByte(); mapTable.setTerminator(terminator); // AND NOW READ THE ACTUAL DATA loadRecords(dis, mapTable); // ALL DONE, NOW RETURN THE TABLE return mapTable; }
/** * This method loads all of the fields in the mapTable argument via the dis stream, which is setup * at the proper location. * * @param dis Input stream reading from the .dbf file. * @param mapTable The dbf table being loaded. * @throws IOException Thrown when the stream fails. */ private void loadFields(DataInputStream dis, DBFTable mapTable) throws IOException { // NUMBER OF FIELDS (COLUMNS) IN THE TABLE int numFields = (mapTable.getPositionOfFirstDataRecorded() - 32 - 2 + 1) / 32; for (int i = 0; i < numFields; i++) { // ANOTHER COLUMN DBFField fieldToAdd = new DBFField(); mapTable.addField(fieldToAdd); // FIELD NAME String fieldName = ""; for (int j = 0; j < 11; j++) { byte c = dis.readByte(); if (c != 0) fieldName += (char) c; } fieldToAdd.setName(fieldName); // FIELD TYPE byte fieldTypeAsByte = dis.readByte(); char fieldType = (char) fieldTypeAsByte; if (fieldType == 'C') fieldToAdd.setType(DBFFieldType.C); else fieldToAdd.setType(DBFFieldType.N); // DISPLACEMENT OF FIELD IN RECORD (12-15) int displacementOfFieldInRecord = readLittleEndianInt(dis); fieldToAdd.setDisplacement(displacementOfFieldInRecord); // LENGTH OF FIELD (16) int lengthOfField = dis.readByte(); if (lengthOfField < 0) lengthOfField += 256; fieldToAdd.setLength(lengthOfField); // NUMBER OF DECIMAL PLACES (17) byte numberOfDecimalPlaces = dis.readByte(); fieldToAdd.setNumberOfDecimalPlaces(numberOfDecimalPlaces); // FIELD FLAGS (18) byte fieldFlags = dis.readByte(); fieldToAdd.setFlags(fieldFlags); // AUTOINCREMENT NEXT (19-22) int next = readLittleEndianInt(dis); fieldToAdd.setNext(next); // AUTOINCREMENT STEP (23) byte step = dis.readByte(); fieldToAdd.setStep(step); // RESERVED (24-31) - WE WON'T USE THIS long reservedFieldData = dis.readLong(); fieldToAdd.setReservedData(reservedFieldData); } }
/** * This method saves all the records in the mapTable argument using the dos stream. * * @param dos Output stream writing to the .dbf file. * @param mapTable The dbf table being saved. * @throws IOException Thrown when the stream fails. */ private void saveRecords(DataOutputStream dos, DBFTable mapTable) throws IOException { // WRITE ALL ROW DATA for (int i = 0; i < mapTable.getNumberOfRecords(); i++) { // HERE'S THE RECORD WE ARE SAVING DBFRecord recordToSave = mapTable.getRecord(i); // THERE IS A MYSTERY BYTE BEFORE EACH RECORD dos.writeByte(recordToSave.getMystery()); // LOAD DATA FOR EACH FIELD Iterator<DBFField> fieldsIt = mapTable.fieldsIterator(); int fieldsCounter = 0; while (fieldsIt.hasNext()) { // WHAT TYPE OF FIELD IS IT (character data, numbers, etc.)? DBFField field = fieldsIt.next(); // TEXT? if (field.getType() == DBFFieldType.C) { int j = 0; Object data = recordToSave.getData(fieldsCounter); String text; if (data == null) text = ""; else text = data.toString(); while (j < text.length()) { dos.writeByte((byte) text.charAt(j)); j++; } while (j < field.getLength()) { dos.writeByte((byte) ' '); j++; } } // IT MUST BE AN 'N' TYPE, THOSE ARE THE ONLY TWO WE'RE USING else { Object data = recordToSave.getData(fieldsCounter); String numText; if (data == null) numText = ""; else numText = data.toString(); int x = 0; while (x < numText.length()) { dos.writeByte((byte) numText.charAt(x)); x++; } while (x < field.getLength()) { dos.writeByte((byte) ' '); x++; } } fieldsCounter++; } } }
/** * This helper method reads and loads all the row data (records) from the .dbf into the mapTable * argument. Note that the dis argument must be ready to read at the start of the records section, * which is right after the fields section. * * @param dis Input stream reading from the .dbf file. * @param mapTable The dbf table being loaded. * @throws IOException Thrown when the stream fails. */ private void loadRecords(DataInputStream dis, DBFTable mapTable) throws IOException { // READ ALL ROW DATA for (int i = 0; i < mapTable.getNumberOfRecords(); i++) { // HERE'S THE RECORD WE ARE LOADING DBFRecord recordToAdd = new DBFRecord(mapTable.getNumFields()); // THERE IS A MYSTERY BYTE BEFORE EACH RECORD byte mystery = dis.readByte(); recordToAdd.setMystery(mystery); // LOAD DATA FOR EACH FIELD Iterator<DBFField> fieldsIt = mapTable.fieldsIterator(); int fieldsCounter = 0; while (fieldsIt.hasNext()) { // WHAT TYPE OF FIELD IS IT (character data, numbers, etc.)? DBFField field = fieldsIt.next(); // TEXT? if (field.getType() == DBFFieldType.C) { String text = ""; for (int counter = 0; counter < field.getLength(); counter++) { char c = (char) dis.readByte(); text += c; } text = text.trim(); recordToAdd.setData(text, fieldsCounter); } // IT MUST BE AN 'N' TYPE SINCE THOSE ARE THE ONLY TWO WE'RE USING else { String text = ""; for (int counter = 0; counter < field.getLength(); counter++) { char c = (char) dis.readByte(); text += c; } text = text.trim(); if (text.contains(".")) { double num = 0.0; num = Double.parseDouble(text); recordToAdd.setData(num, fieldsCounter); } else { long num = 0; if (text.length() > 0) num = Long.parseLong(text); recordToAdd.setData(num, fieldsCounter); } } fieldsCounter++; } // Comparable key = (Comparable)recordToAdd.getData(mapTable.getKeyIndex()); mapTable.addRecord(recordToAdd); } }
/** * This method saves all of the fields in the mapTable argument via the dos stream, which is setup * at the proper location. * * @param dos Output stream writing to the .dbf file. * @param mapTable The dbf table being saved. * @throws IOException Thrown when the stream fails. */ private void saveFields(DataOutputStream dos, DBFTable mapTable) throws IOException { // NUMBER OF FIELDS (COLUMNS) IN THE TABLE int numFields = (mapTable.getPositionOfFirstDataRecorded() - 32 - 2 + 1) / 32; for (int i = 0; i < numFields; i++) { // HERE'S THE FIELD WE'RE SAVING DBFField fieldToSave = mapTable.getField(i); // FIELD NAME String fieldName = fieldToSave.getName(); int j = 0; for (; j < fieldName.length(); j++) { byte c = (byte) fieldName.charAt(j); dos.writeByte(c); } byte z = (byte) 0x00; while (j < 11) { dos.writeByte(z); j++; } // FIELD TYPE dos.writeByte((byte) (fieldToSave.getType().toString().charAt(0))); // DISPLACEMENT OF FIELD IN RECORD (12-15) dos.writeInt(Integer.reverseBytes(fieldToSave.getDisplacement())); // LENGTH OF FIELD (16) dos.writeByte((byte) fieldToSave.getLength()); // NUMBER OF DECIMAL PLACES (17) dos.writeByte(fieldToSave.getNumberOfDecimalPlaces()); // FIELD FLAGS (18) dos.writeByte(fieldToSave.getFlags()); // AUTOINCREMENT NEXT (19-22) dos.writeInt(Integer.reverseBytes(fieldToSave.getNext())); // AUTOINCREMENT STEP (23) dos.writeByte(fieldToSave.getStep()); // RESERVED (24-31) - WE WON'T USE THIS dos.writeLong(fieldToSave.getReservedData()); } }
/** * This method saves the tableToSave argument to the file location. Note that we are only writing * C and N data types. * * @param tableToSave DBFTable data to save to the file. * @param file File location to save the table. * @throws IOException Thrown when writing fails. A reason for this might be the file is already * being used by another program. */ public void saveDBF(DBFTable tableToSave, File file) throws IOException { // WE ARE GOING TO WRITE RAW BYTE DATA FileOutputStream fos = new FileOutputStream(file); DataOutputStream dos = new DataOutputStream(fos); // SAVE THE FIRST 32 BYTES OF THE HEADER saveHeader(dos, tableToSave); // SUBRECORDS (32-(positionOfFirstDataRecorded-3)) saveFields(dos, tableToSave); // HEADER RECORD TERMINATOR (SHOULD BE 0x0D) dos.writeByte(tableToSave.getTerminator()); // AND NOW SAVE THE ACTUAL DATA saveRecords(dos, tableToSave); }
/** * This helper method saves just the .dbf file header portion of the mapTable argument using the * dos stream. * * @param dos The stream writing to the .dbf file. * @param mapTable The dbf table being saved. * @throws IOException Thrown when the stream fails. */ private void saveHeader(DataOutputStream dos, DBFTable mapTable) throws IOException { // DBF file type (0) dos.writeByte(mapTable.getFileType()); // LAST UPDATE (1-3) byte year = (byte) (mapTable.getLastModifiedDate().get(Calendar.YEAR) - 1900); byte month = (byte) (mapTable.getLastModifiedDate().get(Calendar.MONTH) + 1); byte day = (byte) (mapTable.getLastModifiedDate().get(Calendar.DATE)); dos.writeByte(year); dos.writeByte(month); dos.writeByte(day); // NUMBER OF RECORDS IN FILE (4-7) int numberOfRecordsInFile = Integer.reverseBytes(mapTable.getNumberOfRecords()); dos.writeInt(numberOfRecordsInFile); // POSITION OF FIRST DATA RECORDED (8-9) short positionOfFirstDataRecorded = Short.reverseBytes(mapTable.getPositionOfFirstDataRecorded()); dos.writeShort(positionOfFirstDataRecorded); // LENGTH OF ONE DATA RECORD, INCLUDING DELETE FLAG (10-11) short dataRecordLength = Short.reverseBytes(mapTable.getDataRecordLength()); dos.writeShort(dataRecordLength); // ZEROES (12-13) short zeroes = Short.reverseBytes(mapTable.getZeroes()); dos.writeShort(zeroes); // DBASE IV Transaction Flag (14) dos.writeByte(mapTable.getDbaseTransactionFlag()); // DBASE IV Encryption Flag (15) dos.writeByte(mapTable.getDbaseEncryptionFlag()); // Multiuser Processing 12 Bytes (16-27) int[] mup = mapTable.getMup(); dos.writeInt(Integer.reverseBytes(mup[0])); dos.writeInt(Integer.reverseBytes(mup[1])); dos.writeInt(Integer.reverseBytes(mup[2])); // TABLE FLAGS (28) dos.writeByte(mapTable.getFlags()); // CODE PAGE MARK/LANGUAGE DRIVER ID (29) dos.writeByte(mapTable.getCodePageMark()); // RESERVED, CONTAINS 0x00 (30-31) dos.writeShort(Short.reverseBytes(mapTable.getReserved())); }
/** * This helper method loads just the .dbf file header portion into the mapTable argument using the * dis stream. * * @param dis The stream reading from the .dbf file. * @param mapTable The dbf table being loadd. * @throws IOException Thrown when the stream fails. */ private void loadHeader(DataInputStream dis, DBFTable mapTable) throws IOException { // DBF file type (0) byte dbfFileType = dis.readByte(); mapTable.setFileType(dbfFileType); // LAST UPDATE (1-3) int year = 1900 + dis.readByte(); int month = dis.readByte(); int day = dis.readByte(); mapTable.setLastModifiedDate(year, month, day); // NUMBER OF RECORDS IN FILE (4-7) int numberOfRecordsInFile = readLittleEndianInt(dis); mapTable.setNumberOfRecords(numberOfRecordsInFile); // POSITION OF FIRST DATA RECORDED (8-9) short positionOfFirstDataRecorded = readLittleEndianShort(dis); mapTable.setPositionOfFirstDataRecorded(positionOfFirstDataRecorded); // LENGTH OF ONE DATA RECORD, INCLUDING DELETE FLAG (10-11) short dataRecordLength = readLittleEndianShort(dis); mapTable.setDataRecordLength(dataRecordLength); // ZEROES (12-13) short zeroes = readLittleEndianShort(dis); mapTable.setZeroes(zeroes); // DBASE IV Transaction Flag (14) byte dbaseTransactionFlag = dis.readByte(); mapTable.setDbaseTransactionFlag(dbaseTransactionFlag); // DBASE IV Encryption Flag (15) byte dbaseEncryptionFlag = dis.readByte(); mapTable.setDbaseEncryptionFlag(dbaseEncryptionFlag); // Multiuser Processing 12 Bytes (16-27) int[] mup = new int[3]; mup[0] = readLittleEndianInt(dis); mup[1] = readLittleEndianInt(dis); mup[2] = readLittleEndianInt(dis); mapTable.setMup(mup); // TABLE FLAGS (28) byte tableFlags = dis.readByte(); mapTable.setFlags(tableFlags); // CODE PAGE MARK/LANGUAGE DRIVER ID (29) byte pageMark = dis.readByte(); mapTable.setCodePageMark(pageMark); // RESERVED, CONTAINS 0x00 (30-31) short reserved = readLittleEndianShort(dis); mapTable.setReserved(reserved); }