proj2.tar

DataBase.java0000600017357700026750000002104112437035616012774 0ustar  slmyersugradimport com.sleepycat.db.*;
import java.io.*;
import java.util.*;

/*
 * requires refactoring
 * much cleaning required
*/

public class DataBase{
	public static final int NO_RECORDS = 100000;
	public static final int NO_RECORDS_TEST = 11;
	public static final String DATABASE_DIR = "/tmp/slmyers_db";
	public static final String PRIMARY_TABLE = "/tmp/slmyers_db/primary_table_file1";
	private static final String DATA_SECONDARY_TABLE = "/tmp/slmyers_db/data_index";
	public static final String TREE_TABLE = "/tmp/slmyers_db/search_file";
	public static final String HASH_TABLE = "/tmp/slmyers_db/data_support_file";

	public static boolean INITIALIZED = false;
	private static DataBase db = null;	
	
	private Database database = null;
	private Database databaseHash = null;
	private Database databaseTree = null;	
	private SecondaryDatabase dataSecondary = null;

	 

	protected DataBase(){
	}
	
	public static DataBase getInstance(){
		if(db == null){
			db = new DataBase();
		}
		return db;
	}

	public void initDataBase(){
		if(!createDirectory(DATABASE_DIR)){
			System.err.println("Unable to create file	 for database");
			System.exit(-1);
		}
		DatabaseType type;
		int typeInt = Pref.getDbType();
		if(typeInt == 1 ){
			type = DatabaseType.BTREE;
		}else if (typeInt == 2){
			type = DatabaseType.HASH;
		}else if (typeInt == 3){
			initIndexFile(DatabaseType.BTREE);
			configureDataSecondary();
			INITIALIZED = true;
			return;
		}else{
			throw new RuntimeException("unknown database attempting to be created in Database");
		}
		
		this.database = createDb(PRIMARY_TABLE, type);
		System.out.println(PRIMARY_TABLE + " has been created of type: " + type);
		
		int count = populateTable(this.database, NO_RECORDS);
		System.out.println(PRIMARY_TABLE + " has been entered with " + count + " records.");
		INITIALIZED = true;
		
	}

	public Database getPrimaryDb(){
		return this.database;
	}

	public Database getIndexTree(){
		return databaseTree;
	}

	public Database getIndexHash(){
		return databaseHash;
	}

	public SecondaryDatabase getIndexSecondary(){
		return this.dataSecondary;
	}

	public void initIndexFile(DatabaseType type){
		if(type.equals(DatabaseType.BTREE)){
			this.databaseTree = createDb(TREE_TABLE, type);
			System.out.println(TREE_TABLE + " has been created of type: " + type);
			int count = populateTable(this.databaseTree, NO_RECORDS);
			System.out.println(TREE_TABLE + " has been entered with " + count + " records.");
		}else if(type.equals(DatabaseType.HASH)){
			this.databaseHash = createDb(HASH_TABLE, type);
			System.out.println(HASH_TABLE + " has been created of type: " + type);
			int count = populateTable(this.databaseHash, NO_RECORDS);
			System.out.println(HASH_TABLE + " has been entered with " + count + " records.");
		}
	}

	

	public void configureDataSecondary(){
		SecondaryConfig secConfig = new SecondaryConfig();
		secConfig.setKeyCreator(new DataKeyCreator());
		secConfig.setAllowCreate(true);
		secConfig.setType(DatabaseType.BTREE);
		secConfig.setSortedDuplicates(true);
		secConfig.setAllowPopulate(true);

		try{
			this.dataSecondary = new SecondaryDatabase(DATA_SECONDARY_TABLE, null, this.databaseTree, secConfig);
		}catch(DatabaseException dbe){
			System.err.println("Error while instantiating secondary 'data' database: " + dbe.toString());
			this.close(true);
			System.exit(-1);
		}catch(FileNotFoundException fnfe){
			System.err.println("Secondary database file not found: " + fnfe.toString());
		}
		
		System.out.println(DATA_SECONDARY_TABLE + " has been created of type: " + secConfig.getType());
	}

	public final boolean createDirectory(String file){
		deleteFolder(new File(file));
		File dbDirect = new File(file);
	  	dbDirect.mkdirs();
		return dbDirect.exists();
	}

	public Database createDb(String file, DatabaseType type){
		Database db = null;
		DatabaseConfig dbConfig = new DatabaseConfig();
		dbConfig.setType(type);
		dbConfig.setAllowCreate(true);
		try{
			db = new Database(file, null, dbConfig);
		}catch (DatabaseException dbe){
			System.err.println("unable to create database");
			dbe.printStackTrace();
		}catch (FileNotFoundException fnfe){
			System.err.println("can not find file to create Database");
			fnfe.printStackTrace();
		}
		return db;
	}

