/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 706

Added by bojilova over 23 years ago

included flag in DBQuery to run pathqueries with or without the index,
but for the command line only.

              QuerySpecification qspec =
                      new QuerySpecification(xml, util.getOption("saxparser"),
                                             util.getOption("accNumberSeparator"));
              System.out.println(qspec.printSQL());
              boolean useXMLIndex = false;
              System.out.println(qspec.printSQL(useXMLIndex));
            } catch (IOException e) {
              System.err.println(e.getMessage());
-...
       /**
        * create a SQL serialization of the query that this instance represents
        */
       public String printSQL() {
       public String printSQL(boolean useXMLIndex) {
         StringBuffer self = new StringBuffer();
         self.append("SELECT docid,docname,doctype,");
-...
         self.append("FROM xml_documents WHERE docid IN (");
         // This determines the documents that meet the query conditions
         self.append(query.printSQL());
         self.append(query.printSQL(useXMLIndex));
         self.append(") ");
-...
         /**
          * create a SQL serialization of the query that this instance represents
          */
         public String printSQL() {
         public String printSQL(boolean useXMLIndex) {
           StringBuffer self = new StringBuffer();
           boolean first = true;
-...
+            }
             if (qobject instanceof QueryGroup) {
               QueryGroup qg = (QueryGroup)qobject;
               self.append(qg.printSQL());
               self.append(qg.printSQL(useXMLIndex));
             } else if (qobject instanceof QueryTerm) {
               QueryTerm qt = (QueryTerm)qobject;
               self.append(qt.printSQL());
               self.append(qt.printSQL(useXMLIndex));
             } else {
               System.err.println("qobject wrong type: fatal error");
+            }
-...
         /**
          * create a SQL serialization of the query that this instance represents
          */
         public String printSQL() {
         public String printSQL(boolean useXMLIndex) {
           StringBuffer self = new StringBuffer();
           // Uppercase the search string if case match is not important
-...
           if (pathexpr != null) {
             self.append(nodedataterm + " LIKE " + "'" + searchvalue + "' ");
             self.append("AND parentnodeid IN ");
             self.append("(SELECT nodeid FROM xml_index WHERE path LIKE " +
                         "'" +  pathexpr + "') " );
             // use XML Index
             if ( useXMLIndex ) {
               self.append("(SELECT nodeid FROM xml_index WHERE path LIKE " +
                           "'" +  pathexpr + "') " );
             // without using XML Index; using nested statements instead
             } else {
               self.append(useNestedStatements(pathexpr));
+            }
           } else {
             self.append(nodedataterm + " LIKE " + "'" + searchvalue + "' ");
+          }
-...
           return self.toString();
+        }
         /*
          * Constraint the query with @pathexp without using the XML Index,
          * but nested SQL statements instead. The query migth be slower.
          */
         private String useNestedStatements(String pathexpr)
+        {
           StringBuffer nestedStmts = new StringBuffer();
           Vector nodes = new Vector();
           String path = pathexpr;
           int inx = 0;
           do {
             inx = path.lastIndexOf("/");
     //System.out.println(path.substring(inx+1));
             nodes.addElement(path.substring(inx+1));
             path = path.substring(0, Math.abs(inx));
           } while ( inx > 0 );
           // nested statements
           int i = 0;
           for (i = 0; i < nodes.size()-1; i++) {
             nestedStmts.append("(SELECT nodeid FROM xml_nodes" +
                                " WHERE nodename LIKE '" +
                                  (String)nodes.elementAt(i) + "'" +
                                " AND parentnodeid IN ");
+          }
           // for the last statement: it is without " AND parentnodeid IN "
           nestedStmts.append("(SELECT nodeid FROM xml_nodes" +
                              " WHERE nodename LIKE '" +
                              (String)nodes.elementAt(i) + "'" );
           // node.size() number of closing brackets
           for (i = 0; i < nodes.size(); i++) {
             nestedStmts.append(")");
+          }
     //System.out.println(nestedStmts.toString());
           return nestedStmts.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.
          */
         public String toString() {
         public String toString(boolean useXMLIndex) {
           return this.printSQL();
           return this.printSQL(useXMLIndex);
+        }
+      }
+    }

     import java.util.Stack;
     import java.util.Hashtable;
     import java.util.Enumeration;
     import java.io.File;
     import java.io.FileWriter;
     import java.io.BufferedWriter;
     /**
      * A Class that searches a relational DB for elements and
-...
          if (args.length < 1)
+         {
             System.err.println("Wrong number of arguments!!!");
             System.err.println("USAGE: java DBQuery <xmlfile>");
             System.err.println("USAGE: java DBQuery [-t] [-index] <xmlfile>");
             return;
          } else {
             try {
               String xmlfile  = args[0];
               int i = 0;
               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();
               // Open a connection to the database
               MetaCatUtil   util = new MetaCatUtil();
               double startTime = System.currentTimeMillis();
               Connection dbconn = util.openDBConnection();
               double connTime = System.currentTimeMillis();
               // Execute the query
               DBQuery queryobj = new DBQuery(dbconn, util.getOption("saxparser"));
               FileReader xml = new FileReader(new File(xmlfile));
               Hashtable nodelist = null;
               nodelist = queryobj.findDocuments(xml, null, null);
               double stopTime = System.currentTimeMillis();
               nodelist = queryobj.findDocuments(xml, null, null, useXMLIndex);
               // Print the reulting document listing
               StringBuffer result = new StringBuffer();
               String document = null;
               String docid = null;
               result.append("<?xml version=\"1.0\"?>\n");
               result.append("<resultset>\n");
               // following line removed by Dan Higgins to avoid insertion of
               // query XML inside returned XML doc
               //result.append("  <query>" + xmlfile + "</query>\n");
       // following line removed by Dan Higgins to avoid insertion of query XML inside returned XML doc
       //        result.append("  <query>" + xmlfile + "</query>\n");
               Enumeration doclist = nodelist.keys();
               while (doclist.hasMoreElements()) {
                 docid = (String)doclist.nextElement();
-...
+              }
               result.append("</resultset>\n");
               System.out.println(result);
               // Time the request if asked for
               double stopTime = System.currentTimeMillis();
               double dbOpenTime = (connTime - startTime)/1000;
               double insertTime = (stopTime - connTime)/1000;
               double readTime = (stopTime - connTime)/1000;
               double executionTime = (stopTime - startTime)/1000;
               System.out.println("\n\nTotal Execution time was: " +
                                  executionTime + " seconds.");
               System.out.println("Time to open DB connection was: " + dbOpenTime +
                                  " seconds.");
               System.out.println("Time to perform query was: " + insertTime +
                                  " seconds.");
               if (showRuntime) {
                 System.out.println("\n\nTotal Execution time was: " +
                                    executionTime + " seconds.");
                 System.out.println("Time to open DB connection was: " + dbOpenTime +
                                    " seconds.");
                 System.out.println("Time to read was: " + readTime +
                                    " seconds.");
+              }
               //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) {
               System.err.println("Error in DBQuery.main");
               System.err.println(e.getMessage());
-...
         this.parserName = parserName;
+      }
       public Hashtable findDocuments(Reader xmlquery, String user, String group)
       public Hashtable findDocuments(Reader xmlquery, String user, String group,
                                      boolean useXMLIndex)
+      {
         return findDocuments(xmlquery, user, group, null);
         return findDocuments(xmlquery, user, group, null, useXMLIndex);
+      }
       public Hashtable findDocuments(Reader xmlquery, String user, String group,
                                      String[] returndoc)
+      {
         return findDocuments(xmlquery, user, group, returndoc, true);
+      }
       /**
        * routine to search the elements and attributes looking to match query
+       *
-...
        * @param returndoc an array of document types to backtrack against.
        */
       public Hashtable findDocuments(Reader xmlquery, String user, String group,
                                      String[] returndoc)
                                      String[] returndoc, boolean useXMLIndex)
+      {
         //System.out.println("in finddocuments");
           Hashtable   docListResult = new Hashtable();
-...
                                        parserName,
                                        util.getOption("accNumSeparator"));
            // System.out.println(qspec.printSQL());
             pstmt = dbconn.prepareStatement( qspec.printSQL() );
             pstmt = dbconn.prepareStatement( qspec.printSQL(useXMLIndex) );
             // Execute the SQL query using the JDBC connection
             pstmt.execute();

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 706

Added by bojilova over 23 years ago