Metacat

/**

 *  '$RCSfile$'

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

 *             National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: jones $'

 *     '$Date: 2010-02-03 17:58:12 -0900 (Wed, 03 Feb 2010) $'

 * '$Revision: 5211 $'

 *

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

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Timestamp;

import java.util.ArrayList;

import java.util.Date;

import java.util.Hashtable;

import java.util.List;

import java.util.Vector;

import org.apache.log4j.Logger;

import org.dataone.service.types.AccessPolicy;

import org.dataone.service.types.AccessRule;

import org.dataone.service.types.Checksum;

import org.dataone.service.types.ChecksumAlgorithm;

import org.dataone.service.types.Identifier;

import org.dataone.service.types.NodeReference;

import org.dataone.service.types.ObjectFormat;

import org.dataone.service.types.ObjectInfo;

import org.dataone.service.types.ObjectList;

import org.dataone.service.types.Permission;

import org.dataone.service.types.Replica;

import org.dataone.service.types.ReplicationPolicy;

import org.dataone.service.types.ReplicationStatus;

import org.dataone.service.types.Subject;

import org.dataone.service.types.SystemMetadata;

import edu.ucsb.nceas.metacat.accesscontrol.AccessControlInterface;

import edu.ucsb.nceas.metacat.accesscontrol.XMLAccessAccess;

import edu.ucsb.nceas.metacat.accesscontrol.XMLAccessDAO;

import edu.ucsb.nceas.metacat.database.DBConnection;

import edu.ucsb.nceas.metacat.database.DBConnectionPool;

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.metacat.shared.AccessException;

import edu.ucsb.nceas.metacat.util.DocumentUtil;

/**

 * Manage the relationship between Metacat local identifiers (LocalIDs) that are

 * codified as the (docid, rev) pair with globally unique string identifiers

 * (GUIDs) that are opaque strings.  This class provides methods to manage these

 * identifiers, and to search for and look up LocalIDs based on their GUID and

 * vice versa. IdentifierManager is a singleton.

 * 

 * @author Matthew Jones

 */

public class IdentifierManager {

    public static final String TYPE_SYSTEM_METADATA = "systemmetadata";

    public static final String TYPE_IDENTIFIER = "identifier";

    /**

     * The single instance of the manager that is always returned.

     */

    private static IdentifierManager self = null;

    private Logger logMetacat = Logger.getLogger(IdentifierManager.class);

    /**

     * A private constructor that initializes the class when getInstance() is

     * called.

     */

    private IdentifierManager() {}

    /**

     * Return the single instance of the manager after initializing it if it

     * wasn't previously initialized.

     * 

     * @return the single IdentifierManager instance

     */

    public static IdentifierManager getInstance()

    {

        if (self == null) {

            self = new IdentifierManager();

        }

        return self;

    }

    public SystemMetadata asSystemMetadata(Date dateUploaded, String rightsHolder,

            String checksum, String checksumAlgorithm, String originMemberNode,

            String authoritativeMemberNode, Date dateModified, String submitter, 

            String guid, String objectFormat, long size) {

        SystemMetadata sysMeta = new SystemMetadata();

        Identifier sysMetaId = new Identifier();

        sysMetaId.setValue(guid);

        sysMeta.setIdentifier(sysMetaId);

        sysMeta.setDateUploaded(dateUploaded);

        Subject rightsHolderSubject = new Subject();

        rightsHolderSubject.setValue(rightsHolder);

        sysMeta.setRightsHolder(rightsHolderSubject);

        Checksum checksumObject = new Checksum();

        checksumObject.setValue(checksum);

        checksumObject.setAlgorithm(ChecksumAlgorithm.convert(checksumAlgorithm));

        sysMeta.setChecksum(checksumObject);

        NodeReference omn = new NodeReference();

        omn.setValue(originMemberNode);

        sysMeta.setOriginMemberNode(omn);

        NodeReference amn = new NodeReference();

        amn.setValue(authoritativeMemberNode);

        sysMeta.setAuthoritativeMemberNode(amn);

        sysMeta.setDateSysMetadataModified(dateModified);

        Subject submitterSubject = new Subject();

        submitterSubject.setValue(submitter);

        sysMeta.setSubmitter(submitterSubject);

        sysMeta.setObjectFormat(ObjectFormat.convert(objectFormat));

        sysMeta.setSize(size);

        return sysMeta;

    }

