Metacat

/**

 *  '$RCSfile$'

 *             attributes that have free text matches a query string,

 *             document ID for each document that satisfies the query

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

 *             National Center for Ecological Analysis and Synthesis

import java.io.BufferedWriter;

import javax.servlet.ServletOutputStream;

 * attributes that have free text matches a query string,

 * document ID for each document that satisfies the query

 */

public class DBQuery {

  static final int ALL = 1;

  static final int WRITE = 2;

  static final int READ = 4;

  //private Connection  conn = null;

  private String  parserName = null;

  private MetaCatUtil util = new MetaCatUtil();

   * @param xmlfile the filename of the xml file containing the query

   */

  static public void main(String[] args) {

     if (args.length < 1)

     {

        System.err.println("Wrong number of arguments!!!");

          if ( args[i].equals( "-index" ) ) {

            useXMLIndex = true;

            i++;

          String xmlfile  = args[i];

          // Time the request if asked for

          String document = null;

          String docid = null;

          result.append("<?xml version=\"1.0\"?>\n");

          if (!showRuntime)

          {

            Enumeration doclist = nodelist.keys();

            while (doclist.hasMoreElements()) {

              docid = (String)doclist.nextElement();

              document = (String)nodelist.get(docid);

                            "\n  </document>\n");

            }

            result.append("</resultset>\n");

          }

          // Time the request if asked for

            File f = new File("./result.txt");

            FileWriter fw = new FileWriter(f);

            BufferedWriter out = new BufferedWriter(fw);

            out.flush();

            out.close();

            fw.close();

          }

        catch (Exception e) {

          System.err.println("Error in DBQuery.main");

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

        }

     }

  }

  /**

   *

   * an instance to specify the search query</p>

   *

   * @param conn the JDBC connection that we use for the query

   * @param parserName the fully qualified name of a Java class implementing

   *                   the org.xml.sax.XMLReader interface

   */

                         ClassNotFoundException {

    //this.conn = conn;

    this.parserName = parserName;

  }

   * routine to search the elements and attributes looking to match query

   *

   * @param xmlquery the xml serialization of the query (@see pathquery.dtd)

    return findDocuments(xmlquery, user, groups, true);

  }

   * routine to search the elements and attributes looking to match query

   *

   * @param xmlquery the xml serialization of the query (@see pathquery.dtd)

      try

      {

        // Get the XML query and covert it into a SQL statment

                                   util.getOption("accNumSeparator"));

        result = findDocuments(qspec, user, groups, useXMLIndex);

      }

      {

        MetaCatUtil.debugMessage("IO error in DBQuery.findDocuments:", 30);

        MetaCatUtil.debugMessage(ioe.getMessage(), 30);

      }

      return result;

  }

   * routine to search the elements and attributes looking to match query

   *

   * @param qspec java object of the query

   * @param group the group of the user

   * @param useXMLIndex flag whether to search using the path index

   */

                                  String[] groups, boolean useXMLIndex)

  {

      Hashtable   docListResult = new Hashtable();

      StringBuffer document = null;

      DBConnection dbconn = null;

      int serialNumber = -1;

      try {

        dbconn=DBConnectionPool.getDBConnection("DBQuery.findDocuments");

        serialNumber=dbconn.getCheckOutSerialNumber();

        String query = qspec.printSQL(useXMLIndex);

        String ownerQuery = getOwnerQuery(user);

        MetaCatUtil.debugMessage("query: "+query, 30);

          query = query + accessQuery;

          MetaCatUtil.debugMessage(" final query: "+query, 30);

        }

        double startTime = System.currentTimeMillis()/1000;

        pstmt = dbconn.prepareStatement(query);

        // Execute the SQL query using the JDBC connection

        pstmt.execute();

        ResultSet rs = pstmt.getResultSet();

                                            (queryExecuteTime -startTime), 30);

        boolean tableHasRows = rs.next();

        {

          docid = rs.getString(1).trim();

          //long checkTimeStart = System.currentTimeMillis();

            //tableHasRows = rs.next();

            //continue;

          //}

          docname = rs.getString(2);

          doctype = rs.getString(3);

          createDate = rs.getString(4);

          // if there are returndocs to match, backtracking can be performed

          // otherwise, just return the document that was hit

          Vector returndocVec = qspec.getReturnDocList();

              && !qspec.isPercentageSearch())

            MetaCatUtil.debugMessage("Back tracing now...", 20);

            String sep = util.getOption("accNumSeparator");

            StringBuffer btBuf = new StringBuffer();

              if (i != (returndocVec.size() - 1))

              {

                btBuf.append(", ");

            }

            btBuf.append(") ");

            btBuf.append(docid).append("'");

            btBuf.append("or object like '");

            btBuf.append(docid).append("')");

            PreparedStatement npstmt = dbconn.

                                       prepareStatement(btBuf.toString());

            //should incease usage count

              }

              catch(Exception e)

              {

                                   "DBQuery.findDocuments: " + e.getMessage());

              }

              String docid_org = xmldoc.getDocID();

              if (docid_org == null) {

                util.debugMessage("Docid_org was null.", 40);

              }

              // Store the document id and the root node id

              docListResult.put(docid,(String)document.toString());

              // Get the next package document linked to our hit

              hasBtRows = btrs.next();

            }

            npstmt.close();

            btrs.close();

          {

            document = new StringBuffer();

            String completeDocid = docid + util.getOption("accNumSeparator");

            }

            // Store the document id and the root node id

            docListResult.put(docid,(String)document.toString());

          }

          // Advance to the next record in the cursor

        double docListTime =System.currentTimeMillis()/1000;

        MetaCatUtil.debugMessage("prepare docid list time: "

                                          +(docListTime-queryExecuteTime), 30);

        if (qspec.containsExtendedSQL())

        {

          Vector extendedFields = new Vector(qspec.getReturnFieldList());

          Vector results = new Vector();

          Enumeration keylist = docListResult.keys();

          StringBuffer doclist = new StringBuffer();

          Hashtable returnFieldValue = new Hashtable();

          while(keylist.hasMoreElements())

          {

            doclist.append((String)keylist.nextElement());

            doclist.append("',");

          }

          {

            Hashtable controlPairs = new Hashtable();

            double extendedQueryStart = System.currentTimeMillis()/1000;

              controlPairs.put(new Long(startNodeId), new Long(endNodeId));

              tableHasRows = rs.next();

            }

            double extendedAccessQueryEnd = System.currentTimeMillis()/1000;

            MetaCatUtil.debugMessage("Time for execute access extended query: "

                              +(extendedAccessQueryEnd-extendedQueryStart), 30);

                                                          controlPairs);

            MetaCatUtil.debugMessage("Extended query: "+ extendedQuery, 30);

            pstmt = dbconn.prepareStatement(extendedQuery);

            MetaCatUtil.debugMessage("Time for execute extended query: "

                                    +(extendedQueryEnd-extendedQueryStart), 30);

            tableHasRows = rs.next();

            {

              ReturnFieldValue returnValue = new ReturnFieldValue();

              docid = rs.getString(1).trim();

              fieldname = rs.getString(2);

              fielddata = rs.getString(3);

              fielddata = MetaCatUtil.normalize(fielddata);

              String parentId = rs.getString(4);

              StringBuffer value = new StringBuffer();

              {

                value.append("<param name=\"");

                value.append(fieldname);

                value.append("\">");

                returnValue.setFieldValue(fielddata);

                returnValue.setXMLFieldValue(value.toString());

                // Store it in hastable

              }

              else

              {

                // need to merge nodedata if they have same parent id ant

                // node type is text

                fielddata = (String)((ReturnFieldValue)

                value.append("<param name=\"");

                value.append(fieldname);

                value.append("\">");

                // remove the old return value from paretnidList

                parentidList.remove(parentId);

                // store the new return value in parentidlit

              }

               tableHasRows = rs.next();

            }//while

            rs.close();

            pstmt.close();

            // put the merger node data info into doclistReult

            while( xmlFieldValue.hasMoreElements() )

            {

              ReturnFieldValue object = (ReturnFieldValue)

              }

              else

              {

              }

            }//while

            double docListResultEnd = System.currentTimeMillis()/1000;

            MetaCatUtil.debugMessage("Time for prepare doclistresult after"+

                                      " execute extended query: "

                                    +(docListResultEnd-extendedQueryEnd), 30);

            // get attribures return

            docListResult = getAttributeValueForReturn

                                      (qspec,docListResult, doclist.toString());

          }//if doclist lenght is great than zero

        }//if has extended query

        //this loop adds the relation data to the resultdoc

        //this code might be able to be added to the backtracking code above

        double startRelation = System.currentTimeMillis()/1000;

            String obj = rs.getString(3);

            String subDT = rs.getString(4);

            String objDT = rs.getString(5);

            document = new StringBuffer();

            document.append("<triple>");

            document.append("<subject>").append(MetaCatUtil.normalize(sub));

              document.append("</objectdoctype>");

            }

            document.append("</triple>");

            String removedelement = (String)docListResult.remove(docidkey);

                              document.toString());

            tableHasRows = rs.next();

          }

        double endRelation = System.currentTimeMillis()/1000;

        MetaCatUtil.debugMessage("Time for adding relation to docListResult: "+

                                (endRelation-startRelation), 30);

      } catch (SQLException e) {

                           e.getMessage());

      } catch (Exception ee) {

                           ee.getMessage());

        ee.printStackTrace(System.err);

      }

      {

        try

        {

    //System.out.println(docListResult.toString());

    return docListResult;

  }

  /*

   * A method to return search result after running a query which return

   * field have attribue

   */

    ResultSet rs = null;

    int serialNumber = -1;

    boolean tableHasRows =false;

    //check the parameter

    if (squery == null || docList==null || docList.length() <0)

    {

      return docInformationList;

    }

    // if has attribute as return field

    if (squery.containAttributeReturnField())

    {

      sql = squery.printAttributeQuery(docList);

      {

        dbconn=DBConnectionPool.getDBConnection("DBQuery.getAttributeValue");

        serialNumber=dbconn.getCheckOutSerialNumber();

        pstmt.execute();

        rs = pstmt.getResultSet();

        tableHasRows = rs.next();

        {

          String docid = rs.getString(1).trim();

          String fieldname = rs.getString(2);

          String fielddata = rs.getString(3);

          String attirbuteName = rs.getString(4);

          XML = new StringBuffer();

          XML.append("<param name=\"");

          XML.append(fieldname);

          XML.append(QuerySpecification.ATTRIBUTESYMBOL);

          XML.append(fielddata);

          XML.append("</param>");

          tableHasRows = rs.next();

          if (docInformationList.containsKey(docid))

          {

            String removedelement = (String)docInformationList.remove(docid);

          }

          else

          {

          }

        }//while

        rs.close();

      }//finally

    }//if

    return docInformationList;

  }

  /*

   * A method to create a query to get owner's docid list

   */

    return self.toString();

  }

  /**

   * in the order in which they appearred in the document.

   * @param nodename the name or path of the particular node.

   * @param docid the docid of the document you want the node from.

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tableHasRows = rs.next();

      {

        result.add(rs.getString(1));

        //System.out.println(rs.getString(1));

        tableHasRows = rs.next();

      }

    {

      System.err.println("Error in DBQuery.getNodeContent: " + e.getMessage());

    } finally {

      {

        pstmt.close();

      }

      {}

      finally

      {

        DBConnectionPool.returnDBConnection(dbconn, serialNumber);

      }

    }

    return result.toArray();

  }

  /**

   * format a structured query as an XML document that conforms

   * to the pathquery.dtd and is appropriate for submission to the DBQuery

   * @param params The list of parameters that should be included in the query

   */

  public static String createSQuery(Hashtable params)

    StringBuffer query = new StringBuffer();

    Enumeration elements;

    Enumeration keys;

      query.append( ((String[])params.get("meta_file_id"))[0]);

      query.append("</meta_file_id>");

    }

    if (params.containsKey("returndoctype"))

    {

      String[] returnDoctypes = ((String[])params.get("returndoctype"));

      {

        String doctype = (String)returnDoctypes[i];

            !doctype.equals("ANY") &&

        {

          query.append("<returndoctype>").append(doctype);

          query.append("</returndoctype>");

        }

      }

    }

    if (params.containsKey("filterdoctype"))

    {

      String[] filterDoctypes = ((String[])params.get("filterdoctype"));

        query.append("</filterdoctype>");

      }

    }

    if (params.containsKey("returnfield"))

    {

      String[] returnfield = ((String[])params.get("returnfield"));

        query.append("</returnfield>");

      }

    }

    if (params.containsKey("owner"))

    {

      String[] owner = ((String[])params.get("owner"));

        query.append("</owner>");

      }

    }

    if (params.containsKey("site"))

    {

      String[] site = ((String[])params.get("site"));

        query.append("</site>");

      }

    }

    //allows the dynamic switching of boolean operators

    if (params.containsKey("operator"))

    {

                ((String[])params.get("operator"))[0] + "\">");

    }

    else

    { //the default operator is UNION

    }

    if (params.containsKey("casesensitive"))

    {

    }

    else

    {

    }

    if (params.containsKey("searchmode"))

    {

    }

    else

    {

    }

    //free text search.  It does not have a <pathexpr>

    //tag.  This allows for a free text search within the structured

    //query.  This is useful if the INTERSECT operator is used.

       {

         if (!anyfield[i].equals(""))

         {

                        "\" " + "searchmode=\"" + searchmode + "\"><value>" +

                        anyfield[i] +

         }

       }

    }

    //this while loop finds the rest of the parameters

    //and attempts to query for the field specified

    //by the parameter.

        //allow for more than value per field name

        for(int i=0; i<((String[])nextelement).length; i++) {

          if (!((String[])nextelement)[i].equals("")) {

                         "searchmode=\"" + searchmode + "\">" +

                         "<value>" +

                         //add the query value

                         ((String[])nextelement)[i] +

                         "</value><pathexpr>" +

                         "</pathexpr></queryterm>");

          }

        }

    //append on the end of the xml and return the result as a string

    return query.toString();

  }

  /**

   * format a simple free-text value query as an XML document that conforms

   * to the pathquery.dtd and is appropriate for submission to the DBQuery

     xmlquery.append("<querygroup operator=\"UNION\">");

     //chad added - 8/14

     //query.  Without this if a nullpointerException is thrown.

     if (!value.equals(""))

     {

     xmlquery.append("</querygroup>");

     xmlquery.append("</pathquery>");

     return (xmlquery.toString());

   }

   public static String createQuery(String value) {

     return createQuery(value, "any");

   }

    */

  private boolean hasPermission (String user,

                  throws SQLException, Exception

  {

    // Check for READ permission on @docid for @user and/or @groups

    ResultSet rs=null;

    String docIdInSubjectField=null;

    String docIdInObjectField=null;

    // Check the parameter

    if (dataPackageDocid == null || dataPackageDocid.equals(""))

    {

      return docIdList;

    }//if

    //the query stirng

    String query="SELECT subject, object from xml_relation where docId = ?";

    try

      {

        MetaCatUtil.debugMessage("Error in getDocidListForDataPackage: "

                            +ee.getMessage(), 30);

      finally

      {

        DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    }//finally

    return docIdList;

  }//getCurrentDocidListForDataPackadge()

  /**

   * Get all docIds list for a data packadge

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

   */

  private Vector getOldVersionDocidListForDataPackage(String dataPackageDocid)

  {

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

    Vector tripleList=null;

    String xml=null;

     // Check the parameter

    if (dataPackageDocid == null || dataPackageDocid.equals(""))

    {

      return docIdList;

    }//if

    try

    {

                  new DocumentImpl(dataPackageDocid);

      //transfer to documentImpl object to string

      xml=packageDocument.toString();

      //create a tripcollection object

                                     TripleCollection(new StringReader(xml));

      tripleList=tripleForPackage.getCollection();

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

      {

        //put subject docid  into docIdlist without duplicate

      MetaCatUtil.debugMessage("Error in getOldVersionAllDocumentImpl: "

                            +e.getMessage(), 30);

    }//catch

    // return result

    return docIdList;

  /**

   *id, it should be store in the docId fields in xml_relation table.

   *value. If the result is null. The docId is not a packadge id. Otherwise,

   * it is.

   * @param docId, the id need to be checked

    }//finally

    return result;

  }//isDataPackageId()

  /**

   * Check if the user has the permission to export data package

   * @param conn, the connection

   * @param docId, the id need to be checked

   * @param user, the name of user

   * @param groups, the user's group

                                        String user, String[] groups)

                   throws Exception

   {

     //DocumentImpl doc=new DocumentImpl(conn,docId);

     return DocumentImpl.hasReadPermission(user, groups,docId);

   }

  /**

   *Get the current Rev for a docid in xml_documents table

   * @param docId, the id need to get version numb

      {

        rev=-5;

      }

    }//try

    catch (SQLException e)

    {

    }//finally

    return rev;

  }//getCurrentRevFromXMLDoumentsTable

 /**

   *put a doc into a zip output stream

   *@param docImpl, docmentImpl object which will be sent to zip output stream

   *@param zipOut, zip output stream which the docImpl will be put

   *@param packageZipEntry, the zip entry name for whole package

   */

                                ZipOutputStream zipOut, String packageZipEntry)

                      McdbException, Exception

  {

    byte[] byteString = null;

    zipOut.putNextEntry(zEntry);

    zipOut.write(byteString, 0, byteString.length);

    zipOut.closeEntry();

  }//addDocToZipOutputStream()

  /**

   * only inlcudes current version. If a DocumentImple object

   * couldn't find for a docid, then the String of this docid was added to vetor

   * rather than DocumentImple object.

   * @param docIdList, a vetor hold a docid list for a data package. In docid,

   * there is not version number in it.

  private Vector getCurrentAllDocumentImpl( Vector docIdList)

                              throws McdbException,Exception

  {

    //Connection dbConn=null;

    Vector documentImplList=new Vector();

    // Check the parameter

    if (docIdList.isEmpty())

    {

      return documentImplList;

    }//if

    //for every docid in vector

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

    {

      {

        //get newest version for this docId

        rev=getCurrentRevFromXMLDoumentsTable((String)docIdList.elementAt(i));

        // There is no record for this docId in xml_documents table

        if (rev ==-5)

        {

          // Skip other code

          continue;

        }

        String docidPlusVersion=((String)docIdList.elementAt(i))

                        +util.getOption("accNumSeparator")+rev;

        //create new documentImpl object

                                    new DocumentImpl(docidPlusVersion);

        documentImplList.add(documentImplObject);

      }//try

      catch (Exception e)

    }//for

    return documentImplList;

  }

  /**

   * Transfer a docid vetor to a documentImpl vector. If a DocumentImple object

   * couldn't find for a docid, then the String of this docid was added to vetor

   * rather than DocumentImple object.

   * @param docIdList, a vetor hold a docid list for a data package. In docid,

   *t here is version number in it.

  private Vector getOldVersionAllDocumentImpl( Vector docIdList)

  {

    //Connection dbConn=null;

    Vector documentImplList=new Vector();

    String siteCode=null;

    String uniqueId=null;

    // Check the parameter

    if (docIdList.isEmpty())

    {

      return documentImplList;

    }//if

    //for every docid in vector

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

    {

        String docidPlusVersion=(String)(docIdList.elementAt(i));

        try

        {

          //create new documentImpl object

                                    new DocumentImpl(docidPlusVersion);

          documentImplList.add(documentImplObject);

        }//try

        catch (McdbDocNotFoundException notFoundE)

          // Continue the for loop

          continue;

        }//catch

    }//for

    return documentImplList;

  }//getOldVersionAllDocumentImple

  /**

   *put a data file into a zip output stream

   *@param docImpl, docmentImpl object which will be sent to zip output stream

    ZipEntry zEntry = null;

    // this is data file; add file to zip

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

    {

      filePath += "/";

    }

    byte[] byteString=null;

    InputStream source;

    DBTransform xmlToHtml;

    //create a DBTransform ojbect

    xmlToHtml = new DBTransform();

    //head of html

      if ((((docImplList.elementAt(i)).getClass()).toString())

                                             .equals("class java.lang.String"))

      {

        htmlDoc.append("<a href=\"");

        String dataFileid =(String)docImplList.elementAt(i);

        htmlDoc.append("./data/").append(dataFileid).append("\">");

        htmlDoc.append("Data File: ");

        htmlDoc.append(dataFileid).append("</a><br>");

        htmlDoc.append("<br><hr><br>");

      }//if

      else if ((((DocumentImpl)docImplList.elementAt(i)).getDoctype()).

                                                         compareTo("BIN")!=0)

    zipOut.write(byteString, 0, byteString.length);

    zipOut.closeEntry();

    //dbConn.close();

  }//addHtmlSummaryToZipOutputStream

  /**

   * put a data packadge into a zip output stream

   * @param docId, which the user want to put into zip output stream

   * @param user, the username of the user

   * @param groups, the group of the user

   */

        ServletOutputStream out, String user, String[] groups, String passWord)

                      McdbException, NumberFormatException, Exception

    ZipOutputStream zOut = null;

    String elementDocid=null;

    DocumentImpl docImpls=null;

    Vector htmlDocumentImplList=new Vector();

    String packageId=null;

    String rootName="package";//the package zip entry name

    String docId=null;

    int version=-5;

    // Docid without revision

    docId=MetaCatUtil.getDocIdFromString(docIdString);

    // revision number

    version=MetaCatUtil.getVersionFromString(docIdString);

    //check if the reqused docId is a data package id

    if (!isDataPackageId(docId))

    {

      /*Exception e = new Exception("The request the doc id " +docIdString+

                                    " is not a data package id");

      throw e;*/

      //CB 1/6/03: if the requested docid is not a datapackage, we just zip

      //up the single document and return the zip file.

    // Check the permission of user

    else if(!hasPermissionToExportPackage(docId, user, groups))

    {

      Exception e = new Exception("User " + user + " does not have permission"

                       +" to export the data package " + docIdString);

      throw e;

    }

    else //it is a packadge id

      //store the package id

      packageId=docId;

      //get current version in database

      int currentVersion = getCurrentRevFromXMLDoumentsTable(packageId);

      //If it is for current version (-1 means user didn't specify revision)

      if ((version ==-1)||version==currentVersion)

        //get current version number

        version=currentVersion;

        //get package zip entry name

        docIdList=getCurrentDocidListForDataPackage(packageId);

        //get the whole documentImple object

        documentImplList=getCurrentAllDocumentImpl(docIdList);

      }//if

      else if (version > currentVersion || version < -1)

      {

      }//else if

      else  //for an old version

      {

        rootName=docIdString+util.getOption("accNumSeparator")+"package";

        //get the whole id list for data packadge

        docIdList=getOldVersionDocidListForDataPackage(docIdString);

        //get the whole documentImple object

        documentImplList=getOldVersionAllDocumentImpl(docIdList);

      // Make sure documentImplist is not empty

      if (documentImplList.isEmpty())

      {

        throw new Exception ("Couldn't find component for data package: "

                                              + packageId);

      }//if

       zOut = new ZipOutputStream(out);

      //put every element into zip output stream

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

          String documentId = (String) documentImplList.elementAt(i);

          MetaCatUtil.debugMessage("docid: "+documentId, 30);

          // Get doicd without revision

                                     MetaCatUtil.getDocIdFromString(documentId);

          MetaCatUtil.debugMessage("docidWithoutRevsion: "

                                                     +docidWithoutRevision, 30);

          String revision = MetaCatUtil.getRevisionStringFromString(documentId);

          MetaCatUtil.debugMessage("revsion from docIdentifier: "+revision, 30);

          // Zip entry string

          // Create a RemoteDocument object

                                                     passWord, zipEntryPath);

          // Here we only read data file from remote metacat

          String docType = remoteDoc.getDocType();

              htmlDocumentImplList.add(elementInHtmlList);

            }//if

          }//if

        }//if

        else

        {

          docImpls=(DocumentImpl)documentImplList.elementAt(i);

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

          if (docImpls.hasReadPermission(user,groups,docImpls.getDocID()))

            {

              //add metadata into zip output stream

              addDocToZipOutputStream(docImpls, zOut, rootName);

              //add the documentImpl into the vetor which will be used in html

              htmlDocumentImplList.add(docImpls);

            }//if

            {

              addDataFileToZipOutputStream(docImpls, zOut, rootName);

              htmlDocumentImplList.add(docImpls);

            }//else

      return zOut;

    }//else

  }//getZippedPackage()

   private class ReturnFieldValue

  {

    private String docid          = null; //return field value for this docid

    private String fieldValue     = null;

    private String xmlFieldValue  = null; //return field value in xml format

    public void setDocid(String myDocid)

    {

      docid = myDocid;

    }

    public String getDocid()

    {

      return docid;

    }

    public void setFieldValue(String myValue)

    {

      fieldValue = myValue;

    }

    public String getFieldValue()

    {

      return fieldValue;

    }

    public void setXMLFieldValue(String xml)

    {

      xmlFieldValue = xml;

    }

    public String getXMLFieldValue()

    {

      return xmlFieldValue;

    }

  }

}