	private static int populateTable(Database my_table, int nrecs ) {
		int range;
		DatabaseEntry kdbt, ddbt;
		int count = 0;
		String s;
		
		/*  
		 *  generate a random string with the length between 64 and 127,
		 *  inclusive.
		 *
		 *  Seed the random number once and once only.
		 */
		Random random = new Random(1000000);

		try {

    		for (int i = 0; i < nrecs; i++) {
				/* to generate a key string */
				range = 64 + random.nextInt( 64 );
				s = "";
				for ( int j = 0; j < range; j++ ) 
					s+=(new Character((char)(97+random.nextInt(26)))).toString();
				
		
				/* to create a DBT for key */
				kdbt = new DatabaseEntry(s.getBytes());
				kdbt.setSize(s.length()); 
				 	

				/* to generate a data string */
				range = 64 + random.nextInt( 64 );
				s = "";
				for ( int j = 0; j < range; j++ ) 
					s+=(new Character((char)(97+random.nextInt(26)))).toString();
				
				/* to create a DBT for data */
				ddbt = new DatabaseEntry(s.getBytes());
				ddbt.setSize(s.length()); 

				//TODO change so program recovers instead of exiting
				OperationStatus result;
				result = my_table.exists(null, kdbt);
				if (!result.toString().equals("OperationStatus.NOTFOUND"))
					throw new RuntimeException("Key is already in the database!");

					/* to insert the key/data pair into the database */
				my_table.putNoOverwrite(null, kdbt, ddbt);
				count++;
			}
		}
		catch (DatabaseException dbe) {
			System.err.println("Populate the table: "+dbe.toString());
		  	System.exit(1);
		}
		
		return count;
	}

	public void close(boolean clearFiles){
		if(this.database != null){
			try{
				this.database.close();
				this.database.remove(PRIMARY_TABLE,null,null);
				System.out.println(PRIMARY_TABLE + " database is closed and removed");
			}catch(DatabaseException dbe){
				System.err.println("unable to close database");
				dbe.printStackTrace();
			}catch (FileNotFoundException fnfe){
				System.err.println("can not find file to remove Database");
				fnfe.printStackTrace();
			}
			database = null;
			db = null;
		}
		if(this.databaseTree != null){
			try{
				this.dataSecondary.close();
				System.out.println(DATA_SECONDARY_TABLE + " database is closed");
				this.databaseTree.close();
				this.database.remove(TREE_TABLE,null,null);
				System.out.println(TREE_TABLE + " database is closed and removed");
			}catch(DatabaseException dbe){
				System.err.println("unable to close database(s)");
				dbe.printStackTrace();
			}catch (FileNotFoundException fnfe){
				System.err.println("can not find file to remove Database(s)");
				fnfe.printStackTrace();
			}
			this.dataSecondary = null;
			this.databaseHash = null;
			this.databaseTree = null;
		}
		INITIALIZED = false;
		if(clearFiles){
			deleteFolder(new File("/tmp/slmyers_db"));
			WriteToFile.deleteAnswerFile();
			System.out.println("/tmp/slmyers_db and ./answers deleted");
		}
	}

	public static void deleteFolder(File folder) {
    File[] files = folder.listFiles();
    if(files!=null) { //some JVMs return null for empty dirs
        for(File f: files) {
            if(f.isDirectory()) {
                deleteFolder(f);
            } else {
                f.delete();
            }
        }
    }
    folder.delete();
	}

	public void printSecondary() throws DatabaseException{
		DatabaseEntry secKey = new DatabaseEntry();
		DatabaseEntry pKey = new DatabaseEntry();
		DatabaseEntry data = new DatabaseEntry();
		SecondaryCursor cursor = this.dataSecondary.openSecondaryCursor(null, null);

		String secondaryKey;		
		String primaryKey;
		String dataString;
		OperationStatus status;
		secKey.setReuseBuffer(false);
		pKey.setReuseBuffer(false);
		data.setReuseBuffer(false);
		
		
		
		while( (status = cursor.getNextNoDup(secKey, pKey, data, LockMode.DEFAULT)) == OperationStatus.SUCCESS){
			System.out.println("secondary key: " + new String(secKey.getData()) + "\n");
			System.out.println("primary key: " + new String(pKey.getData()) + "\n");
			System.out.println("data: " + new String(data.getData()) + "\n");
			while((status = cursor.getNextDup(secKey, pKey, data, LockMode.DEFAULT)) == OperationStatus.SUCCESS){
				System.out.println("\tsecondary key: " + new String(secKey.getData()) + "\n");
				System.out.println("\tprimary key: " + new String(pKey.getData()) + "\n");
				System.out.println("\tdata: " + new String(data.getData()) + "\n");
			}
			System.out.println("=======================================");
		}
		cursor.close();
	}
}
DataKeyCreator.java0000600017357700026750000000150012436675744014203 0ustar  slmyersugradimport java.nio.ByteBuffer;
import com.sleepycat.db.*;
import java.io.UnsupportedEncodingException;
public class DataKeyCreator implements SecondaryKeyCreator {
	
