Revision 2767
Added by sgarg over 18 years ago
| DocumentImpl.java | ||
|---|---|---|
| 1006 | 1006 |
while (it.hasNext()) {
|
| 1007 | 1007 |
|
| 1008 | 1008 |
NodeRecord currentNode = (NodeRecord) it.next(); |
| 1009 |
logMetacat.info("[Got Node ID: " + currentNode.nodeid + " ("
|
|
| 1010 |
+ currentNode.parentnodeid + ", " + currentNode.nodeindex
|
|
| 1011 |
+ ", " + currentNode.nodetype + ", " + currentNode.nodename
|
|
| 1012 |
+ ", " + currentNode.nodedata + ")]");
|
|
| 1009 |
logMetacat.info("[Got Node ID: " + currentNode.getNodeId() + " ("
|
|
| 1010 |
+ currentNode.getParentNodeId() + ", " + currentNode.getNodeIndex()
|
|
| 1011 |
+ ", " + currentNode.getNodeType() + ", " + currentNode.getNodeName()
|
|
| 1012 |
+ ", " + currentNode.getNodeData() + ")]");
|
|
| 1013 | 1013 |
// Print the end tag for the previous node if needed |
| 1014 | 1014 |
// |
| 1015 | 1015 |
// This is determined by inspecting the parent nodeid for the |
| ... | ... | |
| 1028 | 1028 |
// is handled by the NodeComparator class used by the TreeSet |
| 1029 | 1029 |
if (!atRootElement) {
|
| 1030 | 1030 |
NodeRecord currentElement = (NodeRecord) openElements.peek(); |
| 1031 |
if (currentNode.parentnodeid != currentElement.nodeid) {
|
|
| 1032 |
while (currentNode.parentnodeid != currentElement.nodeid) {
|
|
| 1031 |
if (currentNode.getParentNodeId() != currentElement.getNodeId()) {
|
|
| 1032 |
while (currentNode.getParentNodeId() != currentElement.getNodeId()) {
|
|
| 1033 | 1033 |
currentElement = (NodeRecord) openElements.pop(); |
| 1034 | 1034 |
logMetacat.info("\n POPPED: "
|
| 1035 |
+ currentElement.nodename);
|
|
| 1035 |
+ currentElement.getNodeName());
|
|
| 1036 | 1036 |
if (previousNodeWasElement) {
|
| 1037 | 1037 |
out.print(">");
|
| 1038 | 1038 |
previousNodeWasElement = false; |
| 1039 | 1039 |
} |
| 1040 |
if (currentElement.nodeprefix != null) {
|
|
| 1041 |
out.print("</" + currentElement.nodeprefix + ":"
|
|
| 1042 |
+ currentElement.nodename + ">");
|
|
| 1040 |
if (currentElement.getNodePrefix() != null) {
|
|
| 1041 |
out.print("</" + currentElement.getNodePrefix() + ":"
|
|
| 1042 |
+ currentElement.getNodeName() + ">");
|
|
| 1043 | 1043 |
} else {
|
| 1044 |
out.print("</" + currentElement.nodename + ">");
|
|
| 1044 |
out.print("</" + currentElement.getNodeName() + ">");
|
|
| 1045 | 1045 |
} |
| 1046 | 1046 |
currentElement = (NodeRecord) openElements.peek(); |
| 1047 | 1047 |
} |
| ... | ... | |
| 1049 | 1049 |
} |
| 1050 | 1050 |
|
| 1051 | 1051 |
// Handle the DOCUMENT node |
| 1052 |
if (currentNode.nodetype.equals("DOCUMENT")) {
|
|
| 1052 |
if (currentNode.getNodeType().equals("DOCUMENT")) {
|
|
| 1053 | 1053 |
out.print("<?xml version=\"1.0\"?>");
|
| 1054 | 1054 |
|
| 1055 | 1055 |
// Handle the ELEMENT nodes |
| 1056 |
} else if (currentNode.nodetype.equals("ELEMENT")) {
|
|
| 1056 |
} else if (currentNode.getNodeType().equals("ELEMENT")) {
|
|
| 1057 | 1057 |
if (atRootElement) {
|
| 1058 | 1058 |
atRootElement = false; |
| 1059 | 1059 |
} else {
|
| ... | ... | |
| 1079 | 1079 |
} |
| 1080 | 1080 |
firstElement = false; |
| 1081 | 1081 |
openElements.push(currentNode); |
| 1082 |
logMetacat.info("\n PUSHED: " + currentNode.nodename);
|
|
| 1082 |
logMetacat.info("\n PUSHED: " + currentNode.getNodeName());
|
|
| 1083 | 1083 |
previousNodeWasElement = true; |
| 1084 |
if (currentNode.nodeprefix != null) {
|
|
| 1085 |
out.print("<" + currentNode.nodeprefix + ":"
|
|
| 1086 |
+ currentNode.nodename);
|
|
| 1084 |
if (currentNode.getNodePrefix() != null) {
|
|
| 1085 |
out.print("<" + currentNode.getNodePrefix() + ":"
|
|
| 1086 |
+ currentNode.getNodeName());
|
|
| 1087 | 1087 |
} else {
|
| 1088 |
out.print("<" + currentNode.nodename);
|
|
| 1088 |
out.print("<" + currentNode.getNodeName());
|
|
| 1089 | 1089 |
} |
| 1090 | 1090 |
|
| 1091 | 1091 |
// if currentNode is inline and handle eml2, set flag proccess |
| 1092 | 1092 |
// in |
| 1093 |
if (currentNode.nodename != null
|
|
| 1094 |
&& currentNode.nodename.equals(Eml200SAXHandler.INLINE)
|
|
| 1093 |
if (currentNode.getNodeName() != null
|
|
| 1094 |
&& currentNode.getNodeName().equals(Eml200SAXHandler.INLINE)
|
|
| 1095 | 1095 |
&& proccessEml2) {
|
| 1096 | 1096 |
prcocessInlineData = true; |
| 1097 | 1097 |
} |
| 1098 | 1098 |
|
| 1099 | 1099 |
// Handle the ATTRIBUTE nodes |
| 1100 |
} else if (currentNode.nodetype.equals("ATTRIBUTE")) {
|
|
| 1101 |
if (currentNode.nodeprefix != null) {
|
|
| 1102 |
out.print(" " + currentNode.nodeprefix + ":"
|
|
| 1103 |
+ currentNode.nodename + "=\""
|
|
| 1104 |
+ currentNode.nodedata + "\"");
|
|
| 1100 |
} else if (currentNode.getNodeType().equals("ATTRIBUTE")) {
|
|
| 1101 |
if (currentNode.getNodePrefix() != null) {
|
|
| 1102 |
out.print(" " + currentNode.getNodePrefix() + ":"
|
|
| 1103 |
+ currentNode.getNodeName() + "=\""
|
|
| 1104 |
+ currentNode.getNodeData() + "\"");
|
|
| 1105 | 1105 |
} else {
|
| 1106 |
out.print(" " + currentNode.nodename + "=\""
|
|
| 1107 |
+ currentNode.nodedata + "\"");
|
|
| 1106 |
out.print(" " + currentNode.getNodeName() + "=\""
|
|
| 1107 |
+ currentNode.getNodeData() + "\"");
|
|
| 1108 | 1108 |
} |
| 1109 | 1109 |
|
| 1110 | 1110 |
// Handle the NAMESPACE nodes |
| 1111 |
} else if (currentNode.nodetype.equals("NAMESPACE")) {
|
|
| 1112 |
out.print(" xmlns:" + currentNode.nodename + "=\""
|
|
| 1113 |
+ currentNode.nodedata + "\"");
|
|
| 1111 |
} else if (currentNode.getNodeType().equals("NAMESPACE")) {
|
|
| 1112 |
out.print(" xmlns:" + currentNode.getNodeName() + "=\""
|
|
| 1113 |
+ currentNode.getNodeData() + "\"");
|
|
| 1114 | 1114 |
|
| 1115 | 1115 |
// Handle the TEXT nodes |
| 1116 |
} else if (currentNode.nodetype.equals("TEXT")) {
|
|
| 1116 |
} else if (currentNode.getNodeType().equals("TEXT")) {
|
|
| 1117 | 1117 |
if (previousNodeWasElement) {
|
| 1118 | 1118 |
out.print(">");
|
| 1119 | 1119 |
} |
| 1120 | 1120 |
if (!prcocessInlineData) {
|
| 1121 | 1121 |
// if it is not inline data just out put data |
| 1122 |
out.print(currentNode.nodedata);
|
|
| 1122 |
out.print(currentNode.getNodeData());
|
|
| 1123 | 1123 |
} else {
|
| 1124 | 1124 |
// if it is inline data first to get the inline data |
| 1125 | 1125 |
// internal id |
| 1126 |
String fileName = currentNode.nodedata;
|
|
| 1126 |
String fileName = currentNode.getNodeData();
|
|
| 1127 | 1127 |
String accessfileName = MetaCatUtil |
| 1128 | 1128 |
.getDocIdWithoutRevFromInlineDataID(fileName); |
| 1129 | 1129 |
// check if user has read permision for this inline data |
| ... | ... | |
| 1176 | 1176 |
}// in inlinedata part |
| 1177 | 1177 |
previousNodeWasElement = false; |
| 1178 | 1178 |
// Handle the COMMENT nodes |
| 1179 |
} else if (currentNode.nodetype.equals("COMMENT")) {
|
|
| 1179 |
} else if (currentNode.getNodeType().equals("COMMENT")) {
|
|
| 1180 | 1180 |
if (previousNodeWasElement) {
|
| 1181 | 1181 |
out.print(">");
|
| 1182 | 1182 |
} |
| 1183 |
out.print("<!--" + currentNode.nodedata + "-->");
|
|
| 1183 |
out.print("<!--" + currentNode.getNodeData() + "-->");
|
|
| 1184 | 1184 |
previousNodeWasElement = false; |
| 1185 | 1185 |
|
| 1186 | 1186 |
// Handle the PI nodes |
| 1187 |
} else if (currentNode.nodetype.equals("PI")) {
|
|
| 1187 |
} else if (currentNode.getNodeType().equals("PI")) {
|
|
| 1188 | 1188 |
if (previousNodeWasElement) {
|
| 1189 | 1189 |
out.print(">");
|
| 1190 | 1190 |
} |
| 1191 |
out.print("<?" + currentNode.nodename + " "
|
|
| 1192 |
+ currentNode.nodedata + "?>");
|
|
| 1191 |
out.print("<?" + currentNode.getNodeName() + " "
|
|
| 1192 |
+ currentNode.getNodeData() + "?>");
|
|
| 1193 | 1193 |
previousNodeWasElement = false; |
| 1194 | 1194 |
// Handle the DTD nodes (docname, publicid, systemid) |
| 1195 |
} else if (currentNode.nodetype.equals(DTD)) {
|
|
| 1195 |
} else if (currentNode.getNodeType().equals(DTD)) {
|
|
| 1196 | 1196 |
storedDTD = true; |
| 1197 | 1197 |
if (currentNode.getNodeName().equals(DOCNAME)) {
|
| 1198 | 1198 |
dbDocName = currentNode.getNodeData(); |
| ... | ... | |
| 1233 | 1233 |
// Print the final end tag for the root element |
| 1234 | 1234 |
while (!openElements.empty()) {
|
| 1235 | 1235 |
NodeRecord currentElement = (NodeRecord) openElements.pop(); |
| 1236 |
logMetacat.info("\n POPPED: " + currentElement.nodename);
|
|
| 1237 |
if (currentElement.nodeprefix != null) {
|
|
| 1238 |
out.print("</" + currentElement.nodeprefix + ":"
|
|
| 1239 |
+ currentElement.nodename + ">");
|
|
| 1236 |
logMetacat.info("\n POPPED: " + currentElement.getNodeName());
|
|
| 1237 |
if (currentElement.getNodePrefix() != null) {
|
|
| 1238 |
out.print("</" + currentElement.getNodePrefix() + ":"
|
|
| 1239 |
+ currentElement.getNodeName() + ">");
|
|
| 1240 | 1240 |
} else {
|
| 1241 |
out.print("</" + currentElement.nodename + ">");
|
|
| 1241 |
out.print("</" + currentElement.getNodeName() + ">");
|
|
| 1242 | 1242 |
} |
| 1243 | 1243 |
} |
| 1244 | 1244 |
out.flush(); |
| ... | ... | |
| 1255 | 1255 |
*/ |
| 1256 | 1256 |
public void buildIndex() throws McdbException |
| 1257 | 1257 |
{
|
| 1258 |
logMetacat.warn("buildIndex called on docid " + docid);
|
|
| 1258 | 1259 |
TreeSet nodeRecordLists = getNodeRecordList(rootnodeid); |
| 1259 | 1260 |
boolean atRootElement = true; |
| 1260 | 1261 |
long rootNodeId = -1; |
| ... | ... | |
| 1269 | 1270 |
nodeRecordMap.put(nodeId, currentNode); |
| 1270 | 1271 |
} |
| 1271 | 1272 |
|
| 1272 |
//DocumentIdentifier doc = null; |
|
| 1273 |
//String doc = MetaCatUtil.getDocIdFromAccessionNumber(docid); |
|
| 1274 | 1273 |
String doc = docid; |
| 1275 |
/*try {
|
|
| 1276 |
doc = new DocumentIdentifier(docid); |
|
| 1277 |
} catch (AccessionNumberException e){
|
|
| 1278 |
logMetacat.info("AccessionNumber Exception while "
|
|
| 1279 |
+ " inserting path index " |
|
| 1280 |
+ "in DocumentImpl.buildIndex for " |
|
| 1281 |
+ "document " + docid, 10); |
|
| 1282 |
logMetacat.info(e.getMessage(), 10); |
|
| 1283 |
}*/ |
|
| 1284 | 1274 |
|
| 1285 | 1275 |
// Opening separate db connection for deleting and writing |
| 1286 | 1276 |
// XML Index -- be sure that it is all in one db transaction |
| ... | ... | |
| 1296 | 1286 |
// Delete the previous index entries for this document |
| 1297 | 1287 |
deleteNodeIndex(dbConn); |
| 1298 | 1288 |
|
| 1299 |
// Delete all the entries in xml_queryresult |
|
| 1300 |
PreparedStatement pstmt = dbConn.prepareStatement( |
|
| 1301 |
"DELETE FROM xml_queryresult WHERE docid = ?"); |
|
| 1302 |
pstmt.setString(1, doc); |
|
| 1303 |
pstmt.execute(); |
|
| 1304 |
pstmt.close(); |
|
| 1305 |
dbConn.increaseUsageCount(1); |
|
| 1306 |
|
|
| 1307 |
// Delete all the entries in xml_queryresult |
|
| 1308 |
pstmt = dbConn.prepareStatement( |
|
| 1309 |
"DELETE FROM xml_path_index WHERE docid = ?"); |
|
| 1310 |
pstmt.setString(1, doc); |
|
| 1311 |
pstmt.execute(); |
|
| 1312 |
pstmt.close(); |
|
| 1313 |
dbConn.increaseUsageCount(1); |
|
| 1314 |
//System.out.println("after dleteing !!!!!!!!!!!1");
|
|
| 1315 | 1289 |
// Step through all of the node records we were given |
| 1316 | 1290 |
// and build the new index and update the database |
| 1317 | 1291 |
it = nodeRecordLists.iterator(); |
| 1292 |
Vector pathsFound = new Vector();; |
|
| 1318 | 1293 |
while (it.hasNext()) {
|
| 1319 | 1294 |
NodeRecord currentNode = (NodeRecord) it.next(); |
| 1320 | 1295 |
HashMap pathList = new HashMap(); |
| 1321 |
if (currentNode.nodetype.equals("ELEMENT") ||
|
|
| 1322 |
currentNode.nodetype.equals("ATTRIBUTE") ) {
|
|
| 1296 |
if (currentNode.getNodeType().equals("ELEMENT") ||
|
|
| 1297 |
currentNode.getNodeType().equals("ATTRIBUTE")){
|
|
| 1323 | 1298 |
|
| 1324 | 1299 |
if (atRootElement) {
|
| 1325 | 1300 |
rootNodeId = currentNode.getNodeId(); |
| ... | ... | |
| 1327 | 1302 |
} |
| 1328 | 1303 |
traverseParents(nodeRecordMap, rootNodeId, |
| 1329 | 1304 |
currentNode.getNodeId(), |
| 1330 |
currentNode.getNodeId(), "", pathList); |
|
| 1305 |
currentNode.getNodeId(), |
|
| 1306 |
"", pathList, pathsFound); |
|
| 1331 | 1307 |
updateNodeIndex(dbConn, pathList); |
| 1308 |
} else if (currentNode.getNodeType().equals("TEXT")){
|
|
| 1309 |
if(!currentNode.getNodeData().trim().equals("")
|
|
| 1310 |
&& !pathsFound.isEmpty()){
|
|
| 1311 |
updatePathIndex(dbConn, currentNode, pathsFound); |
|
| 1312 |
pathsFound.removeAllElements(); |
|
| 1313 |
} |
|
| 1332 | 1314 |
} |
| 1333 | 1315 |
} |
| 1334 |
|
|
| 1316 |
|
|
| 1335 | 1317 |
dbConn.commit(); |
| 1336 | 1318 |
} catch (SQLException e) {
|
| 1337 |
logMetacat.error("SQL Exception while inserting path index "
|
|
| 1319 |
logMetacat.error("SQL Exception while indexing "
|
|
| 1338 | 1320 |
+ "in DocumentImpl.buildIndex for " |
| 1339 | 1321 |
+ "document " + docid); |
| 1340 | 1322 |
logMetacat.error(e.getMessage()); |
| ... | ... | |
| 1349 | 1331 |
} finally {
|
| 1350 | 1332 |
DBConnectionPool.returnDBConnection(dbConn, serialNumber); |
| 1351 | 1333 |
} |
| 1352 |
|
|
| 1353 |
try {
|
|
| 1354 |
dbConn = DBConnectionPool.getDBConnection("DocumentImpl.buildIndex-pathIndex");
|
|
| 1355 |
serialNumber = dbConn.getCheckOutSerialNumber(); |
|
| 1356 |
dbConn.setAutoCommit(false); |
|
| 1357 |
|
|
| 1358 |
ResultSet rs = null; |
|
| 1359 |
PreparedStatement pstmt1 = null; |
|
| 1360 |
|
|
| 1361 |
String pathList = ""; |
|
| 1362 |
for (int i = 0; i < MetaCatUtil.pathsForIndexing.size(); i++) {
|
|
| 1363 |
pathList = pathList + "i.path = '" + |
|
| 1364 |
(String)MetaCatUtil.pathsForIndexing.get(i) + "' OR "; |
|
| 1365 |
} |
|
| 1366 |
|
|
| 1367 |
pathList = pathList.substring(0,pathList.length()-4); |
|
| 1368 |
|
|
| 1369 |
PreparedStatement pstmt = dbConn.prepareStatement("SELECT DISTINCT n.docid, "
|
|
| 1370 |
+ "n.nodedata, n.nodedatanumerical," |
|
| 1371 |
+ " n.parentnodeid, i.path FROM" |
|
| 1372 |
+ " xml_nodes n, xml_index i WHERE" |
|
| 1373 |
+ " (" + pathList
|
|
| 1374 |
+ " ) AND n.parentnodeid=i.nodeid AND" |
|
| 1375 |
+ " n.nodetype LIKE 'TEXT' and n.docid = ?" |
|
| 1376 |
+ " order by n.parentnodeid"); |
|
| 1377 |
|
|
| 1378 |
pstmt.setString(1, doc); |
|
| 1379 |
|
|
| 1380 |
pstmt.execute(); |
|
| 1381 |
rs = pstmt.getResultSet(); |
|
| 1382 |
dbConn.increaseUsageCount(1); |
|
| 1383 |
|
|
| 1384 |
int count = 0; |
|
| 1385 |
|
|
| 1386 |
while (rs.next()) {
|
|
| 1387 |
//System.out.println("update xml_path_index!!!!!!!1");
|
|
| 1388 |
String docid = rs.getString(1); |
|
| 1389 |
String nodedata = rs.getString(2); |
|
| 1390 |
float nodedatanumerical = rs.getFloat(3); |
|
| 1391 |
int parentnodeid = rs.getInt(4); |
|
| 1392 |
String path = rs.getString(5); |
|
| 1393 |
|
|
| 1394 |
if (!nodedata.trim().equals("")) {
|
|
| 1395 |
pstmt1 = dbConn.prepareStatement("INSERT INTO "
|
|
| 1396 |
+ "xml_path_index (docid, path, nodedata, " |
|
| 1397 |
+ "nodedatanumerical, parentnodeid)" |
|
| 1398 |
+ " VALUES (?, ?, ?, ?, ?)"); |
|
| 1399 |
|
|
| 1400 |
pstmt1.setString(1, docid); |
|
| 1401 |
pstmt1.setString(2, path); |
|
| 1402 |
pstmt1.setString(3, nodedata); |
|
| 1403 |
pstmt1.setFloat(4, nodedatanumerical); |
|
| 1404 |
pstmt1.setInt(5, parentnodeid); |
|
| 1405 |
|
|
| 1406 |
pstmt1.execute(); |
|
| 1407 |
pstmt1.close(); |
|
| 1408 |
dbConn.increaseUsageCount(1); |
|
| 1409 |
|
|
| 1410 |
count++; |
|
| 1411 |
} |
|
| 1412 |
} |
|
| 1413 |
|
|
| 1414 |
rs.close(); |
|
| 1415 |
pstmt.close(); |
|
| 1416 |
dbConn.increaseUsageCount(1); |
|
| 1417 |
|
|
| 1418 |
logMetacat.warn("Indexed " + count
|
|
| 1419 |
+ " records for docid: " + docid); |
|
| 1420 |
|
|
| 1421 |
dbConn.commit(); |
|
| 1422 |
} catch (SQLException e) {
|
|
| 1423 |
logMetacat.error("SQL Exception while inserting path index "
|
|
| 1424 |
+ "in DocumentImpl.buildIndex for " |
|
| 1425 |
+ "document " + docid); |
|
| 1426 |
logMetacat.error(e.getMessage()); |
|
| 1427 |
try {
|
|
| 1428 |
dbConn.rollback(); |
|
| 1429 |
} catch (SQLException sqle) {
|
|
| 1430 |
logMetacat.error("Error while rolling back "
|
|
| 1431 |
+ "commit in DocumentImpl" |
|
| 1432 |
+ ".buildIndex" + "\n" |
|
| 1433 |
+ sqle.getMessage()); |
|
| 1434 |
} |
|
| 1435 |
} finally {
|
|
| 1436 |
DBConnectionPool.returnDBConnection(dbConn, serialNumber); |
|
| 1437 |
} |
|
| 1334 |
|
|
| 1335 |
logMetacat.warn("BuildIndex complete for docid " + docid);
|
|
| 1438 | 1336 |
} |
| 1439 | 1337 |
|
| 1440 | 1338 |
/** |
| ... | ... | |
| 1451 | 1349 |
*/ |
| 1452 | 1350 |
private void traverseParents(HashMap records, long rootNodeId, |
| 1453 | 1351 |
long leafNodeId, long id, |
| 1454 |
String children, HashMap pathList) {
|
|
| 1455 |
Long nodeId = new Long(id);
|
|
| 1352 |
String children, HashMap pathList, Vector pathsFoundForIndexing) {
|
|
| 1353 |
Long nodeId = new Long(id);
|
|
| 1456 | 1354 |
NodeRecord current = (NodeRecord)records.get(nodeId); |
| 1457 | 1355 |
long parentId = current.getParentNodeId(); |
| 1458 | 1356 |
String currentName = current.getNodeName(); |
| 1459 |
if (current.nodetype.equals("ELEMENT") ||
|
|
| 1460 |
current.nodetype.equals("ATTRIBUTE") ) {
|
|
| 1461 |
|
|
| 1357 |
if (current.getNodeType().equals("ELEMENT") ||
|
|
| 1358 |
current.getNodeType().equals("ATTRIBUTE") ) {
|
|
| 1359 |
|
|
| 1462 | 1360 |
if (children.equals("")) {
|
| 1463 |
if (current.nodetype.equals("ATTRIBUTE")) {
|
|
| 1361 |
if (current.getNodeType().equals("ATTRIBUTE")) {
|
|
| 1464 | 1362 |
currentName = "@" + currentName; |
| 1465 | 1363 |
} |
| 1466 | 1364 |
logMetacat.debug("A: " + currentName +"\n");
|
| 1467 | 1365 |
pathList.put(currentName, new PathIndexEntry(leafNodeId, |
| 1468 | 1366 |
currentName, docid, doctype, parentId)); |
| 1367 |
if(MetaCatUtil.pathsForIndexing.contains(currentName)){
|
|
| 1368 |
logMetacat.debug("paths found " + currentName);
|
|
| 1369 |
pathsFoundForIndexing.add(currentName); |
|
| 1370 |
} |
|
| 1469 | 1371 |
} |
| 1470 | 1372 |
currentName = "/" + currentName; |
| 1471 | 1373 |
currentName = currentName + children; |
| 1472 | 1374 |
if (parentId != 0) {
|
| 1473 | 1375 |
traverseParents(records, rootNodeId, leafNodeId, |
| 1474 |
parentId, currentName, pathList); |
|
| 1376 |
parentId, currentName, pathList, pathsFoundForIndexing);
|
|
| 1475 | 1377 |
} |
| 1476 | 1378 |
String path = current.getNodeName() + children; |
| 1379 |
|
|
| 1477 | 1380 |
if (!children.equals("")) {
|
| 1478 | 1381 |
logMetacat.debug("B: " + path +"\n");
|
| 1479 | 1382 |
pathList.put(path, new PathIndexEntry(leafNodeId, path, docid, |
| 1480 | 1383 |
doctype, parentId)); |
| 1384 |
if(MetaCatUtil.pathsForIndexing.contains(path)){
|
|
| 1385 |
logMetacat.debug("paths found " + path);
|
|
| 1386 |
pathsFoundForIndexing.add(path); |
|
| 1387 |
} |
|
| 1481 | 1388 |
} |
| 1482 | 1389 |
if (id == rootNodeId) {
|
| 1483 | 1390 |
String fullPath = '/' + path; |
| 1484 | 1391 |
logMetacat.debug("C: " + fullPath +"\n");
|
| 1485 | 1392 |
pathList.put(fullPath, new PathIndexEntry(leafNodeId, fullPath, |
| 1486 | 1393 |
docid, doctype, parentId)); |
| 1394 |
if(MetaCatUtil.pathsForIndexing.contains(fullPath)){
|
|
| 1395 |
logMetacat.debug("paths found " + fullPath);
|
|
| 1396 |
pathsFoundForIndexing.add(fullPath); |
|
| 1397 |
} |
|
| 1487 | 1398 |
} |
| 1488 |
} |
|
| 1399 |
}
|
|
| 1489 | 1400 |
} |
| 1490 | 1401 |
|
| 1491 | 1402 |
/** |
| ... | ... | |
| 1514 | 1425 |
pstmt.close(); |
| 1515 | 1426 |
logMetacat.info("Deleted " + rows + " rows from xml_index " +
|
| 1516 | 1427 |
"for document " + docid); |
| 1428 |
|
|
| 1429 |
// Delete all the entries in xml_queryresult |
|
| 1430 |
pstmt = conn.prepareStatement( |
|
| 1431 |
"DELETE FROM xml_queryresult WHERE docid = ?"); |
|
| 1432 |
pstmt.setString(1, docid); |
|
| 1433 |
rows = pstmt.executeUpdate(); |
|
| 1434 |
conn.increaseUsageCount(1); |
|
| 1435 |
pstmt.close(); |
|
| 1436 |
logMetacat.info("Deleted " + rows + " rows from xml_queryresult " +
|
|
| 1437 |
"for document " + docid); |
|
| 1438 |
|
|
| 1439 |
// Delete all the entries in xml_path_index |
|
| 1440 |
pstmt = conn.prepareStatement( |
|
| 1441 |
"DELETE FROM xml_path_index WHERE docid = ?"); |
|
| 1442 |
pstmt.setString(1, docid); |
|
| 1443 |
rows = pstmt.executeUpdate(); |
|
| 1444 |
conn.increaseUsageCount(1); |
|
| 1445 |
pstmt.close(); |
|
| 1446 |
logMetacat.info("Deleted " + rows + " rows from xml_path_index " +
|
|
| 1447 |
"for document " + docid); |
|
| 1448 |
|
|
| 1517 | 1449 |
} |
| 1518 | 1450 |
|
| 1519 | 1451 |
/** |
| ... | ... | |
| 1541 | 1473 |
// Step through the hashtable and insert each of the path values |
| 1542 | 1474 |
Iterator it = pathList.values().iterator(); |
| 1543 | 1475 |
while (it.hasNext()) {
|
| 1544 |
PathIndexEntry entry = (PathIndexEntry)it.next(); |
|
| 1545 |
logMetacat.debug("Inserting: " + entry.nodeId +
|
|
| 1546 |
" (" + entry.parentId + "): " + entry.path);
|
|
| 1547 |
pstmt.setLong(1, entry.nodeId); |
|
| 1548 |
pstmt.setString(2, entry.path); |
|
| 1549 |
pstmt.setLong(5, entry.parentId); |
|
| 1550 |
pstmt.executeUpdate(); |
|
| 1476 |
PathIndexEntry entry = (PathIndexEntry)it.next(); |
|
| 1477 |
logMetacat.debug("Inserting: " + entry.nodeId +
|
|
| 1478 |
" (" + entry.parentId + "): " + entry.path);
|
|
| 1479 |
pstmt.setLong(1, entry.nodeId); |
|
| 1480 |
pstmt.setString(2, entry.path); |
|
| 1481 |
pstmt.setLong(5, entry.parentId); |
|
| 1482 |
pstmt.executeUpdate(); |
|
| 1483 |
} |
|
| 1484 |
// Close the database statement |
|
| 1485 |
pstmt.close(); |
|
| 1486 |
} |
|
| 1487 |
|
|
| 1488 |
/** |
|
| 1489 |
* Insert the paths from the pathList into the xml_path_index table on the |
|
| 1490 |
* database. |
|
| 1491 |
* |
|
| 1492 |
* @param conn the database connection to use, keeping a single transaction |
|
| 1493 |
* @param pathList the hash of paths to insert |
|
| 1494 |
* @throws SQLException if there is an error inserting into the db |
|
| 1495 |
*/ |
|
| 1496 |
private void updatePathIndex(DBConnection conn, NodeRecord currentNode, Vector pathList) |
|
| 1497 |
throws SQLException {
|
|
| 1498 |
// Create an insert statement to reuse for all of the path |
|
| 1499 |
// insertions |
|
| 1500 |
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO "
|
|
| 1501 |
+ "xml_path_index (docid, path, nodedata, " |
|
| 1502 |
+ "nodedatanumerical, parentnodeid)" |
|
| 1503 |
+ " VALUES (?, ?, ?, ?, ?)"); |
|
| 1504 |
pstmt.setString(1, docid); |
|
| 1505 |
// Step through the hashtable and insert each of the path values |
|
| 1506 |
Iterator it = pathList.iterator(); |
|
| 1507 |
while (it.hasNext()) {
|
|
| 1508 |
String path = (String)it.next(); |
|
| 1509 |
logMetacat.debug("Inserting: "+ path);
|
|
| 1510 |
pstmt.setString(2, path); |
|
| 1511 |
pstmt.setString(3, currentNode.getNodeData()); |
|
| 1512 |
pstmt.setFloat(4, currentNode.getNodeDataNumerical()); |
|
| 1513 |
pstmt.setLong(5, currentNode.getParentNodeId()); |
|
| 1514 |
pstmt.execute(); |
|
| 1551 | 1515 |
} |
| 1552 | 1516 |
// Close the database statement |
| 1553 | 1517 |
pstmt.close(); |
| ... | ... | |
| 1777 | 1741 |
String nodename = null; |
| 1778 | 1742 |
String nodeprefix = null; |
| 1779 | 1743 |
String nodedata = null; |
| 1780 |
String quotechar = dbAdapter.getStringDelimiter();
|
|
| 1744 |
float nodedatanumerical = -1;
|
|
| 1781 | 1745 |
String sql = "SELECT nodeid,parentnodeid,nodeindex, " |
| 1782 |
+ "nodetype,nodename,nodeprefix,nodedata " |
|
| 1746 |
+ "nodetype,nodename,nodeprefix,nodedata,nodedatanumerical "
|
|
| 1783 | 1747 |
+ "FROM xml_nodes WHERE rootnodeid = ?"; |
| 1784 | 1748 |
|
| 1785 | 1749 |
// go through the access control for some nodes |
| ... | ... | |
| 1815 | 1779 |
nodeprefix = rs.getString(6); |
| 1816 | 1780 |
nodedata = rs.getString(7); |
| 1817 | 1781 |
nodedata = MetaCatUtil.normalize(nodedata); |
| 1782 |
nodedatanumerical = rs.getFloat(8); |
|
| 1783 |
|
|
| 1818 | 1784 |
// add the data to the node record list hashtable |
| 1819 | 1785 |
NodeRecord currentRecord = new NodeRecord(nodeid, parentnodeid, |
| 1820 |
nodeindex, nodetype, nodename, nodeprefix, nodedata); |
|
| 1786 |
nodeindex, nodetype, nodename, nodeprefix, nodedata, nodedatanumerical);
|
|
| 1821 | 1787 |
nodeRecordList.add(currentRecord); |
| 1822 | 1788 |
|
| 1823 | 1789 |
// Advance to the next node |
| ... | ... | |
| 1869 | 1835 |
String nodename = null; |
| 1870 | 1836 |
String nodeprefix = null; |
| 1871 | 1837 |
String nodedata = null; |
| 1838 |
float nodedatanumerical = -1; |
|
| 1872 | 1839 |
String quotechar = dbAdapter.getStringDelimiter(); |
| 1873 | 1840 |
String table = "xml_nodes"; |
| 1874 | 1841 |
//System.out.println("in getNodeREcorelist !!!!!!!!!!!for root node id "+rootnodeid);
|
| ... | ... | |
| 1892 | 1859 |
serialNumber = dbconn.getCheckOutSerialNumber(); |
| 1893 | 1860 |
pstmt = dbconn |
| 1894 | 1861 |
.prepareStatement("SELECT nodeid,parentnodeid,nodeindex, "
|
| 1895 |
+ "nodetype,nodename,nodeprefix,nodedata " |
|
| 1862 |
+ "nodetype,nodename,nodeprefix,nodedata, nodedatanumerical "
|
|
| 1896 | 1863 |
+ "FROM " + table + " WHERE rootnodeid = ?"); |
| 1897 | 1864 |
|
| 1898 | 1865 |
// Bind the values to the query |
| ... | ... | |
| 1911 | 1878 |
nodename = rs.getString(5); |
| 1912 | 1879 |
nodeprefix = rs.getString(6); |
| 1913 | 1880 |
nodedata = rs.getString(7); |
| 1914 |
nodedata = MetaCatUtil.normalize(nodedata); |
|
| 1881 |
nodedata = MetaCatUtil.normalize(nodedata); |
|
| 1882 |
nodedatanumerical = rs.getFloat(8); |
|
| 1883 |
|
|
| 1915 | 1884 |
// add the data to the node record list hashtable |
| 1916 | 1885 |
NodeRecord currentRecord = new NodeRecord(nodeid, parentnodeid, |
| 1917 |
nodeindex, nodetype, nodename, nodeprefix, nodedata); |
|
| 1886 |
nodeindex, nodetype, nodename, nodeprefix, nodedata, nodedatanumerical);
|
|
| 1918 | 1887 |
nodeRecordList.add(currentRecord); |
| 1919 | 1888 |
|
| 1920 | 1889 |
// Advance to the next node |
Also available in: Unified diff
1. Modified buildIndex() so that only one connection is used for both indexing nodes and indexing paths.
2. Modified the indexing algo so that indexing of paths is done while nodes are being indexed. Results in a much faster indexing algo
3. Replaced access to NodeRecord.<variable> with NodeRecord.<getVariable>