/** Constructor */
public STSDriver2() {
System.out.print("Started STS tests2" + "\n");
// build ColaMarkets table
colamarkets = new Vector();
double[] v = new double[] {1.0, 1.0, 2.0, 3.0};
colamarkets.addElement(new ColaMarkets(1, "cola_a", new Sdo_geometry(Sdo_gtype.RECTANGLE, v)));
v = new double[] {2.5, 3.5, 3.5, 4.5};
colamarkets.addElement(new ColaMarkets(2, "cola_b", new Sdo_geometry(Sdo_gtype.RECTANGLE, v)));
boolean status = OK;
int numMarkets = 2;
int numMarkets_attrs = 3;
String dbpath = "/tmp/" + System.getProperty("user.name") + ".minibase.ststest2db";
String logpath = "/tmp/" + System.getProperty("user.name") + ".sts2log";
String remove_cmd = "/bin/rm -rf ";
String remove_logcmd = remove_cmd + logpath;
String remove_dbcmd = remove_cmd + dbpath;
String remove_sts2cmd = remove_cmd + dbpath;
try {
Runtime.getRuntime().exec(remove_logcmd);
Runtime.getRuntime().exec(remove_dbcmd);
Runtime.getRuntime().exec(remove_sts2cmd);
} catch (IOException e) {
System.err.println("" + e);
}
/*
ExtendedSystemDefs extSysDef =
new ExtendedSystemDefs( "/tmp/minibase.jointestdb", "/tmp/joinlog",
1000,500,200,"Clock");
*/
SystemDefs sysdef = new SystemDefs(dbpath, 1000, NUMBUF, "Clock");
// creating the sailors relation
AttrType[] Mtypes = new AttrType[3];
Mtypes[0] = new AttrType(AttrType.attrInteger);
Mtypes[1] = new AttrType(AttrType.attrString);
Mtypes[2] = new AttrType(AttrType.attrSdogeometry);
// SOS
short[] Msizes = new short[1];
Msizes[0] = 30; // first elt. is 30
Tuple t = new Tuple();
try {
t.setHdr((short) 3, Mtypes, Msizes);
} catch (Exception e) {
System.err.println("*** error in Tuple.setHdr() ***");
status = FAIL;
e.printStackTrace();
}
int size = t.size();
System.out.println("Size:" + size);
// selecting the tuple into file "colamarkets"
RID rid;
Heapfile f = null;
try {
f = new Heapfile("colamarkets.in");
} catch (Exception e) {
System.err.println("*** error in Heapfile constructor ***");
status = FAIL;
e.printStackTrace();
}
t = new Tuple(size);
try {
t.setHdr((short) 3, Mtypes, Msizes);
} catch (Exception e) {
System.err.println("*** error in Tuple.setHdr() ***");
status = FAIL;
e.printStackTrace();
}
for (int i = 0; i < numMarkets; i++) {
try {
t.setIntFld(1, ((ColaMarkets) colamarkets.elementAt(i)).marketId);
t.setStrFld(2, ((ColaMarkets) colamarkets.elementAt(i)).name);
t.setSdogeometryFld(3, ((ColaMarkets) colamarkets.elementAt(i)).shape);
} catch (Exception e) {
System.err.println("*** Heapfile error in Tuple.setStrFld() ***");
status = FAIL;
e.printStackTrace();
}
try {
rid = f.insertRecord(t.returnTupleByteArray());
} catch (Exception e) {
System.err.println("*** error in Heapfile.selectRecord() ***");
status = FAIL;
e.printStackTrace();
}
}
if (status != OK) {
// bail out
System.err.println("*** Error creation relation for colamarkets");
Runtime.getRuntime().exit(1);
}
}
/**
* routing using A* algorithm with fibonacci heap basically same as routingAStar function
*
* @param startNode
* @param endNode
* @param startTime
* @param pathNodeList return path
* @return
*/
public static double routingAStarFibonacci(
long startNode, long endNode, int startTime, int dayIndex, ArrayList<Long> pathNodeList) {
System.out.println("start finding the path...");
int debug = 0;
double totalCost = -1;
try {
// test store transversal nodes
// HashSet<Long> transversalSet = new HashSet<Long>();
if (!OSMData.nodeHashMap.containsKey(startNode)
|| !OSMData.nodeHashMap.containsKey(endNode)) {
System.err.println("cannot find start or end node!");
return -1;
}
if (startNode == endNode) {
System.out.println("start node is the same as end node.");
return 0;
}
HashSet<Long> closedSet = new HashSet<Long>();
HashMap<Long, FibonacciHeapNode<NodeInfoHelper>> nodeHelperCache =
new HashMap<Long, FibonacciHeapNode<NodeInfoHelper>>();
FibonacciHeap<NodeInfoHelper> openSet = initialStartSet(startNode, endNode, nodeHelperCache);
HashSet<Long> endSet = initialEndSet(endNode);
NodeInfoHelper current = null;
FibonacciHeapNode<NodeInfoHelper> fCurrent = null;
while (!openSet.isEmpty()) {
// remove current from openset
fCurrent = openSet.min();
openSet.removeMin();
current = fCurrent.getData();
// if(!transversalSet.contains(current.getNodeId()))
// transversalSet.add(current.getNodeId());
long nodeId = current.getNodeId();
// add current to closedset
closedSet.add(nodeId);
if (endSet.contains(nodeId)) { // find the destination
current = current.getEndNodeHelper(endNode);
totalCost = current.getCost();
break;
}
// for time dependent routing
int timeIndex =
startTime
+ (int)
(current.getCost() / OSMParam.SECOND_PER_MINUTE / OSMRouteParam.TIME_INTERVAL);
if (timeIndex
> OSMRouteParam.TIME_RANGE
- 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights
timeIndex = OSMRouteParam.TIME_RANGE - 1;
LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(nodeId);
if (adjNodeList == null) continue; // this node cannot go anywhere
double arriveTime = current.getCost();
// for each neighbor in neighbor_nodes(current)
for (ToNodeInfo toNode : adjNodeList) {
debug++;
long toNodeId = toNode.getNodeId();
int travelTime;
if (toNode.isFix()) // fix time
travelTime = toNode.getTravelTime();
else // fetch from time array
travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex);
// tentative_g_score := g_score[current] + dist_between(current,neighbor)
double costTime = arriveTime + (double) travelTime / OSMParam.MILLI_PER_SECOND;
// tentative_f_score := tentative_g_score + heuristic_cost_estimate(neighbor, goal)
double heuristicTime = estimateHeuristic(toNodeId, endNode);
double totalCostTime = costTime + heuristicTime;
// if neighbor in closedset and tentative_f_score >= f_score[neighbor]
if (closedSet.contains(toNodeId)
&& nodeHelperCache.get(toNodeId).getData().getTotalCost() <= totalCostTime) {
continue;
}
NodeInfoHelper node = null;
FibonacciHeapNode<NodeInfoHelper> fNode = null;
// if neighbor not in openset or tentative_f_score < f_score[neighbor]
if (!nodeHelperCache.containsKey(toNodeId)) { // neighbor not in openset
// create new one
node = new NodeInfoHelper(toNodeId);
node.setCost(costTime);
node.setHeuristic(heuristicTime);
node.setParentId(nodeId);
fNode = new FibonacciHeapNode<NodeInfoHelper>(node);
openSet.insert(fNode, node.getTotalCost());
nodeHelperCache.put(node.getNodeId(), fNode);
} else if (nodeHelperCache.get(toNodeId).getData().getTotalCost()
> totalCostTime) { // neighbor in openset
fNode = nodeHelperCache.get(toNodeId);
node = fNode.getData();
// update information
node.setCost(costTime);
node.setHeuristic(heuristicTime);
node.setParentId(nodeId);
if (closedSet.contains(toNodeId)) { // neighbor in closeset
closedSet.remove(toNodeId); // remove neighbor form colseset
openSet.insert(fNode, node.getTotalCost());
} else { // neighbor in openset, decreaseKey
openSet.decreaseKey(fNode, node.getTotalCost());
}
}
}
}
if (totalCost != -1) {
long traceNodeId = current.getNodeId();
pathNodeList.add(traceNodeId); // add end node
traceNodeId = current.getParentId();
while (traceNodeId != 0) {
pathNodeList.add(traceNodeId); // add node
fCurrent = nodeHelperCache.get(traceNodeId);
current = fCurrent.getData();
traceNodeId = current.getParentId();
}
Collections.reverse(pathNodeList); // reverse the path list
System.out.println("find the path successful!");
} else {
System.out.println("can not find the path!");
}
// OSMOutput.generateTransversalNodeKML(transversalSet, nodeHashMap);
} catch (Exception e) {
e.printStackTrace();
System.err.println(
"tdsp: debug code " + debug + ", start node " + startNode + ", end node " + endNode);
}
return totalCost;
}
public void Query1() {
System.out.print("**********************Query1 strating *********************\n");
boolean status = OK;
System.out.print(
"Query: Find the intersection of cola market cola_a and cola market cola_b"
+ "SELECT c.name, SDO_GEOM.SDO_AREA(c.shape, 0.005)"
+ " FROM cola_markets c_a, cola_markets c_b"
+ " WHERE c_a.name = 'cola_a' and c_b.name = 'cola_b'\n");
System.out.print("\n(Tests2 FileScan, Projection)\n");
CondExpr[] outFilter = new CondExpr[3];
outFilter[0] = new CondExpr();
outFilter[1] = new CondExpr();
outFilter[2] = new CondExpr();
Query1_CondExpr(outFilter);
Tuple t = new Tuple();
t = null;
AttrType[] Mtypes = new AttrType[3];
Mtypes[0] = new AttrType(AttrType.attrInteger);
Mtypes[1] = new AttrType(AttrType.attrString);
Mtypes[2] = new AttrType(AttrType.attrSdogeometry);
// SOS
short[] Msizes = new short[1];
Msizes[0] = 30; // first elt. is 30
FldSpec[] Mprojection = new FldSpec[2];
Mprojection[0] = new FldSpec(new RelSpec(RelSpec.outer), 2);
Mprojection[1] = new FldSpec(new RelSpec(RelSpec.outer), 3);
AttrType[] jtype = new AttrType[2];
jtype[0] = new AttrType(AttrType.attrString);
jtype[1] = new AttrType(AttrType.attrSdogeometry);
CondExpr[] selects = new CondExpr[1];
selects = null;
FileScan am = null;
try {
am = new FileScan("colamarkets.in", Mtypes, Msizes, (short) 3, (short) 2, Mprojection, null);
} catch (Exception e) {
status = FAIL;
System.err.println("" + e);
e.printStackTrace();
}
if (status != OK) {
// bail out
System.err.println("*** Error setting up scan for sailors");
Runtime.getRuntime().exit(1);
}
System.out.println("done");
Sdo_geometry x[] = new Sdo_geometry[2];
try {
int i = 0;
while ((t = am.get_next()) != null) {
t.print(jtype);
x[i++] = t.getSdogeometryFld(2);
}
Sdo_geometry sdoval = x[0].intersection(x[1]);
if (sdoval != null) {
String output = "SDO_GEOMETRY(" + (int) sdoval.shapeType.ordinal() + ",[ ";
for (double d : sdoval.coordinatesOfShape) output += d + " ";
System.out.print(output + "])");
}
} catch (Exception e) {
System.err.println("" + e);
e.printStackTrace();
Runtime.getRuntime().exit(1);
}
}
// TODO : if start or end is already in the highway, will occur the problem, need to fix
public static double routingHierarchy(
long startNode, long endNode, int startTime, int dayIndex, ArrayList<Long> pathNodeList) {
// System.out.println("start finding the path...");
int debug = 0;
try {
if (!OSMData.nodeHashMap.containsKey(startNode)
|| !OSMData.nodeHashMap.containsKey(endNode)) {
System.err.println("cannot find start or end node!");
return -1;
}
if (startNode == endNode) {
System.out.println("start node is the same as end node.");
return 0;
}
NodeInfo start = OSMData.nodeHashMap.get(startNode);
NodeInfo end = OSMData.nodeHashMap.get(endNode);
double minDistance = Geometry.calculateDistance(start.getLocation(), end.getLocation());
if (minDistance < 5) { // use normal A* algorithm to calculate small distance
return routingAStar(
start.getNodeId(),
end.getNodeId(),
OSMRouteParam.START_TIME,
OSMRouteParam.DAY_INDEX,
pathNodeList);
}
SearchingSharing sharingData = new SearchingSharing();
HashMap<Long, NodeInfoHelper> nodeForwardCache = new HashMap<Long, NodeInfoHelper>();
HashMap<Long, NodeInfoHelper> nodeReverseCache = new HashMap<Long, NodeInfoHelper>();
ForwardSearching forwardSearching =
new ForwardSearching(
startNode, endNode, startTime, dayIndex, sharingData, nodeForwardCache);
ReverseSearching reverseSearching =
new ReverseSearching(endNode, startNode, sharingData, nodeReverseCache);
// two thread run simultaneously
Thread forwardThread = new Thread(forwardSearching);
Thread reverseThread = new Thread(reverseSearching);
// search forward
forwardThread.start();
// let forward searching for a while
// Thread.sleep(100);
// search reverse
reverseThread.start();
// waiting for thread finish
forwardThread.join();
reverseThread.join();
// get the searching intersects
ArrayList<Long> intersectList = sharingData.getIntersectList();
// pick the least cost one according to time-dependent
double minCost = Double.MAX_VALUE;
ArrayList<Long> minCostPath = new ArrayList<Long>();
for (long intersect : intersectList) {
NodeInfoHelper current = nodeForwardCache.get(intersect);
// cost from source to intersect
double cost = current.getCost();
current = nodeReverseCache.get(intersect);
// update the reverse cost as forward cost
current.setCost(cost);
ArrayList<Long> reversePath = new ArrayList<Long>();
double totalCost = Double.MAX_VALUE;
// recalculate from intersect to destination
while (true) {
long nodeId = current.getNodeId();
int timeIndex =
startTime
+ (int)
(current.getCost()
/ OSMParam.SECOND_PER_MINUTE
/ OSMRouteParam.TIME_INTERVAL);
if (timeIndex
> OSMRouteParam.TIME_RANGE
- 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights
timeIndex = OSMRouteParam.TIME_RANGE - 1;
long nextNodeId = current.getParentId();
double arriveTime = current.getCost();
// arrive end
if (nextNodeId == 0) {
totalCost = arriveTime;
break;
}
// add node
reversePath.add(nextNodeId);
// calculate cost according adjlist
LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(nodeId);
double costTime = 0;
for (ToNodeInfo toNode : adjNodeList) {
if (toNode.getNodeId() == nextNodeId) {
int travelTime;
// forward searching is time dependent
if (toNode.isFix()) // fix time
travelTime = toNode.getTravelTime();
else // fetch from time array
travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex);
costTime = arriveTime + (double) travelTime / OSMParam.MILLI_PER_SECOND;
break;
}
}
current = nodeReverseCache.get(nextNodeId);
if (costTime == 0) System.err.println("cost time cannot be zero!");
else current.setCost(costTime);
}
// process the left nodes to real destination
long lastNode = reversePath.get(reversePath.size() - 1);
if (lastNode != endNode) {
NodeInfo last = OSMData.nodeHashMap.get(lastNode);
NodeInfo dest = OSMData.nodeHashMap.get(endNode);
EdgeInfo onEdge = last.getEdgeFromNodes(dest);
current = nodeReverseCache.get(lastNode);
int totalDistance = onEdge.getDistance();
int distance;
long toNodeId;
if (onEdge.getStartNode() == lastNode) { // from start to middle
distance = onEdge.getStartDistance(endNode);
toNodeId = onEdge.getEndNode();
} else { // from end to middle
distance = onEdge.getEndDistance(endNode);
toNodeId = onEdge.getStartNode();
}
LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(lastNode);
double costTime = 0;
int timeIndex =
startTime
+ (int) (totalCost / OSMParam.SECOND_PER_MINUTE / OSMRouteParam.TIME_INTERVAL);
if (timeIndex
> OSMRouteParam.TIME_RANGE
- 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights
timeIndex = OSMRouteParam.TIME_RANGE - 1;
for (ToNodeInfo toNode : adjNodeList) {
if (toNode.getNodeId() == toNodeId) {
int travelTime;
// forward searching is time dependent
if (toNode.isFix()) // fix time
travelTime = toNode.getTravelTime();
else // fetch from time array
travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex);
costTime = (double) travelTime / OSMParam.MILLI_PER_SECOND;
break;
}
}
if (costTime != 0) {
costTime *= (double) distance / totalDistance;
}
totalCost += costTime; // add cost
reversePath.add(endNode); // add dest
}
// if found less cost path, build forward path
if (totalCost < minCost) {
ArrayList<Long> forwardPath = new ArrayList<Long>();
minCost = totalCost;
current = nodeForwardCache.get(intersect);
long traceNodeId = current.getParentId();
while (traceNodeId != 0) {
forwardPath.add(traceNodeId); // add node
current = nodeForwardCache.get(traceNodeId);
traceNodeId = current.getParentId();
}
Collections.reverse(forwardPath); // reverse the path list
// record min-cost path, combine forward path and reverse path
minCostPath = new ArrayList<Long>();
minCostPath.addAll(forwardPath);
minCostPath.add(intersect);
minCostPath.addAll(reversePath);
// output kml
// OSMOutput.generatePathKML(nodeHashMap, pathNodeList, "path_" + intersect);
// ArrayList<Long> intersectNode = new ArrayList<Long>();
// intersectNode.add(intersect);
// OSMOutput.generatePathNodeKML(nodeHashMap, intersectNode, "intersect_" + intersect);
}
}
pathNodeList.addAll(minCostPath);
return minCost;
} catch (Exception e) {
e.printStackTrace();
System.err.println("routingHierarchy: debug code " + debug);
}
return 0;
}
/**
* overrides the test4 function in TestDriver
*
* @return whether test4 has passed
*/
protected boolean test4() {
System.out.print("\n Test 4 exercises some of the internals " + "of the buffer manager\n");
int index;
int numPages = NUMBUF + 10;
Page pg = new Page();
PageId pid = new PageId();
PageId[] pids = new PageId[numPages];
boolean status = OK;
System.out.print(" - Allocate bunch of pages together \n");
for (int i = 0; i < numPages / NUMBUF; i++) {
for (index = i * NUMBUF; status == OK && index < (i + 1) * NUMBUF; ++index) {
pg = new Page();
try {
pid = SystemDefs.JavabaseBM.newPage(pg, 1);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not allocate new page number " + index + 1 + "\n");
e.printStackTrace();
}
if (status == OK) {
pids[index] = pid;
}
if (status == OK) {
// Copy the page number + 99999 onto each page. It seems
// unlikely that this bit pattern would show up there by
// coincidence.
int data = pid.pid + 99999;
try {
Convert.setIntValue(data, 0, pg.getpage());
} catch (IOException e) {
System.err.print("*** Convert value failed\n");
status = FAIL;
e.printStackTrace();
}
}
}
for (index = i * NUMBUF; status == OK && index < (i + 1) * NUMBUF; ++index) {
try {
SystemDefs.JavabaseBM.unpinPage(pids[index], true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not unpin page " + pids[index].pid + "\n");
e.printStackTrace();
}
}
}
if (status == OK) {
System.out.print(" - Read the pages\n");
for (int i = 0; i < numPages / NUMBUF; i++) {
for (index = i * NUMBUF; status == OK && index < (i + 1) * NUMBUF; ++index) {
pg = new Page();
pid = pids[index];
try {
SystemDefs.JavabaseBM.pinPage(pid, pg, false);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not pin page " + pid.pid + "\n");
e.printStackTrace();
}
if (status == OK) {
int data = 0;
try {
data = Convert.getIntValue(0, pg.getpage());
} catch (IOException e) {
System.err.print("*** Convert value failed \n");
status = FAIL;
}
if (data != pid.pid + 99999) {
status = FAIL;
System.err.print("*** Read wrong data back from page " + pid.pid + "\n");
}
}
}
for (index = i * NUMBUF; status == OK && index < (i + 1) * NUMBUF; ++index) {
try {
SystemDefs.JavabaseBM.unpinPage(pids[index], true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not unpin page " + pids[index].pid + "\n");
e.printStackTrace();
}
}
}
}
if (status == OK) {
System.out.print(" Test 4 completed successfully.\n");
}
return status;
}
/**
* overrides the test3 function in TestDriver. It exercises some of the internal of the buffer
* manager
*
* @return whether test3 has passed
*/
protected boolean test3() {
System.out.print("\n Test 3 exercises some of the internals " + "of the buffer manager\n");
int index;
int numPages = NUMBUF + 10;
Page pg = new Page();
PageId pid = new PageId();
PageId[] pids = new PageId[numPages];
boolean status = OK;
System.out.print(
" - Allocate and dirty some new pages, one at " + "a time, and leave some pinned\n");
for (index = 0; status == OK && index < numPages; ++index) {
try {
pid = SystemDefs.JavabaseBM.newPage(pg, 1);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not allocate new page number " + index + 1 + "\n");
e.printStackTrace();
}
if (status == OK) pids[index] = pid;
if (status == OK) {
// Copy the page number + 99999 onto each page. It seems
// unlikely that this bit pattern would show up there by
// coincidence.
int data = pid.pid + 99999;
try {
Convert.setIntValue(data, 0, pg.getpage());
} catch (IOException e) {
System.err.print("*** Convert value failed\n");
status = FAIL;
e.printStackTrace();
}
// Leave the page pinned if it equals 12 mod 20. This is a
// random number based loosely on a bug report.
if (status == OK) {
if (pid.pid % 20 != 12) {
try {
SystemDefs.JavabaseBM.unpinPage(pid, /*dirty:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not unpin dirty page " + pid.pid + "\n");
}
}
}
}
}
if (status == OK) {
System.out.print(" - Read the pages\n");
for (index = 0; status == OK && index < numPages; ++index) {
pid = pids[index];
try {
SystemDefs.JavabaseBM.pinPage(pid, pg, false);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not pin page " + pid.pid + "\n");
e.printStackTrace();
}
if (status == OK) {
int data = 0;
try {
data = Convert.getIntValue(0, pg.getpage());
} catch (IOException e) {
System.err.print("*** Convert value failed \n");
status = FAIL;
}
if (data != pid.pid + 99999) {
status = FAIL;
System.err.print("*** Read wrong data back from page " + pid.pid + "\n");
}
}
if (status == OK) {
try {
SystemDefs.JavabaseBM.unpinPage(pid, true); // might not be dirty
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not unpin page " + pid.pid + "\n");
e.printStackTrace();
}
}
if (status == OK && (pid.pid % 20 == 12)) {
try {
SystemDefs.JavabaseBM.unpinPage(pid, /*dirty:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not unpin page " + pid.pid + "\n");
e.printStackTrace();
}
}
}
}
if (status == OK) System.out.print(" Test 3 completed successfully.\n");
return status;
}
/**
* overrides the test2 function in TestDriver. It tests whether illeagal operation can be caught.
*
* @return whether test2 has passed
*/
protected boolean test2() {
System.out.print("\n Test 2 exercises some illegal buffer " + "manager operations:\n");
// We choose this number to ensure that pinning this number of buffers
// should fail.
int numPages = SystemDefs.JavabaseBM.getNumUnpinnedBuffers() + 1;
Page pg = new Page();
PageId pid, lastPid;
PageId firstPid = new PageId();
boolean status = OK;
System.out.print(" - Try to pin more pages than there are frames\n");
try {
firstPid = SystemDefs.JavabaseBM.newPage(pg, numPages);
} catch (Exception e) {
System.err.print("*** Could not allocate " + numPages);
System.err.print(" new pages in the database.\n");
e.printStackTrace();
return false;
}
pid = new PageId();
lastPid = new PageId();
// First pin enough pages that there is no more room.
for (pid.pid = firstPid.pid + 1, lastPid.pid = firstPid.pid + numPages - 1;
status == OK && pid.pid < lastPid.pid;
pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.pinPage(pid, pg, /*emptyPage:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not pin new page " + pid.pid + "\n");
e.printStackTrace();
}
}
// Make sure the buffer manager thinks there's no more room.
if (status == OK && SystemDefs.JavabaseBM.getNumUnpinnedBuffers() != 0) {
status = FAIL;
System.err.print(
"*** The buffer manager thinks it has "
+ SystemDefs.JavabaseBM.getNumUnpinnedBuffers()
+ " available frames,\n"
+ " but it should have none.\n");
}
// Now pin that last page, and make sure it fails.
if (status == OK) {
try {
SystemDefs.JavabaseBM.pinPage(lastPid, pg, /*emptyPage:*/ true);
} catch (ChainException e) {
status = checkException(e, "bufmgr.BufferPoolExceededException");
if (status == FAIL) {
System.err.print("*** Pinning too many pages\n");
System.out.println(" --> Failed as expected \n");
}
} catch (Exception e) {
e.printStackTrace();
}
if (status == OK) {
status = FAIL;
System.err.print("The expected exception was not thrown\n");
} else {
status = OK;
}
}
if (status == OK) {
try {
SystemDefs.JavabaseBM.pinPage(firstPid, pg, /*emptyPage:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not acquire a second pin on a page\n");
e.printStackTrace();
}
if (status == OK) {
System.out.print(" - Try to free a doubly-pinned page\n");
try {
SystemDefs.JavabaseBM.freePage(firstPid);
} catch (ChainException e) {
status = checkException(e, "bufmgr.PagePinnedException");
if (status == FAIL) {
System.err.print("*** Freeing a pinned page\n");
System.out.println(" --> Failed as expected \n");
}
} catch (Exception e) {
e.printStackTrace();
}
if (status == OK) {
status = FAIL;
System.err.print("The expected exception was not thrown\n");
} else {
status = OK;
}
}
if (status == OK) {
try {
SystemDefs.JavabaseBM.unpinPage(firstPid, false);
} catch (Exception e) {
status = FAIL;
e.printStackTrace();
}
}
}
if (status == OK) {
System.out.print(" - Try to unpin a page not in the buffer pool\n");
try {
SystemDefs.JavabaseBM.unpinPage(lastPid, false);
} catch (ChainException e) {
status = checkException(e, "bufmgr.HashEntryNotFoundException");
if (status == FAIL) {
System.err.print("*** Unpinning a page not in the buffer pool\n");
System.out.println(" --> Failed as expected \n");
}
} catch (Exception e) {
e.printStackTrace();
}
if (status == OK) {
status = FAIL;
System.err.print("The expected exception was not thrown\n");
} else {
status = OK;
}
}
for (pid.pid = firstPid.pid; pid.pid <= lastPid.pid; pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.freePage(pid);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Error freeing page " + pid.pid + "\n");
e.printStackTrace();
}
}
if (status == OK) System.out.print(" Test 2 completed successfully.\n");
return status;
}
/**
* overrides the test1 function in TestDriver. It tests some simple normal buffer manager
* operations.
*
* @return whether test1 has passed
*/
protected boolean test1() {
System.out.print("\n Test 1 does a simple test of normal buffer ");
System.out.print("manager operations:\n");
// We choose this number to ensure that at least one page will have to be
// written during this test.
boolean status = OK;
int numPages = SystemDefs.JavabaseBM.getNumUnpinnedBuffers() + 1;
Page pg = new Page();
PageId pid;
PageId lastPid;
PageId firstPid = new PageId();
System.out.print(" - Allocate a bunch of new pages\n");
try {
firstPid = SystemDefs.JavabaseBM.newPage(pg, numPages);
} catch (Exception e) {
System.err.print("*** Could not allocate " + numPages);
System.err.print(" new pages in the database.\n");
e.printStackTrace();
return false;
}
// Unpin that first page... to simplify our loop.
try {
SystemDefs.JavabaseBM.unpinPage(firstPid, false /*not dirty*/);
} catch (Exception e) {
System.err.print("*** Could not unpin the first new page.\n");
e.printStackTrace();
status = FAIL;
}
System.out.print(" - Write something on each one\n");
pid = new PageId();
lastPid = new PageId();
for (pid.pid = firstPid.pid, lastPid.pid = pid.pid + numPages;
status == OK && pid.pid < lastPid.pid;
pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.pinPage(pid, pg, /*emptyPage:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not pin new page " + pid.pid + "\n");
e.printStackTrace();
}
if (status == OK) {
// Copy the page number + 99999 onto each page. It seems
// unlikely that this bit pattern would show up there by
// coincidence.
int data = pid.pid + 99999;
try {
Convert.setIntValue(data, 0, pg.getpage());
} catch (IOException e) {
System.err.print("*** Convert value failed\n");
status = FAIL;
}
if (status == OK) {
try {
SystemDefs.JavabaseBM.unpinPage(pid, /*dirty:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not unpin dirty page " + pid.pid + "\n");
e.printStackTrace();
}
}
}
}
if (status == OK)
System.out.print(
" - Read that something back from each one\n"
+ " (because we're buffering, this is where "
+ "most of the writes happen)\n");
for (pid.pid = firstPid.pid; status == OK && pid.pid < lastPid.pid; pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.pinPage(pid, pg, /*emptyPage:*/ false);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not pin page " + pid.pid + "\n");
e.printStackTrace();
}
if (status == OK) {
int data = 0;
try {
data = Convert.getIntValue(0, pg.getpage());
} catch (IOException e) {
System.err.print("*** Convert value failed \n");
status = FAIL;
}
if (status == OK) {
if (data != (pid.pid) + 99999) {
status = FAIL;
System.err.print("*** Read wrong data back from page " + pid.pid + "\n");
}
}
if (status == OK) {
try {
SystemDefs.JavabaseBM.unpinPage(pid, /*dirty:*/ true);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Could not unpin page " + pid.pid + "\n");
e.printStackTrace();
}
}
}
}
if (status == OK) System.out.print(" - Free the pages again\n");
for (pid.pid = firstPid.pid; pid.pid < lastPid.pid; pid.pid = pid.pid + 1) {
try {
SystemDefs.JavabaseBM.freePage(pid);
} catch (Exception e) {
status = FAIL;
System.err.print("*** Error freeing page " + pid.pid + "\n");
e.printStackTrace();
}
}
if (status == OK) System.out.print(" Test 1 completed successfully.\n");
return status;
}
