@Test
public void testCursorPutAndGet() throws Exception {
k1.putLong(0, 14);
v1.putLong(0, 15);
k2.putLong(0, 16);
v2.putLong(0, 17);
try (Transaction tx = env.createWriteTransaction()) {
try (Cursor cursor = db.openCursor(tx)) {
cursor.put(k1, v1, 0);
cursor.put(k2, v2, 0);
}
tx.commit();
}
DirectBuffer k = new DirectBuffer();
DirectBuffer v = new DirectBuffer();
try (Transaction tx = env.createReadTransaction()) {
try (Cursor cursor = db.openCursor(tx)) {
cursor.position(k, v, GetOp.FIRST);
assertThat(k.getLong(0), is(14L));
assertThat(v.getLong(0), is(15L));
cursor.position(k, v, GetOp.NEXT);
assertThat(k.getLong(0), is(16L));
assertThat(v.getLong(0), is(17L));
}
}
}
@Test
public void testCursorSeekRange() throws Exception {
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(8);
k1.putLong(0, 18);
v1.putLong(0, 19);
k2.putLong(0, 20);
v2.putLong(0, 21);
try (Transaction tx = env.createWriteTransaction()) {
try (Cursor cursor = db.openCursor(tx)) {
cursor.put(k1, v1, 0);
cursor.put(k2, v2, 0);
}
tx.commit();
}
try (Transaction tx = env.createReadTransaction()) {
try (Cursor cursor = db.openCursor(tx)) {
DirectBuffer k = new DirectBuffer(byteBuffer);
DirectBuffer v = new DirectBuffer();
k.putLong(0, 10);
cursor.seekPosition(k, v, SeekOp.RANGE);
assertThat(k.getLong(0), is(18L));
assertThat(v.getLong(0), is(19L));
k.wrap(byteBuffer);
k.putLong(0, 19);
cursor.seekPosition(k, v, SeekOp.RANGE);
assertThat(k.getLong(0), is(20L));
assertThat(v.getLong(0), is(21L));
}
}
}
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
}
@Test
public void testIteration() {
k1.putLong(0, 18);
v1.putLong(0, 19);
k2.putLong(0, 20);
v2.putLong(0, 21);
db.put(k1, v1, 0);
db.put(k2, v2, 0);
List<Long> result = new ArrayList<>();
try (Transaction tx = env.createWriteTransaction()) {
try (Cursor cursor = db.openCursor(tx)) {
DirectBuffer k = new DirectBuffer();
DirectBuffer v = new DirectBuffer();
for (int rc = cursor.position(k, v, FIRST);
rc != NOTFOUND;
rc = cursor.position(k, v, NEXT)) {
result.add(k.getLong(0));
}
}
tx.commit();
}
assertThat(result.size(), is(2));
assertThat(result.get(0), is(18L));
assertThat(result.get(1), is(20L));
}
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);
}
}
}
}
@Test
public void testReserveCursorRollback() {
byte[] key = new byte[] {1, 1, 1};
byte[] val = new byte[] {3, 3, 3};
Transaction tx = env.createWriteTransaction();
Cursor cursor = db.openCursor(tx);
DirectBuffer keyBuf = new DirectBuffer(ByteBuffer.allocateDirect(key.length));
keyBuf.putBytes(0, key);
DirectBuffer valBuf = cursor.reserve(keyBuf, val.length);
valBuf.putBytes(0, val);
tx.abort();
byte[] result = db.get(key);
assertNull(result);
}
/*
* 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();
}
@Test
public void testReserveCursor() {
byte[] key = new byte[] {1, 1, 1};
byte[] val = new byte[] {3, 3, 3};
try (Transaction tx = env.createWriteTransaction()) {
try (Cursor cursor = db.openCursor(tx)) {
DirectBuffer keyBuf = new DirectBuffer(ByteBuffer.allocateDirect(key.length));
keyBuf.putBytes(0, key);
DirectBuffer valBuf = cursor.reserve(keyBuf, val.length);
valBuf.putBytes(0, val);
}
tx.commit();
}
try (Transaction tx = env.createReadTransaction()) {
byte[] result = db.get(tx, key);
assertArrayEquals(result, val);
}
}
/**
* 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("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
}