	public DataKeyCreator(){

	}
	
	public boolean createSecondaryKey(SecondaryDatabase secondary,
                                      DatabaseEntry key,
                                      DatabaseEntry data,
                                      DatabaseEntry result){
				String dataStr = null;	
				try{
					dataStr = new String(data.getData(), "UTF-8");
				}catch (UnsupportedEncodingException uee){
					uee.printStackTrace();
					System.exit(-1);
				}
 				int strlen = dataStr.length();
				byte[] byteArray = new byte[strlen];
				byteArray = dataStr.getBytes();
				result.setSize(strlen);
        result.setData(byteArray);
				
				return true;
   }
}
DataRetrieve.java0000600017357700026750000001270512437000032013676 0ustar  slmyersugradimport com.sleepycat.db.*;
import java.util.*;
import java.lang.Object;
import java.io.*;


public class DataRetrieve {
    //example key that has data: thndjefjyfwgpbmhzbfsfkubphiyvqirxwggmuxhvqnfmczshjaldffddmqyylwfmvbttcpvdjjffawzrdmwzykaspfugguntavetgdszamyogibkekcrvjuf

    // Last key: zzzzevhwlhknxjmuxosuaunkzvqaynhihjpryfhwzziekyjpwhtsffnvywrrcwpxpmavfbqzwbxwkwwodfxiwcxsvkfznsgymytctmjleuxohjezlyeodccqletvf
    // Last Data: woqlahmzrqlyhhjzdklmjqolkbhhiasczpgukpyobcwztbsffleukvbfdnqnubmorshieukeclbbtie
    
    // DATA BELOW I'M 100% SURE IS RIGHT AS I PRINTED IT AS THE DATABASE WAS BEING CREATED.
    // key: oohiqwurgzsllzvhgigpxqwzbenyyjxuczmewrecjmxuvgjlzrnfxlmgzoilphatfquyyaadzvnztflneudhykt
    // data: hnrkmhfcwwzplsykkcaxqdtsnlenyanztgszjgnzvdgpidenkicynfdsgeyvgbnbaxdxlodtwexdlp
    
    // key: hgfjlbziiqxoqcpdsfginenvozqvyhnsdzwnzmubbxybauzdsolvbtxqqsbdqznvkjixrnaxfmcx
    // data: zqmornwieprpscrhbldbvrnexrqwxtkzufejctzshhhmblhfiwzwnhcadcotyueskadatwtowrfkxf
    
    // key: szysjqctdhewbmldkyzojvnpatqlhofdiavalosfwidkrppmshbcmrihpxuqdmyhvyvpuplerjsqxaseuetlsznwfclfytahorfqfgagjslzkqmlebh
    // data: fgzqeklegbkhfmvybrrlaeqprkwchikudsvdgksxkoxpmeaeqchluypdvatveqreeevnnbqszeykoyddsflsgnktspcfpgggmvkricdrlzfamhisqyyuljptcsnc

  
    Scan scan = Scan.getInstance();
    Database database = null;
    SecondaryDatabase db2 = null;
    String filename = "answers";
    WriteToFile fileWrite = new WriteToFile();
    Map<String, String> records = new HashMap<String, String>();
    OperationStatus oprStat;

	DataBase db = DataBase.getInstance();
	


    public DataRetrieve(){
		DataBase db = DataBase.getInstance();
	

		if (Pref.getDbType() == 3) {
	    
	    //if(index.getDataSecondary() == null){
	    //	index.configureDataSecondary();
	    //}
	    db2 = db.getIndexSecondary();

		}else{
			database = db.getPrimaryDb();
			//if(database == null){
			//	throw new RuntimeException("database is null in data retrieve line 40");
			//}
		}
	 }

		


