/**
* 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);
}
}
}
}
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
}
/**
* Inserts an entity and returns null, or updates it if the primary key already exists and returns
* the existing entity.
*
* <p>If a {@link PrimaryKey#sequence} is used and the primary key field of the given entity is
* null or zero, this method will assign the next value from the sequence to the primary key field
* of the given entity.
*
* @param txn the transaction used to protect this operation, null to use auto-commit, or null if
* the store is non-transactional.
* @param entity the entity to be inserted or updated.
* @return the existing entity that was updated, or null if the entity was inserted.
* @throws DatabaseException the base class for all BDB exceptions.
*/
public E put(Transaction txn, E entity) throws DatabaseException {
DatabaseEntry keyEntry = new DatabaseEntry();
DatabaseEntry dataEntry = new DatabaseEntry();
assignKey(entity, keyEntry);
boolean autoCommit = false;
Environment env = db.getEnvironment();
if (transactional && txn == null && DbCompat.getThreadTransaction(env) == null) {
txn = env.beginTransaction(null, getAutoCommitTransactionConfig());
autoCommit = true;
}
CursorConfig cursorConfig = null;
if (concurrentDB) {
cursorConfig = new CursorConfig();
DbCompat.setWriteCursor(cursorConfig, true);
}
boolean failed = true;
Cursor cursor = db.openCursor(txn, cursorConfig);
LockMode lockMode = locking ? LockMode.RMW : null;
try {
while (true) {
OperationStatus status = cursor.getSearchKey(keyEntry, dataEntry, lockMode);
if (status == OperationStatus.SUCCESS) {
E existing = entityBinding.entryToObject(keyEntry, dataEntry);
entityBinding.objectToData(entity, dataEntry);
cursor.put(keyEntry, dataEntry);
failed = false;
return existing;
} else {
entityBinding.objectToData(entity, dataEntry);
status = cursor.putNoOverwrite(keyEntry, dataEntry);
if (status != OperationStatus.KEYEXIST) {
failed = false;
return null;
}
}
}
} finally {
cursor.close();
if (autoCommit) {
if (failed) {
txn.abort();
} else {
txn.commit();
}
}
}
}
/**
* 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 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("+=-=-=-=-=-=-=-=-=-=-=-=-=+");
}
protected int untypedCount(byte[] k) {
EvictorI.DeactivateController deactivateController = _store.evictor().deactivateController();
deactivateController.lock();
try {
com.sleepycat.db.DatabaseEntry key = new com.sleepycat.db.DatabaseEntry(k);
//
// When we have a custom-comparison function, Berkeley DB returns
// the key on-disk (when it finds one). We disable this behavior:
// (ref Oracle SR 5925672.992)
//
// In DB > 5.1.x we can not set DB_DBT_PARTIAL in the key Dbt when calling
// getSearchKey.
//
if (com.sleepycat.db.Environment.getVersionMajor() < 5
|| (com.sleepycat.db.Environment.getVersionMajor() == 5
&& com.sleepycat.db.Environment.getVersionMinor() <= 1)) {
key.setPartial(true);
}
com.sleepycat.db.DatabaseEntry value = new com.sleepycat.db.DatabaseEntry();
//
// dlen is 0, so we should not retrieve any value
//
value.setPartial(true);
TransactionI transaction = _store.evictor().beforeQuery();
com.sleepycat.db.Transaction tx = transaction == null ? null : transaction.dbTxn();
for (; ; ) {
com.sleepycat.db.Cursor dbc = null;
try {
dbc = _db.openCursor(tx, null);
if (dbc.getSearchKey(key, value, null) == com.sleepycat.db.OperationStatus.SUCCESS) {
return dbc.count();
} else {
return 0;
}
} catch (com.sleepycat.db.DeadlockException dx) {
if (_store.evictor().deadlockWarning()) {
_store
.communicator()
.getLogger()
.warning(
"Deadlock in Freeze.Index.untypedCount while "
+ "iterating over Db \""
+ _store.evictor().filename()
+ "/"
+ _dbName
+ "\"");
}
if (tx != null) {
throw new DeadlockException(
_store.evictor().errorPrefix() + "Db.cursor: " + dx.getMessage(), transaction, dx);
}
//
// Otherwise retry
//
} catch (com.sleepycat.db.DatabaseException dx) {
throw new DatabaseException(
_store.evictor().errorPrefix() + "Db.cursor: " + dx.getMessage(), dx);
} finally {
if (dbc != null) {
try {
dbc.close();
} catch (com.sleepycat.db.DeadlockException dx) {
if (tx != null) {
throw new DeadlockException(
_store.evictor().errorPrefix() + "Db.cursor: " + dx.getMessage(),
transaction,
dx);
}
} catch (com.sleepycat.db.DatabaseException dx) {
//
// Ignored
//
}
}
}
}
} finally {
deactivateController.unlock();
}
}
//
// 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);
}
}