public static Database buildsecondary(Database std) {
// Parse database loaded
try {
io.deleteFile("secondarydb");
// SecondaryDatabases started
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setType(DatabaseType.HASH);
dbConfig.setAllowCreate(true);
dbConfig.setUnsortedDuplicates(true);
Database secdb = new Database("secondarydb", null, dbConfig);
// Cursors started
Cursor stdcursor = std.openCursor(null, null);
Cursor secdbcursor = secdb.openCursor(null, null);
// Key and Data started
DatabaseEntry stdkey = new DatabaseEntry();
DatabaseEntry stddata = new DatabaseEntry();
DatabaseEntry seckey = new DatabaseEntry();
DatabaseEntry secdata = new DatabaseEntry();
while (stdcursor.getNext(stdkey, stddata, LockMode.DEFAULT)
== OperationStatus.SUCCESS) { // Writing into secondary db
String[] key = new String(stdkey.getData()).split(",");
String data = new String(stddata.getData());
// DEBUG:
// System.out.println("key 0:" + key[0] + " key 1:" + key[1] + " data:" + data);
seckey.setData(key[1].getBytes());
OperationStatus operation = secdbcursor.getSearchKey(seckey, secdata, LockMode.DEFAULT);
String b = null;
while (operation == OperationStatus.SUCCESS) {
b = new String(secdata.getData());
secdbcursor.delete();
operation = secdbcursor.getNextDup(seckey, secdata, LockMode.DEFAULT);
}
if (b == null) {
seckey.setData(key[1].getBytes());
secdata.setData(("(" + key[0] + "," + data + ")").getBytes());
secdb.put(null, seckey, secdata);
}
if (b != null) {
secdata.setData(b.concat("(" + key[0] + "," + data + ")").getBytes());
secdb.put(null, seckey, secdata);
}
seckey.setData(null);
secdata.setData(null);
stdkey.setData(null);
stddata.setData(null);
}
// io.debugread(secdb);
return secdb;
} catch (Exception e) {
System.out.println("Error creating <user>,<song,rating> secondary table!\n");
System.out.println(e.getMessage());
}
return null; // SHOULD NEVER HAPPEN
}
public void runTest(DatabaseType type) throws DatabaseException, FileNotFoundException {
int i;
DatabaseConfig conf = new DatabaseConfig();
conf.setErrorStream(TestUtils.getErrorStream());
conf.setErrorPrefix("HashCompareTest");
conf.setType(type);
if (type == DatabaseType.HASH) {
conf.setHashComparator(new HashComparator());
} else conf.setBtreeComparator(new BtreeComparator());
conf.setAllowCreate(true);
Database db = new Database(HASHCOMPARETEST_DBNAME, null, conf);
DatabaseEntry key = new DatabaseEntry();
DatabaseEntry data = new DatabaseEntry("world".getBytes());
for (i = 0; i < 100; i++) {
key.setData((new String("key" + i)).getBytes());
db.put(null, key, data);
}
i = 0;
Cursor dbc;
dbc = db.openCursor(null, CursorConfig.DEFAULT);
while (dbc.getNext(key, data, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
++i;
}
// System.out.println("retrieved " + i + " entries");
dbc.close();
db.close();
}
/**
* Instantiates the query for rscore
*
* @param query contains user query
* @param cmp contains compare structure
* @param resultIndices passes the indices that store the result
* @throws DatabaseException when BerkeleyDB passes errors
* @throws FileNotFoundException when respective .idx or .txt value not found
*/
private void queryRScore(String query, ArrayList<Integer> resultIndices, COMPARE cmp)
throws FileNotFoundException, DatabaseException {
if (cmp == COMPARE.EQUAL) {
query = query.replace("rscore=", "").toLowerCase();
queryDB(query, rscoreIndex, resultIndices);
return;
} else if (cmp == COMPARE.LESS) {
query = query.replace("rscore<", "");
} else {
query = query.replace("rscore>", "");
}
OperationStatus oprStatus;
Database std_db = new Database(rscoreIndex, null, null);
Cursor std_cursor = std_db.openCursor(null, null); // Create new cursor object
if (cmp == COMPARE.LESS) {
for (int n = 0; n < Integer.parseInt(query); n++) {
String searchkey = new String();
searchkey = n + ".0";
DatabaseEntry key = new DatabaseEntry();
DatabaseEntry data = new DatabaseEntry();
oprStatus = std_cursor.getFirst(key, data, LockMode.DEFAULT);
key.setData(searchkey.getBytes());
key.setSize(searchkey.length());
data = new DatabaseEntry();
oprStatus = std_cursor.getSearchKey(key, data, LockMode.DEFAULT);
while (oprStatus == OperationStatus.SUCCESS) {
String s = new String(data.getData());
if (!(resultIndices.contains(Integer.parseInt(s)))) {
resultIndices.add(Integer.parseInt(s));
}
oprStatus = std_cursor.getNextDup(key, data, LockMode.DEFAULT);
}
}
} else {
for (int n = 5; n > Integer.parseInt(query); n--) {
String searchkey = new String();
searchkey = n + ".0";
DatabaseEntry key = new DatabaseEntry();
DatabaseEntry data = new DatabaseEntry();
oprStatus = std_cursor.getFirst(key, data, LockMode.DEFAULT);
key.setData(searchkey.getBytes());
key.setSize(searchkey.length());
data = new DatabaseEntry();
oprStatus = std_cursor.getSearchKey(key, data, LockMode.DEFAULT);
while (oprStatus == OperationStatus.SUCCESS) {
String s = new String(data.getData());
if (!(resultIndices.contains(Integer.parseInt(s)))) {
resultIndices.add(Integer.parseInt(s));
}
oprStatus = std_cursor.getNextDup(key, data, LockMode.DEFAULT);
}
}
}
}
/*
* void return type since error conditions are propogated
* via exceptions.
*/
private void printStocks(Database db) throws DeadlockException, DatabaseException {
Cursor dbc = db.openCursor(null, null);
System.out.println("\tSymbol\tPrice");
System.out.println("\t======\t=====");
DatabaseEntry key = new DatabaseEntry();
DatabaseEntry data = new DatabaseEntry();
OperationStatus ret;
for (ret = dbc.getFirst(key, data, LockMode.DEFAULT);
ret == OperationStatus.SUCCESS;
ret = dbc.getNext(key, data, LockMode.DEFAULT)) {
String keystr = new String(key.getData(), key.getOffset(), key.getSize());
String datastr = new String(data.getData(), data.getOffset(), data.getSize());
System.out.println("\t" + keystr + "\t" + datastr);
}
dbc.close();
}
/**
* Generic query process
*
* @param query contains parsed query for process
* @param db_name contains database to query
* @param indices passes the indices that store the result
* @throws DatabaseException when BerkeleyDB passes errors
* @throws FileNotFoundException when respective .idx or .txt value not found
*/
private void queryDB(String query, String db_name, ArrayList<Integer> indices)
throws DatabaseException, FileNotFoundException {
OperationStatus oprStatus;
Database std_db = new Database(db_name, null, null);
Cursor std_cursor = std_db.openCursor(null, null); // Create new cursor object
DatabaseEntry key = new DatabaseEntry();
DatabaseEntry data = new DatabaseEntry();
key.setData(query.getBytes());
key.setSize(query.length());
// Returns OperationStatus
oprStatus = std_cursor.getSearchKey(key, data, LockMode.DEFAULT);
while (oprStatus == OperationStatus.SUCCESS) {
String s = new String(data.getData());
if (!(indices.contains(Integer.parseInt(s)))) {
indices.add(Integer.parseInt(s));
}
oprStatus = std_cursor.getNextDup(key, data, LockMode.DEFAULT);
}
std_cursor.close();
std_db.close();
}
public static String rank(Database sqSumdb) throws DatabaseException {
Cursor sqSumCurs = sqSumdb.openCursor(null, null);
DatabaseEntry sqSumKey = new DatabaseEntry();
DatabaseEntry sqSumData = new DatabaseEntry();
// initialize the ids and distances to be replaced by the loop below
String firstIDs = "";
String secondIDs = "";
String thirdIDs = "";
double inf = Integer.MAX_VALUE;
double firstDist = inf;
double secondDist = inf;
double thirdDist = inf;
// initialize containers for rating data for each song before distance calculation
boolean firstFilled = true;
boolean secondFilled = true;
boolean thirdFilled = true;
while (sqSumCurs.getNext(sqSumKey, sqSumData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
// get song id
String id = (new String(sqSumKey.getData()));
String[] sumN = (new String(sqSumData.getData())).split(",");
sqSumKey.setData(null);
sqSumData.setData(null);
double sum = Integer.parseInt(sumN[0]);
double N = Integer.parseInt(sumN[1]);
double dist = Math.sqrt(sum) / N;
if (dist != inf) {
if (dist < firstDist || !firstFilled) {
// set thirdID and thirdDist
thirdIDs = secondIDs;
thirdDist = secondDist;
// set secondID and secondDist
secondIDs = firstIDs;
secondDist = firstDist;
// set firstID and firstDist
firstIDs = id;
firstDist = dist;
if (firstFilled) {
if (secondFilled) {
thirdFilled = true;
}
secondFilled = true;
}
firstFilled = true;
} else if ((dist < secondDist || !secondFilled) && dist != firstDist) {
// set thirdID and thirdDist
thirdIDs = secondIDs;
thirdDist = secondDist;
// set secondID and secondDist
secondIDs = id;
secondDist = dist;
if (secondFilled) {
thirdFilled = true;
}
secondFilled = true;
} else if ((dist < thirdDist || !thirdFilled) && dist != firstDist && dist != secondDist) {
// set thirdID and thirdDist
thirdIDs = id;
thirdDist = dist;
thirdFilled = true;
} else if (dist == firstDist) {
// append fistID
firstIDs += ", " + id;
} else if (dist == secondDist) {
// append secondID
secondIDs += ", " + id;
} else if (dist == thirdDist) {
// append thirdID
thirdIDs += ", " + id;
}
}
}
if (firstIDs.equals("")) firstIDs = "<no 1st place>";
if (secondIDs.equals("")) secondIDs = "<no 2nd place>";
if (thirdIDs.equals("")) thirdIDs = "<no 3rd place>";
return firstIDs + ", " + secondIDs + ", " + thirdIDs;
}
public static Database buildtertiary(Database std) {
try {
// configure new database instance
io.deleteFile("tertiarydb");
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setType(DatabaseType.HASH);
dbConfig.setAllowCreate(true);
dbConfig.setUnsortedDuplicates(true);
Database tdb = new Database("tertiarydb", null, dbConfig);
// configure cursors and entries
Cursor stdCurs = std.openCursor(null, null);
Cursor tCurs = tdb.openCursor(null, null);
DatabaseEntry stdKey = new DatabaseEntry();
DatabaseEntry stdData = new DatabaseEntry();
DatabaseEntry tKey = new DatabaseEntry();
DatabaseEntry tData = new DatabaseEntry();
// extract from linearly constructed database to populate <song>,<users> table, making
// use of songs grouped by id
String currUsers = "";
String prevID = "default";
boolean firstIter = true;
while (stdCurs.getNext(stdKey, stdData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
// get rating data from current row
String[] currIDUser = (new String(stdKey.getData())).split(",");
String currID = currIDUser[0].trim();
String currUser = currIDUser[1].trim();
String currRating = (new String(stdData.getData()));
stdKey.setData(null);
stdData.setData(null);
if (currID.equals(prevID) || firstIter) {
// concatenate new username with current string
currUsers += "(" + currUser + "," + currRating + ")";
} else if (!firstIter) {
// insert completed <usernames> into table under key <song id>
tKey.setData(prevID.getBytes());
tData.setData(currUsers.substring(0, currUsers.length()).getBytes());
tCurs.put(tKey, tData);
tKey.setData(null);
tData.setData(null);
// DEBUG:
// System.out.println(prevID+","+currUsers.substring(0, currUsers.length()-1));
// start the new <usernames> for the next song (in currID)
currUsers = "(" + currUser + "," + currRating + ")";
}
prevID = currID;
firstIter = false;
}
// repeat iteration for last song
tKey.setData(prevID.getBytes());
tData.setData(currUsers.substring(0, currUsers.length()).getBytes());
tCurs.put(tKey, tData);
tKey.setData(null);
tData.setData(null);
// DEBUG:
// io.debugread(tdb);
tCurs.close();
return tdb;
} catch (Exception e) {
System.out.println(" error creating <song>,<users> tertiary table\n");
System.out.println(e.getMessage());
}
return null; // should never happen
}
public static String top3(String line, Database secdb, Database tdb)
throws DatabaseException, FileNotFoundException {
// configure sqSum db for keeping track of cumulative squaresums
io.deleteFile("sqSumdb");
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setType(DatabaseType.HASH);
dbConfig.setAllowCreate(true);
dbConfig.setUnsortedDuplicates(true);
Database sqSumdb = new Database("sqSumdb", null, dbConfig);
Cursor sqSumCurs = sqSumdb.openCursor(null, null);
DatabaseEntry sqSumKey = new DatabaseEntry();
DatabaseEntry sqSumData = new DatabaseEntry();
Cursor secCurs = secdb.openCursor(null, null);
Cursor tCurs = tdb.openCursor(null, null);
DatabaseEntry secKey = new DatabaseEntry();
DatabaseEntry secData = new DatabaseEntry();
DatabaseEntry tKey = new DatabaseEntry();
DatabaseEntry tData = new DatabaseEntry();
// get input song users and ratings
tKey.setData(line.getBytes());
if (tCurs.getSearchKey(tKey, tData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
// for each user in input song, get songs and ratings
HashMap<String, String> iRatings = parseBrace(new String(tData.getData()));
for (String user : iRatings.keySet()) {
// get current user's rating for input song
int inputRating = Integer.parseInt(iRatings.get(user));
// get songs and ratings for user
secKey.setData(null);
secData.setData(null);
secKey.setData(user.getBytes());
if (secCurs.getSearchKey(secKey, secData, null) == OperationStatus.SUCCESS) {
// for each song rated by user
HashMap<String, String> currSongs = parseBrace(new String(secData.getData()));
for (String song : currSongs.keySet()) {
// input song should not be compared to itself, otherwise get the users and ratings for
// it
if (song.equals(line)) continue;
// current user's rating for song under inspection
int songRating = Integer.parseInt(currSongs.get(song));
sqSumKey.setData(null);
sqSumData.setData(null);
sqSumKey.setData(song.getBytes());
if (sqSumCurs.getSearchKey(sqSumKey, sqSumData, null) == OperationStatus.SUCCESS) {
// if song is already in sqSum,N db, add to it
String[] sumN = (new String(sqSumData.getData())).split(",");
// add the new square sum to the previous and increment N
int sum = Integer.parseInt(sumN[0]);
int N = Integer.parseInt(sumN[1]);
sum += (inputRating - songRating) * (inputRating - songRating);
N += 1;
String encoded = Integer.toString(sum) + "," + Integer.toString(N);
// remove old entry for current song and replace it with the new one
sqSumCurs.delete();
sqSumKey.setData(null);
sqSumData.setData(null);
sqSumKey.setData(song.getBytes());
sqSumData.setData(encoded.getBytes());
sqSumdb.put(null, sqSumKey, sqSumData);
} else {
// if song in not already in sqSum,N db, create it
int sum = (inputRating - songRating) * (inputRating - songRating);
int N = 1;
String encoded = Integer.toString(sum) + "," + Integer.toString(N);
sqSumKey.setData(null);
sqSumData.setData(null);
sqSumKey.setData(song.getBytes());
sqSumData.setData(encoded.getBytes());
sqSumdb.put(null, sqSumKey, sqSumData);
}
}
} else {
System.out.println("ERROR: user " + user + " not in secondary database.");
}
}
} else {
return line + " has not been rated by any user.";
}
// DEBUG
// io.debugread(sqSumdb);
// calculate distance for each song in, inserting into the top 3 spots as we iterate through
String ranked = rank(sqSumdb);
return line + ", " + ranked;
}
/**
* Prints the results obtained by BerkeleyDB
*
* @throws DatabaseException whenever BerkeleyDB is violateed
* @throws FileNotFoundException when .idx files not found or .txt files not found.
* @throws ParseException when ParseDouble returns an error.
*/
private void printResults() throws DatabaseException, FileNotFoundException, ParseException {
// System.out.println("Num of indices before pprice rdate constraints: " + indices.size());
if (indices.isEmpty()) {
System.out.println("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
System.out.println("No results matching given query.");
System.out.println("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
}
Integer counter = 0;
for (Integer index : indices) {
OperationStatus oprStatus;
Database std_db = new Database("rw.idx", null, null);
Cursor std_cursor = std_db.openCursor(null, null); // Create new cursor object
DatabaseEntry key = new DatabaseEntry();
DatabaseEntry data = new DatabaseEntry();
Product product = new Product();
Review review = new Review();
String searchkey = index.toString().toLowerCase();
key.setData(searchkey.getBytes());
key.setSize(searchkey.length());
// Returns OperationStatus
oprStatus = std_cursor.getSearchKey(key, data, LockMode.DEFAULT);
Bill:
{
if (oprStatus == OperationStatus.SUCCESS) {
String s = new String(data.getData());
load_data(product, review, s);
/** Filters low priority queue for pprice / rdate processes. */
GenericStack<String> tmplow = new GenericStack<String>(lowpriorities);
while (!tmplow.isEmpty()) {
String subquery = tmplow.pop();
if (subquery.matches("pprice.*")) {
Double value =
Double.parseDouble(
subquery
.replace("pprice", "")
.replace(">", "")
.replace("=", "")
.replace("<", ""));
if (product.getPrice().equals("unknown")) break Bill;
if (subquery.matches("pprice<.*")
&& !(Double.parseDouble(product.getPrice()) > value)) continue;
else if (subquery.matches("pprice=.*")
&& !(Double.parseDouble(product.getPrice()) == value)) continue;
else if (subquery.matches("pprice>.*")
&& !(Double.parseDouble(product.getPrice()) < value)) continue;
else break Bill;
} else if (subquery.matches("rdate.*")) {
String comparator = subquery.substring(5, 6);
DateFormat df = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
Date valuedate = df.parse(subquery.substring(6) + " 00:00:00");
long valuedatedoesntmatataer =
(valuedate.getTime() / 1000)
- 25200; // delay set by 7hours - timezone difference.
switch (comparator) {
case "<":
if (!(Long.parseLong(review.getTime()) < valuedatedoesntmatataer)) {
break Bill;
} else {
break;
}
case ">":
if (!(Long.parseLong(review.getTime()) > valuedatedoesntmatataer)) {
break Bill;
} else {
break;
}
case "=":
if (!(Long.parseLong(review.getTime()) == valuedatedoesntmatataer)) {
break Bill;
} else {
break;
}
default:
break Bill;
}
}
}
// System.out.print(" "+ index +" ");
product.print();
review.print();
counter++;
}
std_cursor.close();
std_db.close();
}
}
System.out.println("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
System.out.println("Total records found: " + counter);
System.out.println("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
}
//
// XXX Figure out the appropriate way to pick out IDs.
//
int txn() {
Cursor acurs = null;
Cursor bcurs = null;
Cursor hcurs = null;
Cursor tcurs = null;
Transaction t = null;
Defrec rec = new Defrec();
Histrec hrec = new Histrec();
int account, branch, teller;
DatabaseEntry d_dbt = new DatabaseEntry();
DatabaseEntry d_histdbt = new DatabaseEntry();
DatabaseEntry k_dbt = new DatabaseEntry();
DatabaseEntry k_histdbt = new DatabaseEntry();
account = TpcbExample.this.random_id(TpcbExample.ACCOUNT);
branch = TpcbExample.this.random_id(TpcbExample.BRANCH);
teller = TpcbExample.this.random_id(TpcbExample.TELLER);
// The history key will not actually be retrieved,
// but it does need to be set to something.
byte[] hist_key = new byte[4];
k_histdbt.setData(hist_key);
k_histdbt.setSize(4 /* == sizeof(int)*/);
byte[] key_bytes = new byte[4];
k_dbt.setData(key_bytes);
k_dbt.setSize(4 /* == sizeof(int)*/);
d_dbt.setData(rec.data);
d_dbt.setUserBuffer(rec.length(), true);
hrec.set_aid(account);
hrec.set_bid(branch);
hrec.set_tid(teller);
hrec.set_amount(10);
// Request 0 bytes since we're just positioning.
d_histdbt.setPartial(0, 0, true);
// START PER-TRANSACTION TIMING.
//
// Technically, TPCB requires a limit on response time, you only
// get to count transactions that complete within 2 seconds.
// That's not an issue for this sample application -- regardless,
// here's where the transaction begins.
try {
t = dbenv.beginTransaction(null, null);
acurs = adb.openCursor(t, null);
bcurs = bdb.openCursor(t, null);
tcurs = tdb.openCursor(t, null);
hcurs = hdb.openCursor(t, null);
// Account record
k_dbt.setRecordNumber(account);
if (acurs.getSearchKey(k_dbt, d_dbt, null) != OperationStatus.SUCCESS)
throw new Exception("acurs get failed");
rec.set_balance(rec.get_balance() + 10);
acurs.putCurrent(d_dbt);
// Branch record
k_dbt.setRecordNumber(branch);
if (bcurs.getSearchKey(k_dbt, d_dbt, null) != OperationStatus.SUCCESS)
throw new Exception("bcurs get failed");
rec.set_balance(rec.get_balance() + 10);
bcurs.putCurrent(d_dbt);
// Teller record
k_dbt.setRecordNumber(teller);
if (tcurs.getSearchKey(k_dbt, d_dbt, null) != OperationStatus.SUCCESS)
throw new Exception("ccurs get failed");
rec.set_balance(rec.get_balance() + 10);
tcurs.putCurrent(d_dbt);
// History record
d_histdbt.setPartial(0, 0, false);
d_histdbt.setData(hrec.data);
d_histdbt.setUserBuffer(hrec.length(), true);
if (hdb.append(t, k_histdbt, d_histdbt) != OperationStatus.SUCCESS)
throw new DatabaseException("put failed");
acurs.close();
acurs = null;
bcurs.close();
bcurs = null;
tcurs.close();
tcurs = null;
hcurs.close();
hcurs = null;
// null out t in advance; if the commit fails,
// we don't want to abort it in the catch clause.
Transaction tmptxn = t;
t = null;
tmptxn.commit();
// END TIMING
return (0);
} catch (Exception e) {
try {
if (acurs != null) acurs.close();
if (bcurs != null) bcurs.close();
if (tcurs != null) tcurs.close();
if (hcurs != null) hcurs.close();
if (t != null) t.abort();
} catch (DatabaseException dbe) {
// not much we can do here.
}
if (TpcbExample.this.verbose) {
System.out.println(
"Transaction A="
+ String.valueOf(account)
+ " B="
+ String.valueOf(branch)
+ " T="
+ String.valueOf(teller)
+ " failed");
System.out.println("Reason: " + e.toString());
}
return (-1);
}
}