    //
    public void getRecords(boolean test, String testData) {
	//check if database is null, if true than return to main menu
	if((Pref.getDbType() == 3 && db2 == null) || (Pref.getDbType() != 3 && database == null)){
	    System.out.println("Database has not been created!");
	    return;
	} 
	String searchData;
	if(!test){
		// gets user input for record to search for  
		System.out.print("Please enter data you want to search for: ");
		searchData = scan.getString();
	}
	else{
		searchData = testData;
	}
	// start timer, end before returns
	long timeStart = System.nanoTime();
	DatabaseEntry secKey = new DatabaseEntry();
	DatabaseEntry pKey = new DatabaseEntry();
	DatabaseEntry dataEntry = new DatabaseEntry();
	//OperationStatus success = ;
	secKey.setReuseBuffer(false);
	pKey.setReuseBuffer(false);
	dataEntry.setReuseBuffer(false);
	

	SecondaryDatabase database2 = null;
				
	String data = null;
	String key = null;
		

	System.out.println("Searching for data: " + searchData + " in database");
	try {
	    //if there is a index file then we can use key search
	    if (Pref.getDbType() == 3) {
		System.out.println("searching in index file");
		SecondaryCursor c = db2.openSecondaryCursor(null, null);
		//set dbKey to the data value we are searching for then move cursor
		secKey.setData(searchData.getBytes());
		secKey.setSize(searchData.length());
		if(c.getSearchKey(secKey, pKey, dataEntry, LockMode.DEFAULT)==OperationStatus.SUCCESS){
		    data = new String (secKey.getData());
		    key = new String (pKey.getData());
		    records.put(key, data);

		    //next if there are duplicate keys after the first get them 		
		    while(c.getNextDup(secKey, pKey, dataEntry, LockMode.DEFAULT) == OperationStatus.SUCCESS){
			data = new String (secKey.getData());
			key = new String (pKey.getData());
			records.put(key, data);
		    }
		}
		else{
		    System.out.println("data " + searchData + " is not found");
		}
		c.close(); 
	    }
	    else{    
		//if BTREE or HASH then search all records using cursor and return matches 
		Cursor c = database.openCursor(null, null);
		oprStat = c.getFirst(pKey, dataEntry, LockMode.DEFAULT);
		
		//loop through database until we find a matching key 
		while(oprStat == OperationStatus.SUCCESS){				 
	   
		    data = new String (dataEntry.getData());
		    key = new String (pKey.getData());
		    
		    if(data.equals(searchData)){
			records.put(key, data);
		    }
		   
		    oprStat = c.getNext(pKey, dataEntry, LockMode.DEFAULT);
		   
		    
		}
		c.close(); 
	    }

				   
	}
	catch (DatabaseException e) {
	    System.err.println("unable to get key/value record!");
	}
	
	// end timer and print time
	long timeEnd = System.nanoTime();
	long time = timeEnd - timeStart;
	time = time/1000;
	System.out.println();
	System.out.println("Records found: "+ records.size());

	//get the key values of all records returned
	Set keys = records.keySet();
	Integer len = keys.size();
	String[] hashMapKeys = records.keySet().toArray(new String[len]);
	//iterate through hashMapKeys and write key/data pairs to answers.txt
	System.out.println();
	for(int i = 0; i < len; i++){

	    System.out.println("Key " + (i+1) + ": " + hashMapKeys[i]);
	    System.out.println("Data " + (i+1) + ": " + records.get(hashMapKeys[i]));
	    System.out.println();

	    fileWrite.writeString(filename, hashMapKeys[i]); 
	    fileWrite.writeString(filename, records.get(hashMapKeys[i]));
	    fileWrite.writeString(filename, ""); 
	}

	System.out.println("TOTAL SEARCH TIME = " + time + " Microseconds");
	


	return;
    }
  

}
Menu.java0000600017357700026750000000523712437004204012232 0ustar  slmyersugradimport com.sleepycat.db.DatabaseException;
public class Menu{		
	Scan scan;
	public Menu(){
		this.printHeader();
		scan = Scan.getInstance();
		this.makeSelection();
	}

	public void printHeader(){
		System.out.println("======================================");
		System.out.println("|\tGeneric File Database");
		System.out.println("======================================");
		System.out.println("|Options:");
		System.out.println("|\t1) Create and populate a database");
		System.out.println("|\t2) Retrieve records with a given key");
		System.out.println("|\t3) Retrieve records with a given data");
		System.out.println("|\t4) Retrieve records with a given range of key values");
		System.out.println("|\t5) Destroy the database");
		System.out.println("|\t6) Quit");
		System.out.println("======================================");
	}

