Metacat

    // create xml document

    try

    {

      xmlString = xmlDoc.toString();

      // create dom tree

      read = new StringReader(xmlString);

      in = new InputSource(read);

    String xmlDoc = null;

    try

    {

      xmlDoc = doc.toString();

    }

    catch (Exception e)

    {

    static final int READ = 4;

    protected static final AbstractDatabase dbAdapter = MetaCatUtil.dbAdapter;

    protected DBConnection connection = null;

    protected String docname = null;

    protected String doctype = null;

    private String validateType = null; //base on dtd or schema

    private String system_id = null;

    private String userowner = null;

    private String userupdated = null;

    private int rev;

    private int serverlocation;

    private String docHomeServer;

     * @param conn

     *            the database connection from which to read the document

     * @param docid

     * @param readNodes

     *            flag indicating whether the xmlnodes should be read

     */

    {

        try {

            //this.conn = conn;

            // Look up the document information

            if (readNodes) {

                // Download all of the document nodes using a single SQL query

        this.docname = docName;

        this.doctype = docType;

        this.docid = docId;

        writeDocumentToDB(action, user, pub, catalogId, serverCode, createDate, updateDate);

    }

      DBConnection dbconn = null;

      PreparedStatement pstmt = null;

      int serialNumber = -1;

      String sqlDateString = dbAdapter.getDateTimeFunction();

      if (createDate == null)

      {

            sql.append(doctype).append("','");

            sql.append(user).append("','");

            sql.append(user).append("','");

            sql.append(createDate).append(",");

            sql.append(updateDate).append(",");

            sql.append("'0')");

            sql.append(user).append("', ");

            sql.append("server_location='");

            sql.append(serverCode).append("',");

            sql.append("date_updated=");

            sql.append(updateDate);

            sql.append(" where docid='");

        String action = null;

        MetaCatUtil.debugMessage("The user specifyRev: " + userSpecifyRev, 30);

        // Revision for this docid in current database

        MetaCatUtil.debugMessage("The rev in data base: " + revInDataBase, 30);

        // String to store the revision

        String rev = null;

            nodeRecordMap.put(nodeId, currentNode);

        }

            doc = new DocumentIdentifier(docid);

        } catch (AccessionNumberException e){

            MetaCatUtil.debugMessage("AccessionNumber Exception while "

                                     + "in DocumentImpl.buildIndex for "

                                     + "document " + docid, 10);

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

        // Opening separate db connection for deleting and writing

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

            // Delete all the entries in xml_queryresult

            PreparedStatement pstmt = dbConn.prepareStatement(

                    "DELETE FROM xml_queryresult WHERE docid = ?");

            pstmt.execute();

            pstmt.close();

            dbConn.increaseUsageCount(1);

            // Delete all the entries in xml_queryresult

            pstmt = dbConn.prepareStatement(

                    "DELETE FROM xml_path_index WHERE docid = ?");

            pstmt.execute();

            pstmt.close();

            dbConn.increaseUsageCount(1);

            // 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") ||

                                            + " ) AND n.parentnodeid=i.nodeid AND"

                                            + " n.nodetype LIKE 'TEXT' and n.docid = ?");

            pstmt.execute();

            rs = pstmt.getResultSet();

            int count = 0;

            while (rs.next()) {

                String docid = rs.getString(1);

                String nodedata = rs.getString(2);

                float nodedatanumerical = rs.getFloat(3);

     */

    private void deleteNodeIndex(DBConnection conn) throws SQLException

    {

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

        MetaCatUtil.debugMessage(sql, 55);

        MetaCatUtil.debugMessage("SQL is: " + sql, 60);

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

        // Increase usage count for the connection

        conn.increaseUsageCount(1);

        pstmt.setString(3, familyId);

        pstmt.setString(4, doctype);

        pstmt.close();

    }

    {

        DBConnection dbconn = null;

        int serialNumber = -1;

        PreparedStatement pstmt = null;

        try {

            dbconn = DBConnectionPool

            pstmt.execute();

            ResultSet rs = pstmt.getResultSet();

            boolean tablehasrows = rs.next();

            if (tablehasrows) {

                int r = rs.getInt(1);

                pstmt.close();

                                                        // in in xml_documents

                    //System.out.println("returning false");

                    return false;

                                                              // revision is in

                                                              // xml_revisions.

                    //System.out.println("returning true");

                    return true;

                                                              // cannot be

                                                              // greater than r

                throw new Exception(

                        "requested revision cannot be greater than "

                                + "the latest revision number."); }

            }

            // Get miss docid and rev, throw to McdDocNotFoundException

            throw new McdbDocNotFoundException("the requested docid '"

                    + docid.toString() + "' does not exist", missDocId,

                    missRevision);

        }//finally

    }

            AccessionNumberException, Exception

    {

        getDocumentInfo(new DocumentIdentifier(docid));

    /**

     * Look up the document type information from the database

     * @param docid

     *            the id of the document to look up

     */

            throws McdbException, Exception

    {

        DBConnection dbconn = null;

        String table = "xml_documents";

        try {

                                         // instead of from xml_documents;

                table = "xml_revisions";

            }

            sql.append("date_created, date_updated, user_owner, user_updated,");

            sql.append(" server_location, public_access, rev");

            sql.append(" FROM ").append(table);

            pstmt = dbconn.prepareStatement(sql.toString());

                pstmt.close();

            }

        } catch (SQLException e) {

            e.printStackTrace(System.out);

            throw new McdbException("Error accessing database connection in "

                    + "DocumentImpl.getDocumentInfo: ", e);

        if (this.docname == null) {

            throw new McdbDocNotFoundException(

        }

    }

        String nodedata = null;

        String quotechar = dbAdapter.getStringDelimiter();

        String table = "xml_nodes";

        try {

                // instead of from xml_documents;

                table = "xml_nodes_revisions";

            }

        }  catch (McdbDocNotFoundException notFound) {

            throw notFound;

            MetaCatUtil.debugMessage("error in DocumentImpl.getDocumentInfo: "

                    + e.getMessage(), 30);

        }

        try {

            dbconn = DBConnectionPool

                    .getDBConnection("DocumentImpl.getNodeRecordList");

            // Bind the values to the query

            pstmt.setLong(1, rootnodeid);

            pstmt.execute();

            ResultSet rs = pstmt.getResultSet();

            boolean tableHasRows = rs.next();

            while (tableHasRows) {

                nodeid = rs.getLong(1);

                parentnodeid = rs.getLong(2);

                nodeindex = rs.getLong(3);

                tableHasRows = rs.next();

            }

            pstmt.close();

        } catch (SQLException e) {

            throw new McdbException("Error in DocumentImpl.getNodeRecordList "

                DBConnectionPool.returnDBConnection(dbconn, serialNumber);

            }

        }

        return nodeRecordList;

    }

    private void writeDocumentToDB(String action, String user, String pub,

            String catalogid, int serverCode, String createDate, String updateDate) throws SQLException, Exception

    {

        String sysdate = dbAdapter.getDateTimeFunction();

        if (createDate == null)

        {

                 */

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

                pstmt.setInt(9, serverCode);

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

                // Save the old document publicaccessentry in a backup table

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

                MetaCatUtil.debugMessage("after archiveDoc", 30);

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

                //throw it into a exception

                    throw new Exception("Next revision number couldn't be less"

                            + " than or equal " + thisrev);

                } else {

                    //set the user specified revision

                }

                MetaCatUtil.debugMessage("final revsion is: " + thisrev, 40);

                boolean useXMLIndex = (new Boolean(MetaCatUtil

                    + accnum);

            }

            String server = MetacatReplication

                    .getServerNameForServerCode(serverCode);

            MetacatReplication.replLog("attempting to lock " + accnum);

            conn.setAutoCommit(false);

            parser.parse(new InputSource(xml));

            conn.commit();

            conn.setAutoCommit(true);

        }

        // run access db base on relation table and access object

        runRelationAndAccessHandler(accnum, user, groups, serverCode);

        // Delete enteries from xml_queryresult for given docid if

        int userSpecifyRev = MetaCatUtil.getRevisionFromAccessionNumber(accnum);

        MetaCatUtil.debugMessage("The user specifyRev: " + userSpecifyRev, 30);

        // Revision for this docid in current database

        MetaCatUtil.debugMessage("The rev in data base: " + revInDataBase, 30);

        // String to store the revision

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

            conn.commit();

            conn.setAutoCommit(true);

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

            // this only for xml_documents

            DBSAXHandler dbx = (DBSAXHandler) parser.getContentHandler();

        } catch (Exception ee) {

        	conn.rollback();

            conn.setAutoCommit(true);

            MetacatReplication.replErrorLog("Failed to " + "create access "

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

                    + ee.getMessage());

            Vector packagedoctypes = new Vector();

            packagedoctypes = MetaCatUtil.getOptionList(packagedoctype);

            String docIdWithoutRev = MetaCatUtil.getDocIdFromString(accnumber);

            if (documenttype != null &&

                    packagedoctypes.contains(documenttype)) {

                dbconn = DBConnectionPool.getDBConnection(

                String aclid = RelationHandler.getAccessFileID(docIdWithoutRev);

                // if there are access file, write ACL for that package

                if (aclid != null) {

                            servercode);

                }

                dbconn.commit();

                serialNumber = dbconn.getCheckOutSerialNumber();

                dbconn.setAutoCommit(false);

                // write ACL for the package

                        servercode);

                dbconn.commit();

                dbconn.setAutoCommit(true);

    // It runs in xmlIndex thread. It writes ACL for a package.

    private static void runAccessControlList(DBConnection conn, String aclid,

    {

        // read the access file from xml_nodes

        // parse the access file and store the access info into xml_access

                group, servercode);

    }

        try {

            if (doc == null) {

            }

            long rootNodeId = doc.getRootNodeID();

        }

    }

    /**

     * Get server location form database for a accNum

     *

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

                DocumentImpl xmldoc = new DocumentImpl(docid);

                if (useOldReadAlgorithm) {

                } else {

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

                }

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

                DocumentImpl.delete(docid, null, null,null);

            } else {

                /*

                 * String newdocid = DocumentImpl.write(dbconn, filename, null,

            double insertTime = (stopTime - connTime) / 1000;

            double executionTime = (stopTime - startTime) / 1000;

            if (showRuntime) {

            }

            dbconn.close();

        } catch (McdbException me) {

            me.toXml(new PrintWriter(System.err));

        } catch (AccessionNumberException ane) {

        } catch (Exception e) {

            System.err.println("EXCEPTION HANDLING REQUIRED");

            System.err.println(e.getMessage());

            DBConnectionPool.returnDBConnection(dbconn, serialNumber);

        }

    }

}

  /* Handle replicate single xml document*/

  private void handleSingleXMLDocument(String remoteserver, String actions,

               throws Exception

  {

    DBConnection dbConn = null;

      serialNumber=dbConn.getCheckOutSerialNumber();

      //if the document needs to be updated or inserted, this is executed

      String readDocURLString = "https://" + remoteserver + "?server="+

      readDocURLString = MetaCatUtil.replaceWhiteSpaceForURL(readDocURLString);

      URL u = new URL(readDocURLString);

      XMLReader docinfoParser = initParser(dih);

      String docInfoURLStr = "https://" + remoteserver +

                       "?server="+util.getLocalReplicationServerName()+

      docInfoURLStr = MetaCatUtil.replaceWhiteSpaceForURL(docInfoURLStr);

      URL docinfoUrl = new URL(docInfoURLStr);

      MetaCatUtil.debugMessage("Sending message: " +

      String createdDate = (String)docinfoHash.get("date_created");

      String updatedDate = (String)docinfoHash.get("date_updated");

      //docid should include rev number too

      String docType = (String)docinfoHash.get("doctype");

      MetaCatUtil.debugMessage("doctype in repl: "+docType, 45);

                              (String)docinfoHash.get("public_access"),

                              null,  /* the dtd text */

                              actions,

                              (String)docinfoHash.get("user_owner"),

                              null, /* null for groups[] */

                              docHomeServer,

                              remoteserver, tableName, true,// true is for time replication 

                              createdDate,

                              updatedDate);

                                         remoteserver);

    }//try

    catch(Exception e)

    {

                                      " into db because " +e.getMessage());

                                      " into db because " +e.getMessage(), 30);

      throw e;

    }

  /* Handle replicate single xml document*/

  private void handleSingleDataFile(String remoteserver, String actions,

               throws Exception

  {

    DBConnection dbConn = null;

    int serialNumber = -1;

    try

      XMLReader docinfoParser = initParser(dih);

      String docInfoURLString = "https://" + remoteserver +

                  "?server="+util.getLocalReplicationServerName()+

      docInfoURLString = MetaCatUtil.replaceWhiteSpaceForURL(docInfoURLString);

      URL docinfoUrl = new URL(docInfoURLString);

      String createdDate = (String)docinfoHash.get("date_created");

      String updatedDate = (String)docinfoHash.get("date_updated");

      //docid should include rev number too

      String datafilePath = util.getOption("datafilepath");

      // Get data file content

      String readDataURLString = "https://" + remoteserver + "?server="+

                                        util.getLocalReplicationServerName()+

      readDataURLString = MetaCatUtil.replaceWhiteSpaceForURL(readDataURLString);

      URL u = new URL(readDataURLString);

      InputStream input = u.openStream();

        DocumentImpl.writeDataFileInReplication(input,

                                                datafilePath,

                                                docName,docType,

                                                docHomeServer,

                                                remoteserver,

                                                tableName,

                                                createdDate,

                                                updatedDate);

                                    remoteserver);

      }//if

      else

      {

      }//else

    }//try

    catch(Exception e)

    {

                                      " because " +e.getMessage());

                                      " because " +e.getMessage(), 30);

      throw e;

    }

       boolean flag = false;

       try

       {

       }

       catch (SQLException e)

       {

           flag = true;

         }

       }

       // this is non-data file

       if(flag && !dataFile)

       {

         try

         {

         }

         catch(Exception e)

         {

       {

         try

         {

         }

         catch(Exception e)

         {

                                        throws Exception

   {

       // compare the update rev and local rev to see what need happen

       Vector localrev = null;

       String action = "INSERT";

       boolean flag = false;

       {

           flag = true;    

       }

       // this is non-data file

       if(flag && !dataFile)

       {

         try

         {

         }

         catch(Exception e)

         {

       {

         try

         {

         }

         catch(Exception e)

         {

      return list;

  }//getLatestRevisionNumber

}

                    // xmldoc = new DocumentImpl(dbconn, packageDocid);

                    //  thus use the following to get the doc info only

                    //  xmldoc = new DocumentImpl(dbconn);

                    if (xmldoc == null)

                    {

                       MetaCatUtil.debugMessage("Document was null for: "

     *

     * @param dataPackageDocid, the string in docId field of xml_relation table

     */

    {

        Vector docIdList = new Vector();//return value

        String xml = null;

        // Check the parameter

        try {

            //initial a documentImpl object

            //transfer to documentImpl object to string

            xml = packageDocument.toString();

    /**

     * put a data packadge into a zip output stream

     *

     * @param out, a servletoutput stream which the zip output stream will be

     *            put

     * @param user, the username of the user

                throw e;

            }

            //checking if the user has the permission to read the documents

            if (DocumentImpl.hasReadPermission(user, groups, docImpls

                    .getDocID())) {

      throw new Exception ("Couldn't find a dataset docid for the required id");

    }

    // Create a documentImpl object

    // get the replication home server (it come from xml_replication table)

    replicationDocHomeServer = document.getDocHomeServer();

   * @param serverCode the serverid from xml_replication on which this document

   *        resides.

   */

                           String user, String[] groups, int serverCode)

                  throws SAXException, IOException, McdbException

  {

    this.serverCode = serverCode;

    // read the access file from db connection

    String acl = acldoc.toString();

    this.rev = acldoc.getRev();

          for (int i=0; i < aclObjects.size(); i++) {

            // docid of the current object

            String docid = (String)aclObjects.elementAt(i); 

            insertPermissions(docid,leavingTagName);

          }

      ResultSet rs = pstmt.getResultSet();

      boolean hasRows = rs.next();

      while (hasRows) {

        hasRows = rs.next();

      }//whil

    }