    /**

     * return a hash of all of the info that is in the systemmetadata table

     * @param localId

     * @return

     */

    public Hashtable<String, String> getSystemMetadataInfo(String localId)

    throws McdbDocNotFoundException

    {

        try

        {

            AccessionNumber acc = new AccessionNumber(localId, "NONE");

            localId = acc.getDocid();

        }

        catch(Exception e)

        {

            //do nothing. just try the localId as it is

        }

        Hashtable<String, String> h = new Hashtable<String, String>();

        String sql = "select guid, date_uploaded, rights_holder, checksum, checksum_algorithm, " +

          "origin_member_node, authoritive_member_node, date_modified, submitter, object_format, size " +

          "from systemmetadata where docid = ?";

        DBConnection dbConn = null;

        int serialNumber = -1;

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getDocumentInfo");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            stmt.setString(1, localId);

            ResultSet rs = stmt.executeQuery();

            if (rs.next()) 

            {

                String guid = rs.getString(1);

                Timestamp dateUploaded = rs.getTimestamp(2);

                String rightsHolder = rs.getString(3);

                String checksum = rs.getString(4);

                String checksumAlgorithm = rs.getString(5);

                String originMemberNode = rs.getString(6);

                String authoritativeMemberNode = rs.getString(7);

                Timestamp dateModified = rs.getTimestamp(8);

                String submitter = rs.getString(9);

                String objectFormat = rs.getString(10);

                long size = new Long(rs.getString(11)).longValue();

                h.put("guid", guid);

                h.put("date_uploaded", new Long(dateUploaded.getTime()).toString());

                h.put("rights_holder", rightsHolder);

                h.put("checksum", checksum);

                h.put("checksum_algorithm", checksumAlgorithm);

                h.put("origin_member_node", originMemberNode);

                h.put("authoritative_member_node", authoritativeMemberNode);

                h.put("date_modified", new Long(dateModified.getTime()).toString());

                h.put("submitter", submitter);

                h.put("object_format", objectFormat);

                h.put("size", new Long(size).toString());

                stmt.close();

            } 

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

                throw new McdbDocNotFoundException("2Could not find document " + localId);

            }

        } 

        catch (SQLException e) 

        {

            e.printStackTrace();

            logMetacat.error("Error while getting system metadata info for localid " + localId + " : "  

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return h;

    }

    /**

     * return a hash of all of the info that is in the systemmetadata table

     * @param guid

     * @return

     * @throws McdbDocNotFoundException 

     */

    public SystemMetadata getSystemMetadata(String guid)

    	throws McdbDocNotFoundException

    {

        SystemMetadata sysMeta = new SystemMetadata();

        String sql = "select guid, date_uploaded, rights_holder, checksum, checksum_algorithm, " +

          "origin_member_node, authoritive_member_node, date_modified, submitter, object_format, size " +

          "from systemmetadata where guid = ?";

        DBConnection dbConn = null;

        int serialNumber = -1;

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getSystemMetadata");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            stmt.setString(1, guid);

            ResultSet rs = stmt.executeQuery();

            if (rs.next()) 

            {

                Timestamp dateUploaded = rs.getTimestamp(2);

                String rightsHolder = rs.getString(3);

                String checksum = rs.getString(4);

                String checksumAlgorithm = rs.getString(5);

                String originMemberNode = rs.getString(6);

                String authoritativeMemberNode = rs.getString(7);

                Timestamp dateModified = rs.getTimestamp(8);

                String submitter = rs.getString(9);

                String objectFormat = rs.getString(10);

                long size = new Long(rs.getString(11)).longValue();

                Identifier sysMetaId = new Identifier();

                sysMetaId.setValue(guid);

                sysMeta.setIdentifier(sysMetaId);

                sysMeta.setDateUploaded(dateUploaded);

                Subject rightsHolderSubject = new Subject();

                rightsHolderSubject.setValue(rightsHolder);

                sysMeta.setRightsHolder(rightsHolderSubject);

                Checksum checksumObject = new Checksum();

                checksumObject.setValue(checksum);

                checksumObject.setAlgorithm(ChecksumAlgorithm.convert(checksumAlgorithm));

                sysMeta.setChecksum(checksumObject);

                NodeReference omn = new NodeReference();

                omn.setValue(originMemberNode);

                sysMeta.setOriginMemberNode(omn);

                NodeReference amn = new NodeReference();

                amn.setValue(authoritativeMemberNode);

                sysMeta.setAuthoritativeMemberNode(amn);

                sysMeta.setDateSysMetadataModified(dateModified);

                Subject submitterSubject = new Subject();

                submitterSubject.setValue(submitter);

                sysMeta.setSubmitter(submitterSubject);

                sysMeta.setObjectFormat(ObjectFormat.convert(objectFormat));

                sysMeta.setSize(size);

                stmt.close();

            } 

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

                throw new McdbDocNotFoundException("Could not find " + guid);

            }

        } 

        catch (SQLException e) 

        {

            e.printStackTrace();

            logMetacat.error("Error while getting system metadata for guid " + guid + " : "  

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        // look up provenance information

        sysMeta.setObsoleteList(getSystemMetadataProvenance(sysMeta.getIdentifier().getValue(), "obsoletes"));

        sysMeta.setObsoletedByList(getSystemMetadataProvenance(sysMeta.getIdentifier().getValue(), "obsoletedBy"));

        sysMeta.setDescribeList(getSystemMetadataProvenance(sysMeta.getIdentifier().getValue(), "describes"));

        sysMeta.setDescribedByList(getSystemMetadataProvenance(sysMeta.getIdentifier().getValue(), "describedBy"));

        sysMeta.setDerivedFromList(getSystemMetadataProvenance(sysMeta.getIdentifier().getValue(), "derivedFrom"));

        // look up replication policy

        ReplicationPolicy replicationPolicy = new ReplicationPolicy();

        replicationPolicy.setBlockedMemberNodeList(getReplicationPolicy(guid, "blocked"));

        replicationPolicy.setPreferredMemberNodeList(getReplicationPolicy(guid, "preferred"));

		sysMeta.setReplicationPolicy(replicationPolicy);

		// look up replication status

		sysMeta.setReplicaList(getReplicationStatus(guid));

		// look up access policy

		try {

			sysMeta.setAccessPolicy(getAccessPolicy(guid));

		} catch (AccessException e) {

			throw new McdbDocNotFoundException(e);

		}

        return sysMeta;

    }

    private List<Identifier> getSystemMetadataProvenance(String guid, String relationship)

    	throws McdbDocNotFoundException {

    	List<Identifier> identifiers = new ArrayList<Identifier>();

    	String sql = "select guid, relationship, target_guid " +

    		"from systemMetadataProvenance where guid = ? and relationship = ?";

	    DBConnection dbConn = null;

	    int serialNumber = -1;

	    try {

	        // Get a database connection from the pool

	        dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getSystemMetadataProvenance");

	        serialNumber = dbConn.getCheckOutSerialNumber();

	        // Execute the statement

	        PreparedStatement stmt = dbConn.prepareStatement(sql);

	        stmt.setString(1, guid);

	        stmt.setString(2, relationship);

	        ResultSet rs = stmt.executeQuery();

	        while (rs.next()) 

	        {

	            String targetGuid = rs.getString(3);

	            Identifier id = new Identifier();

	            id.setValue(targetGuid);

	            identifiers.add(id);

	        } 

	        stmt.close();

	    } 

	    catch (SQLException e) {

	        logMetacat.error("Error while getting system metadata provenance for guid " + guid, e);

	    } 

	    finally {

	        // Return database connection to the pool

	        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

	    }

	    return identifiers;

	}

    private List<NodeReference> getReplicationPolicy(String guid, String policy)

		throws McdbDocNotFoundException {

		List<NodeReference> nodes = new ArrayList<NodeReference>();

		String sql = "select guid, policy, member_node " +

			"from systemMetadataReplicationPolicy where guid = ? and policy = ?";

	    DBConnection dbConn = null;

	    int serialNumber = -1;

	    try {

	        // Get a database connection from the pool

	        dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getReplicationPolicy");

	        serialNumber = dbConn.getCheckOutSerialNumber();

	        // Execute the statement

	        PreparedStatement stmt = dbConn.prepareStatement(sql);

	        stmt.setString(1, guid);

	        stmt.setString(2, policy);

	        ResultSet rs = stmt.executeQuery();

	        while (rs.next()) 

	        {

	            String memberNode = rs.getString(3);

	            NodeReference node = new NodeReference();

	            node.setValue(memberNode);

	            nodes.add(node);

	        } 

	        stmt.close();

	    } catch (SQLException e) {

	        logMetacat.error("Error while getting system metadata replication policy for guid " + guid, e);

	    } 

	    finally {

	        // Return database connection to the pool

	        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

	    }

	    return nodes;

	}

    private List<Replica> getReplicationStatus(String guid) throws McdbDocNotFoundException {

		List<Replica> replicas = new ArrayList<Replica>();

		String sql = "select guid, member_node, status, date_verified " +

			"from systemMetadataReplicationStatus where guid = ?";

	    DBConnection dbConn = null;

	    int serialNumber = -1;

	    try {

	        // Get a database connection from the pool

	        dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getReplicas");

	        serialNumber = dbConn.getCheckOutSerialNumber();

	        // Execute the statement

	        PreparedStatement stmt = dbConn.prepareStatement(sql);

	        stmt.setString(1, guid);

	        ResultSet rs = stmt.executeQuery();

	        while (rs.next()) 

	        {

	            String memberNode = rs.getString(2);

	            String status = rs.getString(3);

	            java.sql.Date verified = rs.getDate(4);

	            Replica replica = new Replica();	            

	            NodeReference node = new NodeReference();

	            node.setValue(memberNode);

	            replica.setReplicaMemberNode(node);

	            replica.setReplicationStatus(ReplicationStatus.convert(status));

	            replica.setReplicaVerified(new Date(verified.getTime()));

	            replicas.add(replica);

	        } 

	        stmt.close();

	    } catch (SQLException e) {

	        logMetacat.error("Error while getting system metadata replication policy for guid " + guid, e);

	    } 

	    finally {

	        // Return database connection to the pool

	        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

	    }

	    return replicas;

	}

    /**

     * return information on the document with localId.  These are the fields

     * from the xml_documents table.  They can be used to contstruct metadata 

     * about the object that is stored.

     * @param localId

     * @return

     * @throws McdbDocNotFoundException

     */

    public Hashtable<String, Object> getDocumentInfo(String localId)

        throws McdbDocNotFoundException

    {

        try

        {

            AccessionNumber acc = new AccessionNumber(localId, "NONE");

            localId = acc.getDocid();

        }

        catch(Exception e)

        {

            //do nothing. just try the localId as it is

        }

        Hashtable<String, Object> h = new Hashtable<String, Object>();

        String sql = "select docname, doctype, user_owner, user_updated, " +

            "server_location, rev, date_created, date_updated from " + 

            "xml_documents where docid like '" + localId + "'";

        DBConnection dbConn = null;

        int serialNumber = -1;

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getDocumentInfo");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            ResultSet rs = stmt.executeQuery();

            if (rs.next()) 

            {

                String docname = rs.getString(1);

                String doctype = rs.getString(2);

                String user_owner = rs.getString(3);

                String user_updated = rs.getString(4);

                String server_location = rs.getString(5);

                int rev = rs.getInt(6);

                String date_created = rs.getString(7);

                String date_updated = rs.getString(8);

                h.put("docid", localId);

                h.put("docname", docname);

                h.put("doctype", doctype);

                h.put("user_owner", user_owner);

                h.put("user_updated", user_updated);

                h.put("server_location", server_location);

                h.put("rev", new Integer(rev).toString());

                h.put("date_created", date_created);

                h.put("date_updated", date_updated);

                stmt.close();

            } 

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

                throw new McdbDocNotFoundException("2Could not find document " + localId);

            }

            String sql2 = "select principal_name, permission, perm_type, perm_order from xml_access " +

            "where docid like '" + localId + "'";

            logMetacat.debug("executing sql: " + sql2);

            PreparedStatement stmt2 = dbConn.prepareStatement(sql2);

            rs = stmt2.executeQuery();

            Vector accessVector = new Vector();

            while(rs.next())

            {

                Hashtable accessHash = new Hashtable();

                String principal_name = rs.getString(1);

                String permission = rs.getString(2);

                String permissionType = rs.getString(3);

                String permissionOrder = rs.getString(4);

                accessHash.put("principal_name", principal_name);

                accessHash.put("permission", permission);

                accessHash.put("permission_type", permissionType);

                accessHash.put("permission_order", permissionOrder);

                logMetacat.debug("accessHash: " + accessHash.toString());

                accessVector.add(accessHash);

            }

            h.put("access", accessVector);

        } 

        catch (SQLException e) 

        {

            e.printStackTrace();

            logMetacat.error("Error while getting document info for localid " + localId + " : "  

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return h;

    }

    /**

     * return the newest rev for a given localId

     * @param localId

     * @return

     */

    public int getLatestRevForLocalId(String localId)

        throws McdbDocNotFoundException

    {

        try

        {

            AccessionNumber acc = new AccessionNumber(localId, "NONE");

            localId = acc.getDocid();

        }

        catch(Exception e)

        {

            //do nothing. just try the localId as it is

        }

        int rev = 0;

        String sql = "select rev from xml_documents where docid like '" + localId + "'";

        DBConnection dbConn = null;

        int serialNumber = -1;

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getLatestRevForLocalId");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            ResultSet rs = stmt.executeQuery();

            if (rs.next()) 

            {

                rev = rs.getInt(1);

                stmt.close();

            } 

            else

            {

                stmt.close();

                DBConnectionPool.returnDBConnection(dbConn, serialNumber);

                throw new McdbDocNotFoundException("While trying to get the latest rev, could not find document " + localId);

            }

        } 

        catch (SQLException e) 

        {

            logMetacat.error("Error while looking up the guid: " 

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return rev;

    }

    /**

     * return all local ids in the object store that do not have associated

     * system metadata

     */

    public List<String> getLocalIdsWithNoSystemMetadata()

    {

        Vector<String> ids = new Vector<String>();

        String sql = "select docid, rev from xml_documents " +

        		"where docid not in " +

        		"(select docid from identifier where guid in (select guid from systemmetadata)))";

        DBConnection dbConn = null;

        int serialNumber = -1;

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getLocalIdsWithNoSystemMetadata");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            ResultSet rs = stmt.executeQuery();

            while (rs.next()) 

            {

                String localid = rs.getString(1);

                String rev = rs.getString(2);

                localid += "." + rev;

                logMetacat.debug("id to add SM for: " + localid);

                ids.add(localid);

            } 

            stmt.close();

        } 

        catch (SQLException e) 

        {

            logMetacat.error("Error while looking up the guid: " 

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return ids;

    }

    /**

     * return a listing of all local ids in the object store

     * @return a list of all local ids in metacat

     */

    public List<String> getAllLocalIds()

       throws Exception

    {

        Vector<String> ids = new Vector<String>();

        String sql = "select docid from xml_documents";

        DBConnection dbConn = null;

        int serialNumber = -1;

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getAllLocalIds");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            ResultSet rs = stmt.executeQuery();

            while (rs.next()) 

            {

                String localid = rs.getString(1);

                ids.add(localid);

            } 

            stmt.close();

        } 

        catch (SQLException e) 

        {

            logMetacat.error("Error while looking up the guid: " 

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return ids;

    }

    /**

     * returns a list of system metadata-only guids since the given date

     * @return a list of system ids in metacat that do not correspond to objects

     * TODO: need to check which server they are on

     */

    public List<String> getUpdatedSystemMetadataIds(Date since)

       throws Exception

    {

        List<String> ids = new Vector<String>();

        String sql = 

        	"select guid from " + TYPE_SYSTEM_METADATA +

        	" where guid not in " +

        	" (select guid from " + TYPE_IDENTIFIER + ") " +

        	" and date_modified > ?";

        DBConnection dbConn = null;

        int serialNumber = -1;

        try 

        {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getUpdatedSystemMetadataIds");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            PreparedStatement stmt = dbConn.prepareStatement(sql);

            stmt.setDate(1, new java.sql.Date(since.getTime()));

            ResultSet rs = stmt.executeQuery();

            while (rs.next()) 

            {

                String guid = rs.getString(1);

                ids.add(guid);

            } 

            stmt.close();

        } 

        catch (SQLException e) 

        {

            logMetacat.error("Error while looking up the updated guids: " 

                    + e.getMessage());

        } 

        finally 

        {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return ids;

    }

    /**

     * Determine if an identifier exists already, returning true if so.

     * 

     * @param guid the global identifier to look up

     * @return boolean true if the identifier exists

     */

    public boolean identifierExists(String guid)

    {

        boolean idExists = false;

        try {

            String id = getLocalId(guid);

            if (id != null) {

                idExists = true;

            }

        } catch (McdbDocNotFoundException e) {

            idExists = false;

        }

        return idExists;

    }

    /**

     * 

     * @param guid

     * @param rev

     * @return

     */

    public String generateLocalId(String guid, int rev)

    {

        return generateLocalId(guid, rev, false);

    }

    /**

     * Given a global identifier (guid), create a suitable local identifier that

     * follows Metacat's docid semantics and format (scope.id.rev), and create

     * a mapping between these two identifiers.  This effectively reserves both

     * the global and the local identifier, as they will now be present in the

     * identifier mapping table.  If the incoming guid has the syntax of a

     * Metacat docid (scope.id.rev), then simply use it.

     * 

     * @param guid the global string identifier

     * @param rev the revision number to be used in the localId

     * @return String containing the localId to be used for Metacat operations

     */

    public String generateLocalId(String guid, int rev, boolean isSystemMetadata) 

    {

        String localId = "";

        boolean conformsToDocidFormat = false;

        // Check if the guid passed in is already in docid (scope.id.rev) format

        try {

            AccessionNumber acc = new AccessionNumber(guid, "NONE");

            if (new Integer(acc.getRev()).intValue() > 0) {

                conformsToDocidFormat = true;

            }

        } catch (NumberFormatException e) {

            // No action needed, simply detecting invalid AccessionNumbers

        } catch (AccessionNumberException e) {

            // No action needed, simply detecting invalid AccessionNumbers

        } catch (SQLException e) {

            // No action needed, simply detecting invalid AccessionNumbers

        }

        if (conformsToDocidFormat) {

            // if it conforms, use it for both guid and localId

            localId = guid;

        } else {

            // if not, then generate a new unique localId

            localId = DocumentUtil.generateDocumentId(rev);

        }

        // Register this new pair in the identifier mapping table

        logMetacat.debug("creating mapping in generateLocalId");

        if(!isSystemMetadata)

        { //don't do this if we're generating for system metadata

            createMapping(guid, localId);

        }

        return localId;

    }

    /**

     * given a local identifer, look up the guid.  Throw McdbDocNotFoundException

     * if the docid, rev is not found in the identifiers or systemmetadata tables

     *

     * @param docid the docid to look up

     * @param rev the revision of the docid to look up

     * @return String containing the mapped guid

     * @throws McdbDocNotFoundException if the docid, rev is not found

     */

    public String getGUID(String docid, int rev)

      throws McdbDocNotFoundException

    {

        logMetacat.debug("getting guid for " + docid);

        String query = "select guid from identifier where docid = ? and rev = ?";

        String guid = null;

        DBConnection dbConn = null;

        int serialNumber = -1;

        try {

            // Get a database connection from the pool

            dbConn = DBConnectionPool.getDBConnection("IdentifierManager.getGUID");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            PreparedStatement stmt = dbConn.prepareStatement(query);

            stmt.setString(1, docid);

            stmt.setInt(2, rev);

            ResultSet rs = stmt.executeQuery();

            if (rs.next()) 

            {

                guid = rs.getString(1);

            } 

            else

            {

            	throw new McdbDocNotFoundException("No guid registered for docid " + docid + "." + rev);

            }

        } catch (SQLException e) {

            logMetacat.error("Error while looking up the guid: " 

                    + e.getMessage());

        } finally {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

        return guid;

    }

    /**

     * creates a system metadata mapping and adds additional fields from sysmeta

     * to the table for quick searching.

     * 

     * @param guid the id to insert

     * @param localId the systemMetadata object to get the local id for

     * @throws McdbDocNotFoundException 

     */

    public void createSystemMetadata(SystemMetadata sysmeta) throws McdbDocNotFoundException

    {

        insertSystemMetadata(sysmeta.getIdentifier().getValue());

        updateSystemMetadata(sysmeta);

    }

    /**

     * update a mapping