	public void makeSelection(){
		DataBase db;
		int option = this.select();
		switch(option){
			case 1 : 
						db = DataBase.getInstance();
						db.initDataBase();
						printHeader();
						makeSelection();
						break;
			case 2 : 
						System.out.println("Option 2 executed");
						KeyRetrieve kr = new KeyRetrieve();	
						if(Pref.getDbType() == 3){
							try{
								kr.getIndexFileRecord(false, null);
								db = DataBase.getInstance();
								if(db.getIndexTree() == null)
									db.initDataBase();
							}catch(DatabaseException dbe){
								dbe.printStackTrace();
							}
						}
						else{
							kr.getRecords(false, null);
						}
						printHeader();
						makeSelection();
						break;
			case 3: 
						System.out.println("Option 3 executed");				                        	   
						DataRetrieve dr = new DataRetrieve();	
						dr.getRecords(false, null);
						printHeader();
						makeSelection();
						break;
			case 4: 
						System.out.println("Option 4 executed");	
						RangeSearch rs = new RangeSearch();
						rs.execute(false, null, null);
						printHeader();
						makeSelection();
						break;
			case 5:
						System.out.println("Option 5 executed");
						DataBase.getInstance().close(false);
						this.printHeader();
						this.makeSelection();
						break;
			case 6:
						//TODO ensure that DataBase.getInstance() does not open create database when unwanted
						System.out.println("Exiting data base");
						DataBase.getInstance().close(true);
						System.exit(-1);	
						break;
			default: 
						System.out.println("invalid option selected");
						this.makeSelection();
		}	
				
		
	}


	public int select(){
		int selection = -1;
		try{
			selection = scan.getInt();
		}catch(Exception e){
			System.out.println("Menu selection failed! Check output console");
			e.printStackTrace();
		}
		return selection;		
	}
}
Pref.java0000600017357700026750000000024612436675744012243 0ustar  slmyersugrad
public class Pref{
	private static int dbType;
	
	public static void setDbType(int type){
		dbType = type;
	}

	public static int getDbType(){
		return dbType;
	}
}
RangeSearch.java0000600017357700026750000001056312437017166013521 0ustar  slmyersugradimport com.sleepycat.db.*;
import java.lang.String;
import java.util.concurrent.TimeUnit;
import java.io.UnsupportedEncodingException;
public class RangeSearch{
	//these should be private
	DataBase db;	
	String lowerLimit;
	String upperLimit;
	ResultSet resultSet;
	Database dataBase;
	OperationStatus oprStatus;
	String retrievedKey;
	String retrievedData;
	Scan scan;
	long duration;	

	public RangeSearch(){
		scan = Scan.getInstance();
		db = DataBase.getInstance();
		lowerLimit = new String();
		upperLimit = new String();
		resultSet = new ResultSet();
		
	}

	public void execute(boolean test, String lowerLimit, String upperLimit){
		if(!DataBase.INITIALIZED){
			db.initDataBase();
		}
		int dbtype = Pref.getDbType();
		if(!test){
			getLimits(); //sets this.upperLimit and this.lowerLimit if we're not running a test
		}
		else{
			this.lowerLimit = lowerLimit;
			this.upperLimit = upperLimit;
		}
		if(dbtype == 1 || dbtype == 3){
			try{
				btreeSearch();
			}catch(DatabaseException dbe){
				dbe.printStackTrace();
			}catch(UnsupportedEncodingException uee){
				uee.printStackTrace();
			}
		}else{
			try{
				hashSearch();
			}catch(DatabaseException dbe){
				dbe.printStackTrace();
			}catch(UnsupportedEncodingException uee){
				uee.printStackTrace();
			}
		}
		System.out.println("there were " + resultSet.getCount() + " results found and it took " + duration + " microseconds.");		
		resultSet.clear();
	}

	public void getLimits(){
		System.out.println("Enter lower key for range search or 'menu' to return to menu: ");
		lowerLimit = getInput();
		
		System.out.println("Enter upper key for range search or 'menu' to return to menu: ");
		upperLimit = getInput();
		
	}	

	public String getInput(){
		String input = new String();
		input = scan.getString();
		
		if(input.equals("menu")){
			Menu menu = new Menu();
			return null;
		}else{
			return input;
		}
	}

