Metacat

/**

 *    Purpose: A Class that searches a relational DB for elements and

 *             attributes that have free text matches a query string,

 *             or structured query matches to a path specified node in the

 *             XML hierarchy.  It returns a result set consisting of the

 *             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

 *    Authors: Matt Jones

 *     '$Date$'

 * '$Revision$'

 * 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

import java.io.*;

import java.net.MalformedURLException;

import java.sql.*;

import java.util.Stack;

import java.util.Hashtable;

import java.util.Enumeration;

import java.io.FileWriter;

import java.io.BufferedWriter;

/**

 * attributes that have free text matches a query string,

 * or structured query matches to a path specified node in the

 * XML hierarchy.  It returns a result set consisting of the

 * document ID for each document that satisfies the query

public class DBQuery {

  static final int WRITE = 2;

  static final int READ = 4;

  private String  parserName = null;

   * the main routine used to test the DBQuery utility.

   * Usage: java DBQuery <xmlfile>

  static public void main(String[] args) {

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

     } else {

        try {

          boolean showRuntime = false;

          boolean useXMLIndex = false;

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

            showRuntime = true;

            i++;

          }

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

            useXMLIndex = true;

            i++;

          }

          String xmlfile  = args[i];

          // Time the request if asked for

          double startTime = System.currentTimeMillis();

          Connection dbconn = util.openDBConnection();

          String document = null;

            Enumeration doclist = nodelist.keys();

            while (doclist.hasMoreElements()) {

              docid = (String)doclist.nextElement();

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

              result.append("  <document>\n    " + document +

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

            }

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

          double stopTime = System.currentTimeMillis();

            System.out.print("  " + dbOpenTime);

            System.out.print("  " + readTime);

            System.out.print("  " + nodelist.size());

            System.out.println();

          //System.out.println(result);

          //write into a file "result.txt"

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

            FileWriter fw = new FileWriter(f);

            BufferedWriter out = new BufferedWriter(fw);

            out.write(result.toString());

            out.flush();

            out.close();

            fw.close();

          }

        }

        catch (Exception e) {

          e.printStackTrace(System.err);

        }

     }

  }

  /**

   * construct an instance of the DBQuery class

   *

   * <p>Generally, one would call the findDocuments() routine after creating

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

   *

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

                         SQLException,

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

   *

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

   * @param user the username of the user

   * @param group the group of the user

   */

  public Hashtable findDocuments(Reader xmlquery, String user, String group)

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

   *

   * @param group the group of the user

      String doctype = null;

      String updateDate = null;

      String fieldname = null;

      String fielddata = null;

        }

        ResultSet rs = pstmt.getResultSet();

        boolean tableHasRows = rs.next();

        {

            tableHasRows = rs.next();

            continue;

          }

          doctype = rs.getString(3);

          updateDate = rs.getString(5);

          rev = rs.getInt(6);

          // otherwise, just return the document that was hit

          Vector returndocVec = qspec.getReturnDocList();

          {

            {

              btBuf.append("'").append((String)returndocVec.get(i)).append("'");

                btBuf.append(", ");

            btBuf.append(") ");

            btBuf.append("and (subject like '");

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

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

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

                                       prepareStatement(btBuf.toString());

            ResultSet btrs = npstmt.getResultSet();

              DocumentImpl xmldoc = null;

              //MetacatURL objURL = new MetacatURL(packageDocid);

              {

                xmldoc = new DocumentImpl(dbconn, packageDocid);

              catch(Exception e)

              {

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

              docid   = xmldoc.getDocID();

              docname = xmldoc.getDocname();

              doctype = xmldoc.getDoctype();

              createDate = xmldoc.getCreateDate();

              updateDate = xmldoc.getUpdateDate();

              document = new StringBuffer();

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

              completeDocid += rev;

              document.append("<docid>").append(completeDocid);

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

              if (docname != null) {

                document.append("<docname>" + docname + "</docname>");

              }

              if (doctype != null) {

                document.append("<doctype>" + doctype + "</doctype>");

              }

              if (createDate != null) {

                document.append("<createdate>" + createDate + "</createdate>");

              }

              if (updateDate != null) {

                document.append("<updatedate>" + updateDate + "</updatedate>");

              }

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

            completeDocid += rev;

            document.append("<docid>").append(completeDocid).append("</docid>");

              document.append("<docname>" + docname + "</docname>");

            }

            if (doctype != null) {

              document.append("<doctype>" + doctype + "</doctype>");

            }

            }

            }

            // Store the document id and the root node id

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

          // Advance to the next record in the cursor

          tableHasRows = rs.next();

        }

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

          Vector results = new Vector();

          StringBuffer doclist = new StringBuffer();

          while(keylist.hasMoreElements())

          {

            doclist.append("'");

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

            doclist.append("',");

          }

          doclist.deleteCharAt(doclist.length()-1); //remove the last comma

          pstmt = dbconn.prepareStatement(qspec.printExtendedSQL(

          rs = pstmt.getResultSet();

          tableHasRows = rs.next();

          while(tableHasRows)

          {

            docid = rs.getString(1);

              // Advance to the next record in the cursor

              tableHasRows = rs.next();

              continue;

            }

            fielddata = rs.getString(3);

            document = new StringBuffer();

            tableHasRows = rs.next();

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

              docListResult.put(docid, removedelement + document.toString());

            }

            else

            {

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

            }

          }

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

        Enumeration docidkeys = docListResult.keys();

        while(docidkeys.hasMoreElements())

          String connstring = "%docid=";

          rs = pstmt.getResultSet();

          tableHasRows = rs.next();

          while(tableHasRows)

          {

            String sub = rs.getString(1);

            String rel = rs.getString(2);

            String obj = rs.getString(3);

            String objDT = rs.getString(5);

            //we only want to process metacat urls here.

            //if (murl.getProtocol().equals("metacat")) {

              //String[] tempparam = murl.getParam(0);

              //if (tempparam[0].equals("docid") && tempparam[1].equals(docidkey))

              //{

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

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

                if (!subDT.equals("null")) {

                  document.append("<subjectdoctype>").append(subDT);

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

                }

                document.append("<relationship>").append(rel);

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

                document.append("<object>").append(obj);

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

                if (!objDT.equals("null")) {

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

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

                }

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

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

                                  document.toString());

            //}

          pstmt.close();

                           e.getMessage());

        try

        {

          dbconn.close();

        }

        catch(SQLException sqle)

        {

          System.out.println("error closing conn in DBQuery.findDocuments");

        }

      }

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

  }

  /**

   * If the node appears more than once, the contents are returned

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

   * @param conn a database connection-this allows this method to be static

   */

  public static Object[] getNodeContent(String nodename, String docid,

                                        Connection conn)

  {

    StringBuffer query = new StringBuffer();

    Vector result = new Vector();

    query.append("(select nodeid from xml_index where path like '");

    query.append(nodename);

    query.append("' and docid like '").append(docid).append("')");

    try

    {

      pstmt = conn.prepareStatement(query.toString());

      // Execute the SQL query using the JDBC connection

      pstmt.execute();

      ResultSet rs = pstmt.getResultSet();

      boolean tableHasRows = rs.next();

      while (tableHasRows)

      {

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

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

        tableHasRows = rs.next();

      }

    }

    catch (SQLException e)

    {

      try

      {

        pstmt.close();

      }

      catch(SQLException sqle) {}

    }

  }

  /**

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

   * structured query engine

   *

    StringBuffer query = new StringBuffer();

    Enumeration keys;

    String searchmode = null;

    Object nextelement;

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

    if (params.containsKey("meta_file_id"))

      for(int i=0; i<returnDoctypes.length; i++)

      {

        String doctype = (String)returnDoctypes[i];

        if (!doctype.equals("any") &&

            !doctype.equals("ANY") &&

            !doctype.equals("") )

        {

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

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

        }

      }

    {

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

      for(int i=0; i<filterDoctypes.length; i++)

      {

        query.append("<filterdoctype>").append(filterDoctypes[i]);

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

      }

    }

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

      for(int i=0; i<returnfield.length; i++)

      {

        query.append("<returnfield>").append(returnfield[i]);

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

      }

    }

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

      for(int i=0; i<owner.length; i++)

      {

        query.append("<owner>").append(owner[i]);

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

      }

    }

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

      for(int i=0; i<site.length; i++)

      {

        query.append("<site>").append(site[i]);

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

      }

    }

      query.append("<querygroup operator=\"" +

    else

    { //the default operator is UNION

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

    }

      casesensitive = ((String[])params.get("casesensitive"))[0];

    }

    else

    {

      casesensitive = "false";

    }

      searchmode = ((String[])params.get("searchmode"))[0];

    }

    else

    {

      searchmode = "contains";

    }

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

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

       //allow for more than one value for anyfield

       for(int i=0; i<anyfield.length; i++)

           query.append("<queryterm casesensitive=\"" + casesensitive +

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

                        "</value></queryterm>");

    //and attempts to query for the field specified

    //by the parameter.

    elements = params.elements();

    keys = params.keys();

    while(keys.hasMoreElements() && elements.hasMoreElements())