Metacat

            String docIdWithoutRev = DocumentUtil.getDocIdFromAccessionNumber(accnum);

            int userSpecifyRev = DocumentUtil.getRevisionFromAccessionNumber(accnum);

            action = checkRevInXMLDocuments(docIdWithoutRev, userSpecifyRev);

            if (action.equals("UPDATE"))

            {

                //archive the old entry

        {

          ForceReplicationHandler forceReplication = new ForceReplicationHandler(

                accnum, false, notificationServer);

        }

    }

     private static String checkRevInXMLDocuments(String docid, int userSpecifyRev) throws Exception

     {

        String action = null;

        // Revision for this docid in current database

        int revInDataBase =DBUtil.getLatestRevisionInDocumentTable(docid);

        // String to store the revision

//        String rev = null;

                   "written because error happend to find it's local revision");

           throw new Exception (e.getMessage());

         }

                                 localrev.toString());

         // if the rev is in the xml_revision, it throws a exception

	 */

    public void buildIndex() throws McdbException

    {

    	double start = System.currentTimeMillis()/1000;

        TreeSet<NodeRecord> nodeRecordLists = getNodeRecordList(rootnodeid);

        boolean atRootElement = true;

//        String doc = docid;

      double afterPutNode = System.currentTimeMillis()/1000;

      double afterDelete = 0;

        // Opening separate db connection for deleting and writing

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

		}

		double finish = System.currentTimeMillis() / 1000;

		logMetacat.info("The time for inserting is " + (finish - afterDelete));

		// Adds the docid to the spatial data cache

		try {

			if (PropertyService.getProperty("spatial.runSpatialOption").equals("true")) {

				SpatialHarvester spatialHarvester = new SpatialHarvester();

								+ docid);

				spatialHarvester.addToUpdateQue(docid);

				spatialHarvester.destroy();

								+ docid);

			}

		} catch (PropertyNotFoundException pnfe) {

    	double start = System.currentTimeMillis()/1000;

        String familyId = docid;

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

        PreparedStatement pstmt = conn.prepareStatement(sql);

        pstmt.setString(1, familyId);

        int rows = pstmt.executeUpdate();

        pstmt.close();

            "for document " + docid);

        double afterDeleteIndex = System.currentTimeMillis()/1000;

        // Delete all the entries in xml_queryresult

        pstmt = conn.prepareStatement(

                "DELETE FROM xml_queryresult WHERE docid = ?");

        rows = pstmt.executeUpdate();

        conn.increaseUsageCount(1);

        pstmt.close();

                "for document " + docid);

        double afterDeleteQueryResult = System.currentTimeMillis()/1000;

        // Delete all the entries in xml_path_index

        pstmt = conn.prepareStatement(

                "DELETE FROM xml_path_index WHERE docid = ?");

        conn.increaseUsageCount(1);

        pstmt.close();

        double afterDeletePathIndex = System.currentTimeMillis()/1000;

                "for document " + docid);

    }

        Iterator<PathIndexEntry> it = pathList.values().iterator();

        while (it.hasNext()) {

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

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

        	 pstmt.setLong(1, entry.nodeId);

        	 pstmt.setString(2, entry.path);

            throw notFound;

        } catch (Exception e) {

            throw e;

        }

                    this.docHomeServer = MetacatUtil

                            .getLocalReplicationServerName();

                }

            }

            pstmt.close();

                pstmt.close();

            }

        } catch (SQLException e) {

                    + e.getMessage());

            e.printStackTrace(System.out);

        } finally {

            try {

                pstmt.close();

            } catch (SQLException ee) {

            } finally {

                DBConnectionPool.returnDBConnection(dbconn, serialNumber);

            }

            throw notFound;

        } catch (Exception e) {

                    + e.getMessage());

        }

        //System.out.println("in getNodeREcorelist !!!!!!!!!!!3");

                nodedata = rs.getString(7);

                try

                {

                	nodedata = MetacatUtil.normalize(nodedata);

                } catch (java.lang.StringIndexOutOfBoundsException SIO){

                }

                nodedatanumerical = rs.getFloat(8);

            try {

                pstmt.close();

            } catch (SQLException ee) {

                                + ee.getMessage());

            } finally {

                DBConnectionPool.returnDBConnection(dbconn, serialNumber);

            } else if (action.equals("UPDATE")) {

                int thisrev = DBUtil.getLatestRevisionInDocumentTable(docid);

                // Save the old document publicaccessentry in a backup table

                String accNumber = docid+PropertyService.getProperty("document.accNumSeparator")+thisrev;

                thisdoc = new DocumentImpl(accNumber, false);

                DocumentImpl.archiveDocAndNodesRevision(connection, docid, user, thisdoc);

                //if the updated vesion is not greater than current one,

                //throw it into a exception

                if (rev <= thisrev) {

                    //set the user specified revision

                    thisrev = rev;

                }

                boolean useXMLIndex = (new Boolean(PropertyService

                        .getProperty("database.usexmlindex"))).booleanValue();

                if (useXMLIndex) {

                    double start = System.currentTimeMillis()/1000;

                    // Delete index for the old version of docid

                    // The new index is inserting on the next calls to DBSAXNode

                    pstmt.close();

                    double end = System.currentTimeMillis()/1000;

                }

                // Update the new document to reflect the new node tree

    	// Get the xml as a string so we can write to file later

    	String xmlString = StringUtil.readerToString(xml);

                + conn.getUsageCount());

        AccessionNumber ac = new AccessionNumber(accnum, action);

        String docid = ac.getDocid();

        String rev = ac.getRev();

                + serverCode + " override: " + override);

        if ((serverCode != 1 && action.equals("UPDATE")) && !override) {

                     * XMLReader parser = initializeParser(conn, action, docid,

                     * updaterev, validate, user, groups, pub, serverCode, dtd);

                     */

                    parser = initializeParser(conn, action, docid, xml, updaterev,

                            user, groups, pub, serverCode, dtd, ruleBase,

                            needValidation, false, null, null);// false means it is not a revision doc

                                   //null, null are createdate and updatedate

                                   //null will use current time as create date time

                    conn.setAutoCommit(false);

                    parser.parse(new InputSource(xml));

                    conn.commit();

                    conn.setAutoCommit(true);

                    //write the file to disk

                	writeToFileSystem(xmlString, accnum);

                    // write to xml_node complete. start the indexing thread.

                    addDocidToIndexingQueue(docid, rev);

               } catch (Exception e) {

                    conn.rollback();

                    conn.setAutoCommit(true);

                    //if it is a eml2 document, we need delete online data

        String docType = null;

        String docName = null;

        String catalogId = null;

        // Docid without revision

        String docid = DocumentUtil.getDocIdFromAccessionNumber(accnum);

        // Revision specified by user (int)

        int userSpecifyRev = DocumentUtil.getRevisionFromAccessionNumber(accnum);

        // Revision for this docid in current database

        int revInDataBase = DBUtil.getLatestRevisionInDocumentTable(docid);

        // String to store the revision

        String rev = (new Integer(userSpecifyRev)).toString();

        // Get server code again

        serverCode = getServerCode(homeServer);

                        + " into local" + " metacat with servercode: "

                        + serverCode);

            catalogId = dbx.getCatalogId();

        } catch (Exception e) {

            conn.rollback();

            conn.setAutoCommit(true);

            if (parser != null) {

                // we need to delete the nodes in xml_ndoes.

                deleteXMLNodes(conn, rootId);

            }

                    + "rule for package: " + accnum + " because "

                    + ee.getMessage());

                    + "rule for package: " + accnum + " because "

                    + ee.getMessage());

        }

        {

          ForceReplicationHandler forceReplication = new ForceReplicationHandler(

                accnum, action, true, notifyServer);

        }

        // clear cache after inserting or updating a document

                dbconn.rollback();

                dbconn.setAutoCommit(true);

            }

                            + e.getMessage());

            throw e;

        } finally {

    private static String getDocTypeFromDBForCurrentDocument(String accnumber)

            throws SQLException

    {

        String docid = null;

        PreparedStatement pstate = null;

        ResultSet rs = null;

            //handle resultset

            rs = pstate.getResultSet();

            if (rs.next()) {

            }

            rs.close();

            pstate.close();

        }//try

        catch (SQLException e) {

            throw e;

        }//catch

        finally {

            pstate.close();

            DBConnectionPool.returnDBConnection(dbConnection, serialNumber);

        }//

    }

    /**

              isXML = false;

            }

            double start = System.currentTimeMillis()/1000;

            // check for 'write' permission for 'user' to delete this document

            if (!hasAllPermission(user, groups, accnum)) {

            // Copy the record to the xml_revisions table

            DocumentImpl.archiveDocAndNodesRevision(conn, docid, user, null);

            double afterArchiveDocAndNode = System.currentTimeMillis()/1000;

            // Now delete it from the xml_index table

//            boolean useXMLIndex = (new Boolean(PropertyService

//                    .getProperty("database.usexmlindex"))).booleanValue();

            conn.increaseUsageCount(1);

            //}

            double afterDeleteIndex = System.currentTimeMillis()/1000;

            // Now delete it from xml_access table

            pstmt = conn.prepareStatement(

                    "DELETE FROM xml_access WHERE accessfileid = ?");

            pstmt.setString(1, docid);

            pstmt.execute();

            pstmt.close();

            conn.increaseUsageCount(1);

            double afterDeleteXmlAccess1 = System.currentTimeMillis()/1000;

            pstmt = conn.prepareStatement(

                    "DELETE FROM xml_access WHERE docid = ?");

            pstmt.setString(1, docid);

            pstmt.execute();

            pstmt.close();

            conn.increaseUsageCount(1);

            double afterDeleteXmlAccess2 = System.currentTimeMillis()/1000;

            // Delete enteries from xml_queryresult

            pstmt = conn.prepareStatement(

                    "DELETE FROM xml_queryresult WHERE docid = ?");

            pstmt.setString(1, docid);

            pstmt.execute();

            pstmt.close();

            conn.increaseUsageCount(1);

            double afterDeleteQueryResult = System.currentTimeMillis()/1000;

            // Delete it from relation table

            pstmt = conn.prepareStatement(

                    "DELETE FROM xml_relation WHERE docid = ?");

            //increase usage count

            pstmt.setString(1, docid);

            pstmt.execute();

            pstmt.close();

            conn.increaseUsageCount(1);

            double afterXMLRelation = System.currentTimeMillis()/1000;

            		(afterXMLRelation - afterDeleteQueryResult) );

            // Delete it from xml_path_index table

                    "DELETE FROM xml_path_index WHERE docid = ?");

            //increase usage count

            pstmt.setString(1, docid);

            pstmt.execute();

            pstmt.close();

            conn.increaseUsageCount(1);

                    "DELETE FROM xml_accesssubtree WHERE docid = ?");

            //increase usage count

            pstmt.setString(1, docid);

            pstmt.execute();

            pstmt.close();

            conn.increaseUsageCount(1);

            pstmt = conn.prepareStatement(

                    "DELETE FROM xml_documents WHERE docid = ?");

            pstmt.setString(1, docid);

            pstmt.execute();

            pstmt.close();

            //Usaga count increase 1

            conn.increaseUsageCount(1);

            double afterDeleteDoc = System.currentTimeMillis()/1000;

            		(afterDeleteDoc - afterXMLRelation ));

            // Delete the old nodes in xml_nodes table...

                   pstmt = conn.prepareStatement("DELETE FROM xml_nodes "

                   conn.increaseUsageCount(1);

                   // Bind the values to the query and execute it

                   pstmt.setString(1, docid);

                   pstmt.execute();

                   pstmt.close();

            double afterDeleteXMLNodes = System.currentTimeMillis()/1000;

            conn.commit();

            conn.setAutoCommit(true);

            // add force delete replcation document here.

            ForceReplicationHandler frh = new ForceReplicationHandler(

                             accnum, ForceReplicationHandler.DELETE, isXML, notifyServer);

            // clear cache after inserting or updating a document

            if (PropertyService.getProperty("database.queryCacheOn").equals("true"))

            {

         	   DBQuery.clearQueryResultCache();

            }

           double end = System.currentTimeMillis()/1000;

        } catch (Exception e) {

            throw e;

        } finally {

      {

        type = result.getString(1);

      }

                               " is " + type);

      return type;

    }

            String parserName = PropertyService.getProperty("xml.saxparser");

            parser = XMLReaderFactory.createXMLReader(parserName);

            if (ruleBase != null && ruleBase.equals(EML200)) {

                chandler = new Eml200SAXHandler(dbconn, action, docid, rev,

                        user, groups, pub, serverCode, createDate, updateDate);

                chandler.setIsRevisionDoc(isRevision);

                String externalSchemaLocation = null;

//                SchemaLocationResolver resolver = new SchemaLocationResolver();

                externalSchemaLocation = XMLSchemaService.getNameSpaceAndLocationString();

                // Set external schemalocation.

                if (externalSchemaLocation != null

                        && !(externalSchemaLocation.trim()).equals("")) {

                    parser.setProperty(EXTERNALSCHEMALOCATIONPROPERTY,

                            externalSchemaLocation);

                }

            } else if (ruleBase != null && ruleBase.equals(EML210)) {

                chandler = new Eml210SAXHandler(dbconn, action, docid, rev,

                        user, groups, pub, serverCode, createDate, updateDate);

                chandler.setIsRevisionDoc(isRevision);

                // From DB to find the register external schema location

                String externalSchemaLocation = null;

                externalSchemaLocation = XMLSchemaService.getNameSpaceAndLocationString();

                // Set external schemalocation.

                if (externalSchemaLocation != null

                        && !(externalSchemaLocation.trim()).equals("")) {

                    parser.setProperty(EXTERNALSCHEMALOCATIONPROPERTY,

                            externalSchemaLocation);

                }

            } else {

                //create a DBSAXHandler object which has the revision

                // specification

                if (ruleBase != null && ruleBase.equals(SCHEMA)

                        && needValidation) {

                    // turn on schema validation feature

                    parser.setFeature(VALIDATIONFEATURE, true);

                    parser.setFeature(NAMESPACEFEATURE, true);

                    // From DB to find the register external schema location

                    String externalSchemaLocation = null;

                    externalSchemaLocation = XMLSchemaService.getNameSpaceAndLocationString();

                    // Set external schemalocation.

                    if (externalSchemaLocation != null

                            && !(externalSchemaLocation.trim()).equals("")) {

                } else if (ruleBase != null && ruleBase.equals(DTD)

                        && needValidation) {

                    // turn on dtd validaton feature

                    parser.setFeature(VALIDATIONFEATURE, true);

                    eresolver = new DBEntityResolver(dbconn,

                    parser.setEntityResolver((EntityResolver) eresolver);

                    parser.setDTDHandler((DTDHandler) dtdhandler);

                } else {

                    // non validation

                    parser.setFeature(VALIDATIONFEATURE, false);

                    eresolver = new DBEntityResolver(dbconn,

        }catch (Exception e) {

            logMetacat.error(

                            + e.getMessage());

        }

        pstmt.execute();

        pstmt.close();

        double end = System.currentTimeMillis()/1000;

      } catch (SQLException e) {

                        + e.getMessage());

        throw e;

      } catch (Exception e) {

                        + e.getMessage());

        throw e;

      }

            pstmt.close();

        } catch (SQLException ee) {

            logMetacat.error(

                            + ee.getMessage());

        }

      }

    private static void moveNodesToNodesRevision(DBConnection dbconn,

                                       long rootNodeId) throws Exception

    {

                " will be moved from xml_nodes to xml_node_revision table");

        PreparedStatement pstmt = null;

        double start = System.currentTimeMillis()/1000;

        pstmt.execute();

        pstmt.close();

        double end = System.currentTimeMillis()/1000;

    }

            pstmt.close();

        } catch (SQLException e) {

            logMetacat.error(

                            + e.getMessage());

            throw e;

        } finally {

                pstmt.close();

            } catch (SQLException ee) {

                logMetacat.error(

                                + ee.getMessage());

                throw ee;

            } 

            try {

                pStmt.close();

            } catch (SQLException e) {

                                + e.getMessage());

            } finally {

                //return back DBconnection

                pStmt.close();

            }//try

            catch (Exception ee) {

                                + ee.getMessage());

            }//catch

            finally {

                pStmt.close();

            }

        } catch (Exception e) {

                    + e.getMessage());

        } finally {

            try {

                pStmt.close();

            } catch (Exception ee) {

                                + ee.getMessage());

            } finally {

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

            }

        }//try

        catch (Exception e) {

                            + e.getMessage());

        }//catch

        finally {

            }//try

            catch (Exception ee) {

                                + ee.getMessage());

            }//catch

            finally {

            if (action.equals("READ")) {

                DocumentImpl xmldoc = new DocumentImpl(docid);

                if (useOldReadAlgorithm) {

                } else {

                    xmldoc.toXml(new PrintWriter(System.out), null, null, true);

                }

            double insertTime = (stopTime - connTime) / 1000;

            double executionTime = (stopTime - startTime) / 1000;

            if (showRuntime) {

                        + executionTime + " seconds.");

                        + dbOpenTime + " seconds.");

                        + " seconds.");

            }

            dbconn.close();

            {

                createDate = DatabaseService.getDBAdapter().toDate(createDate, "YYYY-MM-DD HH24:MI:SS");

            }

            if (updateDate == null)

            {

                updateDate = DatabaseService.getDBAdapter().getDateTimeFunction();

            {

                updateDate = DatabaseService.getDBAdapter().toDate(updateDate, "YYYY-MM-DD HH24:MI:SS");

            }

            PreparedStatement pstmt = null;

            String sql = null;

            if (rootNodeId <= 0)

            {

            	// this is for data file, not rootnodeid need

            // Bind the values to the query

            pstmt.setString(1, docId);

            pstmt.setString(2, docName);

            pstmt.setString(3, docType);

            pstmt.setString(4, user);

            pstmt.setString(5, user);

            pstmt.setInt(6, 0);

            pstmt.setInt(7, serverCode);

            pstmt.setInt(8, Integer.parseInt(rev));

            if (rootNodeId >0 )

            {

              if (catalogid != null)

              {

                pstmt.setInt(9, (new Integer(catalogid)).intValue());

                pstmt.setLong(10, rootNodeId);

              }

              else

              {

                 pstmt.setLong(9, rootNodeId);

              }

            }

            // Do the insertion

            pstmt.execute();

            pstmt.close();

        } 

        catch (SQLException sqle) 

        pstmt.execute();

        pstmt.close(); 

        double end = System.currentTimeMillis()/1000;

    }

}