	public void btreeSearch() throws DatabaseException, UnsupportedEncodingException{
		System.out.println("Search type is BTREE interval search.");
		System.out.println("lower limit is: " + lowerLimit);
		System.out.println("upper limit is: " + upperLimit);

		if(Pref.getDbType() == 1){
			dataBase = db.getPrimaryDb();
		}else{
			dataBase = db.getIndexTree();

		}
		Cursor cursor = dataBase.openCursor(null, null);
		

		DatabaseEntry key = new DatabaseEntry();
		DatabaseEntry data = new DatabaseEntry();
		
		key.setReuseBuffer(false);		
		key.setData(lowerLimit.getBytes());
		
		data.setReuseBuffer(false);

		long startTime = System.nanoTime();
		
		oprStatus = cursor.getSearchKeyRange(key, data, LockMode.DEFAULT);
		if(oprStatus == OperationStatus.SUCCESS){
			retrievedKey = new String(key.getData(), "UTF-8");
		}
		while(oprStatus == OperationStatus.SUCCESS && !(retrievedKey.compareTo(upperLimit) > 0) ){
			retrievedData = new String(data.getData(), "UTF-8");
			resultSet.addResult(retrievedKey, retrievedData);
			oprStatus = cursor.getNext(key, data, LockMode.DEFAULT);
			retrievedKey = new String(key.getData(), "UTF-8");
		}
		long endTime = System.nanoTime();
		cursor.close();
		this.duration = TimeUnit.MICROSECONDS.convert(endTime - startTime, TimeUnit.NANOSECONDS);
		resultSet.writeResults();
	}	

	public void hashSearch() throws DatabaseException, UnsupportedEncodingException{
		dataBase = db.getPrimaryDb();
		System.out.println("Search type is hashTable interval search.");
		System.out.println("lower limit is: " + lowerLimit);
		System.out.println("upper limit is: " + upperLimit);
	
		Cursor cursor = dataBase.openCursor(null, null);
		if(cursor == null){
			db.initDataBase();
			cursor = dataBase.openCursor(null, null);

		}
		DatabaseEntry key = new DatabaseEntry();
		DatabaseEntry data = new DatabaseEntry();
		
		key.setReuseBuffer(false);
		data.setReuseBuffer(false);
		
		long startTime = System.nanoTime();
		oprStatus = cursor.getFirst(key, data, LockMode.DEFAULT);
		while(oprStatus == OperationStatus.SUCCESS){
			retrievedKey = new String(key.getData(), "UTF-8");
			if( (retrievedKey.compareTo(lowerLimit) >= 0) && (retrievedKey.compareTo(upperLimit) <= 0) ){
				retrievedData = new String(data.getData(), "UTF-8");
				resultSet.addResult(retrievedKey, retrievedData);
			}
			oprStatus = cursor.getNext(key, data, LockMode.DEFAULT);
		}
		long endTime = System.nanoTime();
		cursor.close();
		this.duration = TimeUnit.MICROSECONDS.convert(endTime - startTime, TimeUnit.NANOSECONDS);
		resultSet.writeResults();
	}
}
Result.java0000600017357700026750000000103212436675744012617 0ustar  slmyersugrad
public class Result{
	private String key;
	private String data;
	private int count;

	public Result(String key, String data, int count){
		this.count =  count;
		this.data = new String(data);
		this.key = new String(key);
	}

	public int getCount(){
		return this.count;
	}

	public String getData(){
		return this.data;
	}

	public String getKey(){
		return this.key;

	}

	public void print(){
		System.out.println("count = " + this.count);
		System.out.println("key = " + this.key);
		System.out.println("data = " + this.data);

	}
}
ResultSet.java0000600017357700026750000000151112437017023013252 0ustar  slmyersugradimport java.util.ArrayList;
import java.lang.String;
import java.util.HashSet;

public class ResultSet{
	private static final String ANSWERS = "answers";	
	private ArrayList<Result> results;
	private WriteToFile fw;

	public ResultSet(){
		this.results = new ArrayList<Result>();
		fw = new WriteToFile();
	}

	public void addResult(String key, String data){
		results.add(new Result(key, data, this.results.size() + 1));
	}
	
	public ArrayList<Result> getResults(){
		return this.results;
	}

	public int getCount(){
		return this.results.size();
	}

	public void writeResults(){
		for (Result result : results){
			fw.writeString(ANSWERS, result.getKey());
			fw.writeString(ANSWERS, result.getData());
			fw.writeString(ANSWERS, "");
		}
		
	}

	public void clear(){
		this.results.clear();
		this.results = new ArrayList<Result>();
	}
}
Scan.java0000600017357700026750000000233712436675744012236 0ustar  slmyersugradimport java.util.Scanner;

public class Scan{
	private static Scan scan = null;
	private static Scanner scanner = null;

	protected Scan(){
		try{		
			this.scanner = new Scanner(System.in);
		}catch(Exception e){
			System.out.println("Unable to instantiate Scanner! Check console output");
			e.printStackTrace();
		}	
	}

	public static Scan getInstance(){
		if(scan == null){
			scan = new Scan();
		}
		return scan;
	}

	public void close(){
		try{
			this.scanner.close();
		}catch(Exception e){
			System.out.println("Unable to close Scanner! Check console output");
			
		}
	}

