/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 465

Added by berkley about 24 years ago

Added backtrack functionality. Backtracking works by passing a returndoc parameter. There can be more than one. If a document that is hit by a query is not of type returndoc then it searches the database for a related file of type returndoc. If one is found it is displayed, if no relation is found, the original is displayed.

Support was also added for an index of relations. the table xml_relation handles the all of the relation indexing.

       private String docid = null;
       private String docname = null;
       private String doctype = null;
       private String doctitle = null;
       private String createdate = null;
       private String updatedate = null;
       private String system_id = null;
       private long rootnodeid;
       private ElementNode rootNode = null;
       private String doctitle = null;
       private TreeSet nodeRecordList = null;
       /**
-...
        */
       public DocumentImpl(Connection conn, String docid) throws McdbException
+      {
         try {
         try {
           this.conn = conn;
           this.docid = docid;
-...
       public long getRootNodeID() {
         return rootnodeid;
+      }
       /**
        * get the creation date
        */
       public String getCreateDate() {
         return createdate;
+      }
       /**
        * get the update date
        */
       public String getUpdateDate() {
         return updatedate;
+      }
       /**
        * Get the document identifier (docid)
-...
       public String getDocID() {
         return docid;
+      }
       /**
        *get the document title
        */
       public String getDocTitle() {
         return doctitle;
+      }
       /**
-...
         try {
           pstmt =
             conn.prepareStatement("SELECT docname,doctype,rootnodeid " +
                                     "FROM xml_documents " +
             conn.prepareStatement("SELECT docname, doctype, rootnodeid,doctitle, " +
                                   "date_created, date_updated " +
                                    "FROM xml_documents " +
                                    "WHERE docid LIKE ?");
           // Bind the values to the query
           pstmt.setString(1, docid);
-...
             this.docname    = rs.getString(1);
             this.doctype    = rs.getString(2);
             this.rootnodeid = rs.getLong(3);
             this.doctitle   = rs.getString(4);
             this.createdate = rs.getString(5);
             this.updatedate = rs.getString(6);
+          }
           pstmt.close();
-...
+       *
        * @param title the new title for the document
        */
       public void setTitle( String title ) {
         this.doctitle = title;
         try {

+    {
       private String[][] params = new String[200][2];
       private String urlType = null;
       private String url;
       /**
        * This constructor takes a string url and parses it according to the
-...
        */
       public metacatURL(String url) throws MalformedURLException
+      {
         this.url = url;
         parseURL(url);
+      }
-...
+      }
       /**
        * returns a string representation of this metacatURL
        */
       public String toString()
+      {
         return this.url;
+      }
       /**
        * Prints the parameters neatly to system.out
        */
       public void printParams()

        * This method prints sql based upon the &lt;returnfield&gt; tag in the
        * pathquery document.  This allows for customization of the
        * returned fields
        * @param doclist the list of document ids to search by
        */
       public String printExtendedSQL()
       public String printExtendedSQL(String doclist)
+      {
         StringBuffer self = new StringBuffer();
         self.append("select xml_nodes.docid, xml_index.path, xml_nodes.nodedata ");
-...
+          }
+        }
         self.append(") AND xml_nodes.docid in (");
         self.append(query.printSQL());
         //self.append(query.printSQL());
         self.append(doclist);
         self.append(")");
         self.append(" AND xml_nodes.nodetype = 'TEXT'");
         //System.out.println(self.toString());
         return self.toString();
+      }
       public static String printRelationSQL(String docid)
+      {
         StringBuffer self = new StringBuffer();
         self.append("select subject, relationship, object from xml_relation ");
         self.append("where subject like '").append(docid).append("'");
         return self.toString();
+      }
       /**
+       *
        * Prints sql that returns all relations in the database.
        */
       public static String printPackageSQL()
+      {
-...
+      }
       /**
        * Prints sql that returns all relations in the database that were input
        * under a specific docid
        * @param docid the docid to search for.
        */
       public static String printPackageSQL(String docid)
+      {
         StringBuffer self = new StringBuffer();
         self.append("select z.nodedata, x.nodedata, y.nodedata from ");
         self.append("(select nodeid, parentnodeid from xml_index where path like ");
         self.append("'package/relation/subject') s, (select nodeid, parentnodeid ");
         self.append("from xml_index where path like ");
         self.append("'package/relation/relationship') rel, ");
         self.append("(select nodeid, parentnodeid from xml_index where path like ");
         self.append("'package/relation/object') o, ");
         self.append("xml_nodes x, xml_nodes y, xml_nodes z ");
         self.append("where s.parentnodeid = rel.parentnodeid ");
         self.append("and rel.parentnodeid = o.parentnodeid ");
         self.append("and x.parentnodeid in rel.nodeid ");
         self.append("and y.parentnodeid in o.nodeid ");
         self.append("and z.parentnodeid in s.nodeid ");
         self.append("and z.docid like '").append(docid).append("'");
         return self.toString();
+      }
       /**
        * Returns all of the relations that has a certain docid in the subject
        * or the object.
+       *
        * @param docid the docid to search for
        */
       public static String printPackageSQL(String subDocidURL, String objDocidURL)
+      {
         StringBuffer self = new StringBuffer();
         self.append("select z.nodedata, x.nodedata, y.nodedata from ");
         self.append("(select nodeid, parentnodeid from xml_index where path like ");
         self.append("'package/relation/subject') s, (select nodeid, parentnodeid ");
         self.append("from xml_index where path like ");
         self.append("'package/relation/relationship') rel, ");
         self.append("(select nodeid, parentnodeid from xml_index where path like ");
         self.append("'package/relation/object') o, ");
         self.append("xml_nodes x, xml_nodes y, xml_nodes z ");
         self.append("where s.parentnodeid = rel.parentnodeid ");
         self.append("and rel.parentnodeid = o.parentnodeid ");
         self.append("and x.parentnodeid in rel.nodeid ");
         self.append("and y.parentnodeid in o.nodeid ");
         self.append("and z.parentnodeid in s.nodeid ");
         self.append("and (z.nodedata like '");
         self.append(subDocidURL);
         self.append("' or y.nodedata like '");
         self.append(objDocidURL);
         self.append("')");
         return self.toString();
+      }
       public static String printGetDocByDoctypeSQL(String docid)
+      {
         StringBuffer self = new StringBuffer();
         self.append("SELECT docid,docname,doctype,doctitle,");
         self.append("date_created, date_updated ");
         self.append("FROM xml_documents WHERE docid IN (");
         self.append(docid).append(")");
         return self.toString();
+      }
       /**
        * create a String description of the query that this instance represents.
        * This should become a way to get the XML serialization of the query.
        */
-...
     /**
      * '$Log$
      * 'Revision 1.15  2000/09/15 19:52:12  berkley
      * 'Added functionality for package specifications.  metacatservlet now contains a new action called getrelateddocument that handles retrieving related documents using the metacatURL specification (metacatURL.java).  DBQuery contains new code in runQuery that embeds relation tags in the returned hashtable describing the documents related to each docid.  querySpecification contains a new method which prints the sql that does the relation query.
      * '
      * 'Revision 1.14  2000/08/31 21:20:39  berkley
      * 'changed xslf for new returnfield scheme.  the returnfields are now returned as <param name="<returnfield>"> tags.
      * 'hThe sql for the returnfield query was redone to fix a previous problem with slow queries

       private Connection	conn = null;
       private String	parserName = null;
       private MetaCatUtil util = new MetaCatUtil();
       /**
        * the main routine used to test the DBQuery utility.
        * <p>
-...
         this.parserName = parserName;
+      }
       public Hashtable findDocuments(Reader xmlquery, String user, String group)
+      {
         return findDocuments(xmlquery, user, group, null);
+      }
       /**
        * 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
        * @param returndoc an array of document types to backtrack against.
        */
       public Hashtable findDocuments(Reader xmlquery, String user, String group)
              //throws Exception
       public Hashtable findDocuments(Reader xmlquery, String user, String group,
                                      String[] returndoc)
+      {
           Hashtable	 docListResult = new Hashtable();
           PreparedStatement pstmt;
-...
           String fielddata = null;
           String relation = null;
           StringBuffer document = null;
           Vector returndocVec = new Vector();
           if(returndoc != null)
           {//add the returndoc elements to a vector for easier manipulation
             for(int i=0; i<returndoc.length; i++)
+            {
               returndocVec.add(new String((String)returndoc[i]));
+            }
+          }
           try {
             // Get the XML query and covert it into a SQL statment
             QuerySpecification qspec = new QuerySpecification(xmlquery,
-...
               createDate = rs.getString(5);
               updateDate = rs.getString(6);
               if(returndocVec.size() != 0 && !returndocVec.contains(doctype))
               { //there are returndocs to match (backtracking can now be performed).
                 //System.out.println("olddoctype: " + doctype);
                 StringBuffer btBuf = new StringBuffer();
                 btBuf.append("select object from xml_relation where ");
                 btBuf.append("objdoctype in (");
                 //build the doctype list for the backtracking sql statement
                 for(int i=0; i<returndocVec.size(); i++)
+                {
                   btBuf.append("'").append((String)returndocVec.get(i)).append("'");
                   if(i != (returndocVec.size() - 1))
+                  {
                     btBuf.append(", ");
+                  }
+                }
                 btBuf.append(") ");
                 btBuf.append("and subject like '");
                 btBuf.append("metacat://docid#").append(docid).append("'");
                 pstmt = conn.prepareStatement(btBuf.toString());
                 pstmt.execute();
                 ResultSet btrs = pstmt.getResultSet();
                 boolean hasBtRows = btrs.next();
                 if(hasBtRows)
                 { //there was a backtrackable document found
                   DocumentImpl xmldoc = null;
                   //System.out.println("document found is: " + btrs.getString(1));
                   metacatURL objURL = new metacatURL(btrs.getString(1));
                   try
+                  {
                     xmldoc = new DocumentImpl(conn, objURL.getParam(0)[1]);
+                  }
                   catch(Exception e)
+                  {
                     System.out.println("Error getting document: " + e.getMessage());
+                  }
                   docid   = xmldoc.getDocID();
                   docname = xmldoc.getDocname();
                   doctype = xmldoc.getDoctype();
                   doctitle = xmldoc.getDocTitle();
                   createDate = xmldoc.getCreateDate();
                   updateDate = xmldoc.getUpdateDate();
                   //System.out.println("docname: " + docname + " doctype: " + doctype +
                   //                   " doctitle: " + doctitle + " createdate: " +
                   //                   createDate + " updatedate: " + updateDate);
+                }
                 btrs.close();
+              }
               document = new StringBuffer();
               document.append("<docid>").append(docid).append("</docid>");
               if (docname != null) {
                 document.append("<docname>" + docname + "</docname>");
               //System.out.println("packagdoctype: " + util.getOption("packagedoctype"));
               if(!doctype.equals(util.getOption("packagedoctype")))
+              {
                 document.append("<docid>").append(docid).append("</docid>");
                 if (docname != null) {
                   document.append("<docname>" + docname + "</docname>");
+                }
                 if (doctype != null) {
                   document.append("<doctype>" + doctype + "</doctype>");
+                }
                 if (doctitle != null) {
                   document.append("<doctitle>" + doctitle + "</doctitle>");
+                }
                 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());
+              }
               if (doctype != null) {
                 document.append("<doctype>" + doctype + "</doctype>");
+              }
               if (doctitle != null) {
                 document.append("<doctitle>" + doctitle + "</doctitle>");
+              }
               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());
               // Advance to the next record in the cursor
               tableHasRows = rs.next();
+            }
-...
+            {
               Vector extendedFields = new Vector(qspec.getReturnFieldList());
               Vector results = new Vector();
               pstmt = conn.prepareStatement(qspec.printExtendedSQL());
               Enumeration keylist = docListResult.keys();
               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 = conn.prepareStatement(qspec.printExtendedSQL(
                                             doclist.toString()));
               pstmt.execute();
               rs = pstmt.getResultSet();
               tableHasRows = rs.next();
-...
+              }
+            }
             pstmt = conn.prepareStatement(qspec.printPackageSQL());
             pstmt.execute();
             rs = pstmt.getResultSet();
             tableHasRows = rs.next();
             String[][] relations = new String[2000][3];
             int relLength=0;
             while(tableHasRows)
             //this loop adds the relation data to the resultdoc
             //this code might be able to be added to the backtracking code above
             Enumeration docidkeys = docListResult.keys();
             while(docidkeys.hasMoreElements())
+            {
               relations[relLength][0] = rs.getString(1).trim();
               relations[relLength][1] = rs.getString(2).trim();
               relations[relLength][2] = rs.getString(3).trim();
               relLength++;
               //this get's direct relations from the data.  i.e. those relations
               //where the docid of the current document is in the subject tag.
               docid = rs.getString(1);
               metacatURL murl = new metacatURL(docid);
               if(murl.getURLType().equals("metacat"))
               {//we only want to process metacat urls here.
                 String[] tempparam = murl.getParam(0);
                 if(tempparam[0].equals("docid"))
+                {
                   docid = tempparam[1];
                   document = new StringBuffer();
                   document.append("<relation>");
                   document.append("<relationtype>").append(rs.getString(2));
                   document.append("</relationtype>");
                   document.append("<relationdoc>").append(rs.getString(3));
                   document.append("</relationdoc>");
                   document.append("</relation>");
                   tableHasRows = rs.next();
                   if(docListResult.containsKey(docid))
               String docidkey = (String)docidkeys.nextElement();
               pstmt = conn.prepareStatement(
                       qspec.printRelationSQL("metacat://docid#" + docidkey));
               pstmt.execute();
               rs = pstmt.getResultSet();
               tableHasRows = rs.next();
               while(tableHasRows)
+              {
                 String sub = rs.getString(1);
                 String rel = rs.getString(2);
                 String obj = rs.getString(3);
                 metacatURL murl = new metacatURL(sub);
                 if(murl.getURLType().equals("metacat"))
                 {//we only want to process metacat urls here.
                   String[] tempparam = murl.getParam(0);
                   if(tempparam[0].equals("docid") && tempparam[1].equals(docidkey))
+                  {
                     String removedelement = (String)docListResult.remove(docid);
                     docListResult.put(docid, removedelement + document.toString());
                     document = new StringBuffer();
                     document.append("<relation>");
                     document.append("<relationtype>").append(rel);
                     document.append("</relationtype>");
                     document.append("<relationdoc>").append(obj);
                     document.append("</relationdoc>");
                     document.append("</relation>");
                     String removedelement = (String)docListResult.remove(docidkey);
                     docListResult.put(docidkey, removedelement + document.toString());
+                  }
                   else
+                  {
                     docListResult.put(docid, document.toString());
+                  }
+                }
                 else
+                {
                   //throw new Exception("Error in url. The first parameter must " +
                   //                    "be the docid.");
                   System.err.println("DBQuery: error in url");
+                }
                 tableHasRows = rs.next();
+              }
+            }
             //this loop handles transitive relations. i.e. if two relation tags
             //both have the same object then the subject of each are related.
             for(int i=0; i<relLength; i++)
+            {
               for(int j=0; j<relLength; j++)
+              {
                 if(i != j)
+                {
                   if(relations[i][2].equals(relations[j][2]))
                   {//the objects are the same.
                     metacatURL murl = new metacatURL(relations[i][0]);
                     //relations[i][0] contains the docid of document that
                     //the new document is related to.
                     String[] tempparam = murl.getParam(0);
                     if(tempparam[0].equals("docid"))
+                    {
                       docid = tempparam[1];
                       document = new StringBuffer();
                       document.append("<relation>");
                       document.append("<relationtype>").append(relations[j][1]);
                       document.append("</relationtype>");
                       document.append("<relationdoc>").append(relations[j][0]);
                       //the relation is to the subject of the new document
                       //instead of the object.
                       //   direct relation    transitive relation
                       // |-----------------|  |-----------------|
                       // subject -> (object = object) -> subject
                       document.append("</relationdoc>");
                       document.append("</relation>");
                       if(docListResult.containsKey(docid))
+                      {
                         String removedelement = (String)docListResult.remove(docid);
                         docListResult.put(docid, removedelement +
                                           document.toString());
+                      }
                       else
+                      {
                         docListResult.put(docid, document.toString());
+                      }
+                    }
+                  }
+                }
+              }
+            }
             pstmt.close();
           } catch (SQLException e) {
             System.err.println("Error getting id: " + e.getMessage());
-...
     /**
      * '$Log$
      * 'Revision 1.20  2000/09/15 19:52:11  berkley
      * 'Added functionality for package specifications.  metacatservlet now contains a new action called getrelateddocument that handles retrieving related documents using the metacatURL specification (metacatURL.java).  DBQuery contains new code in runQuery that embeds relation tags in the returned hashtable describing the documents related to each docid.  querySpecification contains a new method which prints the sql that does the relation query.
      * '
      * 'Revision 1.19  2000/09/12 17:37:07  bojilova
      * 'added check from "read" permission on "query" and "squery" actions
      * 'for connected user or for "public" connection

       // in defaultdocpath dir
       private String executescript  = null;
       /**
        * Initialize the servlet by creating appropriate database connections
        */
-...
           PrintWriter out = response.getWriter();
           out.println("Error: action not registered.  Please report this error.");
+        }
         util.closeConnections();
         // Close the stream to the client
         //out.close();
+      }
-...
+      {
         String xmlquery = ((String[])params.get("query"))[0];
         String qformat = ((String[])params.get("qformat"))[0];
         Hashtable doclist = runQuery(xmlquery, user, group);
         String resultdoc = createResultDocument(doclist, transformQuery(xmlquery));
         String resultdoc = null;
         String[] returndoc = null;
         if(params.contains("returndoc"))
+        {
           returndoc = (String[])params.get("returndoc");
+        }
         Hashtable doclist = runQuery(xmlquery, user, group, returndoc);
         //String resultdoc = createResultDocument(doclist, transformQuery(xmlquery));
         resultdoc = createResultDocument(doclist, transformQuery(xmlquery));
         //format and transform the results
         if(qformat.equals("html")) {
           transformResultset(resultdoc, response, out);
-...
                      HttpServletResponse response, String user, String group)
+      {
         //create the query and run it
         String[] returndoc = null;
         if(params.containsKey("returndoc"))
+        {
           returndoc = (String[])params.get("returndoc");
+        }
         String xmlquery = DBQuery.createSQuery(params);
         Hashtable doclist = runQuery(xmlquery, user, group);
         String qformat = ((String[])params.get("qformat"))[0];
         String resultdoc = createResultDocument(doclist, transformQuery(params));
         Hashtable doclist = runQuery(xmlquery, user, group, returndoc);
         String qformat = ((String[])params.get("qformat"))[0];
         String resultdoc = null;
         resultdoc = createResultDocument(doclist, transformQuery(params));
         //format and transform the results
         if(qformat.equals("html")) {
-...
+       *
        * @param xmlquery the query to run
        */
       private Hashtable runQuery(String xmlquery, String user, String group)
       private Hashtable runQuery(String xmlquery, String user, String group,
                                  String[] returndoc)
+      {
         Hashtable doclist=null;
         Connection conn = null;
-...
+        {
           conn = util.getConnection();
           DBQuery queryobj = new DBQuery(conn, saxparser);
           doclist = queryobj.findDocuments(new StringReader(xmlquery),user,group);
           doclist = queryobj.findDocuments(new StringReader(xmlquery),user,group,
                                            returndoc);
           util.returnConnection(conn);
           return doclist;
+        }
-...
       /**
        * Transforms a hashtable of documents to an xml or html result.
        * If there is a returndoc, then it only displays documents of
        * whatever type returndoc represents.  If a result is found in a document
        * that is not of type returndoc then this attempts to find a relation
        * between this document and one that satifies the returndoc doctype.
+       *
        * @param doclist- the hashtable to transform
        * @param xmlquery- the query that returned the dolist result
        * @param resultdoc- the document type to backtrack to.
        */
       protected String createResultDocument(Hashtable doclist, String xmlquery)
+      {
-...
         String document = null;
         resultset.append("<?xml version=\"1.0\"?>\n");
         resultset.append("<resultset>\n");
         resultset.append("  <query>" + xmlquery + "</query>");
         Enumeration doclistkeys = doclist.keys();
         while (doclistkeys.hasMoreElements())
+        {
-...
               String[] murlParams = murl.getParam(0);
               if(murlParams[0].equals("docid"))
               {//the docid should be first
                 murl.printParams();
                 //murl.printParams();
                 docid = murlParams[1]; //get the docid value
                 conn = util.getConnection();
                 xmldoc = new DocumentImpl(conn, docid);
-...
                         accNumber = null;
+                    }
                     newdocid = DocumentImpl.write(conn, xml, doAction, accNumber,
                                                                       user, group);
                                                   user, group);
                     DocumentImpl xmldoc = new DocumentImpl(conn, newdocid);
                    //if this is a package file then write the package info to
                    //the xml_relation table. relationHandler checks to see
                    //if it is a package file so you don't have to do it here.
                    relationHandler rth = new relationHandler(xmldoc);
                 } catch (NullPointerException npe) {
                   newdocid = DocumentImpl.write(conn,xml,doAction,null,user,group);
+                }

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 465

Added by berkley about 24 years ago