Metacat

import java.sql.Statement;

import org.xml.sax.SAXException;

     *

     * @throws McdbException on error getting the node records for the document

        // Opening separate db connection for deleting and writing 

        // XML Index -- be sure that it is all in one db transaction

        int serialNumber = -1;

        DBConnection dbConn = null;

        try {

            dbConn = DBConnectionPool.getDBConnection(

                "DocumentImpl.buildIndex");

            serialNumber = dbConn.getCheckOutSerialNumber();

            dbConn.setAutoCommit(false);

            //make sure record is done

            //checkDocumentTable();

            // Delete the previous index entries for this document

            deleteNodeIndex(dbConn);

            // Step through all of the node records we were given

            // and build the new index and update the database

            it = nodeRecordLists.iterator();

            while (it.hasNext()) {

                NodeRecord currentNode = (NodeRecord) it.next();

                HashMap pathList = new HashMap();

                if (currentNode.nodetype.equals("ELEMENT") ||

                    currentNode.nodetype.equals("ATTRIBUTE") ) {

                    System.err.println("\nStarting Node: " + 

                        currentNode.getNodeId() + " (" + 

                        currentNode.getParentNodeId() + "): " + 

                        currentNode.getNodeName() + " (" +

                        currentNode.getNodeType() + ")");

                    if (atRootElement) {

                        rootNodeId = currentNode.getNodeId();

                        atRootElement = false;

                    }

                    traverseParents(nodeRecordMap, rootNodeId, 

                            currentNode.getNodeId(),

                            currentNode.getNodeId(), "", pathList);

                    updateNodeIndex(dbConn, pathList);

            dbConn.commit();

        } catch (SQLException e) {

            MetaCatUtil.debugMessage(

                "SQL Exception while inserting path index in " +

                "DocumentImpl.buildIndex for document " + docid, 10);

      		MetaCatUtil.debugMessage(e.getMessage(), 10);

            e.printStackTrace();

            try {

                dbConn.rollback();

            } catch (SQLException sqle) {

            	MetaCatUtil.debugMessage(

					"Error while rolling back commit in DocumentImpl.buildIndex"

                    + "\n" + sqle.getMessage(), 10);

            }

        } finally {

			DBConnectionPool.returnDBConnection(dbConn, serialNumber);

     * @param leafNodeId the id of the leafNode being processed

     * @param pathList the hash to which paths are added

    private void traverseParents(HashMap records, long rootNodeId, 

            long leafNodeId, long id, 

            String children, HashMap pathList) {

        Long nodeId = new Long(id);

        NodeRecord current = (NodeRecord)records.get(nodeId);

        long parentId = current.getParentNodeId();

                pathList.put(currentName, new PathIndexEntry(

                    leafNodeId, currentName, docid, doctype, parentId));

                traverseParents(records, rootNodeId, leafNodeId,

                    parentId, currentName, pathList);

            String path = current.getNodeName() + children;

                System.err.print("B: " + path +"\n");

                pathList.put(path, new PathIndexEntry(leafNodeId, path, docid, 

                    doctype, parentId));

                String fullPath = '/' + path;

                System.err.print("C: " + fullPath +"\n");

                pathList.put(fullPath, new PathIndexEntry(leafNodeId, fullPath,

                    docid, doctype, parentId));

    /**

     * Delete the paths from the xml_index table on the database in preparation 

     * of a subsequent update.

     *

     * @param conn the database connection to use, keeping a single transaction

     * @throws SQLException if there is an error deleting from the db

     */

    public void deleteNodeIndex(DBConnection conn) throws SQLException

    {

        String familyId = MetaCatUtil.getDocIdFromString(docid);

        String sql = "DELETE FROM xml_index WHERE docid LIKE ?";

        MetaCatUtil.debugMessage(sql, 55);

        System.err.println("SQL is: " + sql);

        PreparedStatement pstmt = conn.prepareStatement(sql);

        // Increase usage count for the connection

        conn.increaseUsageCount(1);

        // Execute the delete and close the statement

        pstmt.setString(1, familyId);

        int rows = pstmt.executeUpdate();

        pstmt.close();

        MetaCatUtil.debugMessage("Deleted " + rows + " rows from xml_index " +

            "for document " + docid, 55);

    }

    /**

	 * Insert the paths from the pathList into the xml_index table on the

     * database.

     *

     * @param conn the database connection to use, keeping a single transaction

     * @param pathList the hash of paths to insert

     * @throws SQLException if there is an error inserting into the db

     */

    private void updateNodeIndex(DBConnection conn, HashMap pathList) 

    	throws SQLException

    {

        // Create an insert statement to reuse for all of the path

        // insertions

        PreparedStatement pstmt = conn.prepareStatement(

                "INSERT INTO xml_index (nodeid, path, docid, doctype, " +

                "parentnodeid) " + "VALUES (?, ?, ?, ?, ?)");

        // Increase usage count for the connection

        conn.increaseUsageCount(1);

        String familyId = MetaCatUtil.getDocIdFromString(docid);

        pstmt.setString(3, familyId);

        pstmt.setString(4, doctype);

        // Step through the hashtable and insert each of the path values

        Iterator it = pathList.values().iterator();

        while (it.hasNext()) {

            PathIndexEntry entry = (PathIndexEntry)it.next();

            System.err.println("Inserting: " + entry.nodeId +

                " (" + entry.parentId + "): " + entry.path);

            pstmt.setLong(1, entry.nodeId);

            pstmt.setString(2, entry.path);

            pstmt.setLong(5, entry.parentId);

            pstmt.executeUpdate();

        }

        // Close the database statement

        pstmt.close();

    }

/**

 *  '$RCSfile$'

 *  Copyright: 2004 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat;

/**

 * PathIndexEntry contains all of the data fields needed to insert an path into

 * the xml_index table.

 * 

 * @author jones

 */

public class PathIndexEntry

{

    protected long nodeId;

    protected String path;

    protected String docid; 

    protected String docType;

    protected long parentId;

    /**

     * Construct a new PathIndexEntry.

     * 

     * @param nodeId the node identifier

     * @param path the path in the xml document

     * @param docid the document identifier

     * @param docType the document type

     * @param parentId the identifier of the parent node

     */

    public PathIndexEntry(long nodeId, String path, String docid, 

            String docType, long parentId)

    {

        this.nodeId = nodeId;

        this.path = path;

        this.docid = docid;

        this.docType = docType;

        this.parentId = parentId;

    }

}