	public static Scanner getScanner(){
		if(scanner == null){
			throw new RuntimeException("attempting to retrieve null scanner! Make sure to call Scan.getInstance() prior to retrieving scanner!");
		}

		return scanner;
	}

	public int getInt(){
		int number = -1;
		try{
			number = scanner.nextInt();
		}catch(Exception e){
			// some type of i/o or class error
			System.out.println("Error reading number input!");
			
		}
		scanner.nextLine();
		return number;
	}

	public String getString(){
		String string = null;
		try{
			string = scanner.nextLine();
		}catch(Exception e){
			System.out.println("Error reading text input!");
		}
		return string;
	}
}
WriteToFile.java0000600017357700026750000000201712436776747013547 0ustar  slmyersugradimport java.io.*;
import java.util.LinkedList;
//class for writing to file 
public class WriteToFile{
  private static File FILE = new File("answers");
    
  public void writeString(String file, String output){
		try{
			  PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(file, true)));
			  writer.println(output);
			  writer.close();
		}catch (IOException e){
			  System.out.println(e.getMessage());
		}
	}
        
	public LinkedList<String> readAnswerFile() throws FileNotFoundException, IOException{
		LinkedList<String> ll = new LinkedList<String>();
		String line = null;
		if(FILE.exists()){
			BufferedReader br = new BufferedReader(new FileReader(FILE));
			while( (line = br.readLine()) != null ){
				ll.add(line);
			}
			br.close();
			return ll;
		}
		return null;
	}

	public static final boolean deleteAnswerFile(){
		if(FILE.exists()){
			FILE.delete();
			return true;
		}
		return true;
	}

	public static final boolean answersExist(){
		boolean success = FILE.exists();
		return success;
	}
}
mydbtest.java0000600017357700026750000000161512437011362013160 0ustar  slmyersugradimport java.util.Scanner;

import java.util.Arrays;

public class mydbtest {
	public static void main(String[] args) {
		Scan scan = Scan.getInstance();
		int type = 0; 
		if (args.length > 0) {
    		try{
      		type = Integer.parseInt(args[0]);
    		}catch (NumberFormatException e) {
        	System.err.println("Argument " + args[0] + " must be an integer.");
        	System.exit(-1);
    		}
		}
		else{
			System.out.println("database type must be selected.");
			System.exit(-1);
		}
		if( (type > 3) || (type < 1) ){
			System.out.println("database type must be in interval (1,3)");
			System.exit(-1);
		}
		Pref.setDbType(type);
		Menu menu = new Menu();
		scan.close();
		if(DataBase.getInstance().getPrimaryDb() != null){
			DataBase.getInstance().close(true);
		}
		if(Pref.getDbType() == 3 && DataBase.getInstance().getIndexTree() != null){
			DataBase.getInstance().close(true);
		}
		
	}
}
README0000600017357700026750000000002112436675744011353 0ustar  slmyersugradtest readme file
mydbtest0000700017357700026750000000006012436675744012255 0ustar  slmyersugrad#!/bin/bash
make
java mydbtest $1 $2
make clean
makefile0000600017357700026750000000020112437020426012151 0ustar  slmyersugradall: javac 

javac:
	javac *\.java

clean:
	rm -f *.class
	rm -f *.java~
	rm -rf /tmp/user_db/
	rm -f makefile~
	rm -f ./answers
KeyRetrieve.java0000600071635700026750000001124212437150734013742 0ustar  jlhostynugradimport com.sleepycat.db.*;
import java.util.concurrent.TimeUnit;
public class KeyRetrieve {
        //examples 
	// Random Key: thndjefjyfwgpbmhzbfsfkubphiyvqirxwggmuxhvqnfmczshjaldffddmqyylwfmvbttcpvdjjffawzrdmwzykaspfugguntavetgdszamyogibkekcrvjuf
	// Random Data: djjtchkroyzbyzqycjbjfvkxuwuywywkcvqltyagjavmhpewjuhfqsaawwzwvusrobrzmkbstekgkbawzkl

	// Last key: zzzzevhwlhknxjmuxosuaunkzvqaynhihjpryfhwzziekyjpwhtsffnvywrrcwpxpmavfbqzwbxwkwwodfxiwcxsvkfznsgymytctmjleuxohjezlyeodccqletvf
	// Last Data: woqlahmzrqlyhhjzdklmjqolkbhhiasczpgukpyobcwztbsffleukvbfdnqnubmorshieukeclbbtie

	// DATA BELOW I'M 100% SURE IS RIGHT AS I PRINTED IT AS THE DATABASE WAS BEING CREATED.
	// key: oohiqwurgzsllzvhgigpxqwzbenyyjxuczmewrecjmxuvgjlzrnfxlmgzoilphatfquyyaadzvnztflneudhykt
	// data: hnrkmhfcwwzplsykkcaxqdtsnlenyanztgszjgnzvdgpidenkicynfdsgeyvgbnbaxdxlodtwexdlp

