Metacat

    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);

        }

    }

}