	// key: hgfjlbziiqxoqcpdsfginenvozqvyhnsdzwnzmubbxybauzdsolvbtxqqsbdqznvkjixrnaxfmcx
	// data: zqmornwieprpscrhbldbvrnexrqwxtkzufejctzshhhmblhfiwzwnhcadcotyueskadatwtowrfkxf
	
	// key: szysjqctdhewbmldkyzojvnpatqlhofdiavalosfwidkrppmshbcmrihpxuqdmyhvyvpuplerjsqxaseuetlsznwfclfytahorfqfgagjslzkqmlebh
	// data: fgzqeklegbkhfmvybrrlaeqprkwchikudsvdgksxkoxpmeaeqchluypdvatveqreeevnnbqszeykoyddsflsgnktspcfpgggmvkricdrlzfamhisqyyuljptcsnc
	Scan scan = Scan.getInstance();
	// creates database or gets instance if it was already created
	DataBase db = DataBase.getInstance();
	Database database = null;
	String filename = "answers";
    	WriteToFile fileWrite = new WriteToFile();
	
	public KeyRetrieve(){	
		if(Pref.getDbType() != 3){
			database = db.getPrimaryDb();
			if(database == null){
				db.initDataBase();
				database = db.getPrimaryDb();
			}
		}else{
			database = db.getIndexTree();
			if(database == null){
				db.initDataBase();
				database = db.getIndexTree();
			}
		}
	}

	// main of KeyRetrieve
	public void getRecords(boolean test, String testKey) {
		String key = null;
		// check if databse was populated by user yet
		if (database == null) {
			System.out.println("Database needs to be populated first!");
			return;
		}
		if(!test){
			// gets user input for record to search for                               
			System.out.print("Please enter key you want to search for: ");
			key = scan.getString();
		}else{
			key = testKey;
		}

		// set up inputed key and data
		DatabaseEntry dbKey = new DatabaseEntry();
		dbKey.setData(key.getBytes()); 
		dbKey.setSize(key.length());
		DatabaseEntry data = new DatabaseEntry();

		// start timer, end before returns
		long timeStart = System.nanoTime();
		
		System.out.println("Searching for key in database");
		// get the data record
		try {
			database.get(null, dbKey, data, LockMode.DEFAULT);
		}	
		catch (DatabaseException e) {
			System.err.println("unable to get key/value record!");
		}

		// end timer and print time
		long timeEnd = System.nanoTime();
    		long time = TimeUnit.MICROSECONDS.convert(timeEnd - timeStart, TimeUnit.NANOSECONDS);
		// prints the records found
		if (data.getData() == null) {
			System.out.println("Records found: 0");
		}
		else {
			System.out.println("Records found: 1");
			String sData = new String (data.getData());
			String fKey = new String (dbKey.getData());
			System.out.println("Key: " + fKey);
			System.out.println("Data: " + sData);
			fileWrite.writeString(filename, fKey); 
	    		fileWrite.writeString(filename, sData);
	    		fileWrite.writeString(filename, "");
		}

    		System.out.println("Search time = " + time + " Microseconds");
		return;

	}

	public void getIndexFileRecord(boolean test, String testKey) throws DatabaseException{
		String key;		
		if(!test){
			System.out.print("Enter key: ");
			key = scan.getString();
		}
		else{
			key = testKey;
		}
		String data = null;
		int recordsFound = 0;
		Cursor c = database.openCursor(null, null);		
		DatabaseEntry cKey = new DatabaseEntry();
		DatabaseEntry cData = new DatabaseEntry();
		cKey.setSize(key.length());	
		cKey.setData(key.getBytes());	
		OperationStatus status;

		long startTime = System.nanoTime();
		status = c.getSearchKey(cKey, cData, LockMode.DEFAULT);
		if(status == OperationStatus.SUCCESS){
			data = new String (cData.getData());
		}
		long endTime = System.nanoTime();
		long duration = TimeUnit.MICROSECONDS.convert(endTime - startTime, TimeUnit.NANOSECONDS);
		if(status == OperationStatus.SUCCESS){
			recordsFound = 1;
			fileWrite.writeString(filename, key); 
	   		fileWrite.writeString(filename, data);
	   		fileWrite.writeString(filename, "");
		}
		System.out.println("Records found: " + recordsFound + " Search time: " + duration + " Microseconds");
		System.out.println("Record information");
		System.out.println("key: " + key);
		System.out.println("data: " + data);
	}
}