/ - Diff - Metacat - Ecoinformatics Redmine

         public void testPrintSQL()
+        {
             try {
                 System.out.println("----------------------");
                 QuerySpecification qspec = new QuerySpecification(xml,
                         MetaCatUtil.getOption("saxparser"),
                         MetaCatUtil.getOption("accNumberSeparator"));
                 System.out.println(qspec.printSQL(true));
                 System.out.println(qspec.printSQL(false));
             } catch (IOException e) {
                 fail(e.getMessage());
+            }
-...
         public void testPrintExtendedSQL()
+        {
             try {
                 System.out.println("----------------------");
                 Hashtable controlPairs = new Hashtable();
                 QuerySpecification qspec = new QuerySpecification(xml,
                         MetaCatUtil.getOption("saxparser"),
                         MetaCatUtil.getOption("accNumberSeparator"));
                 System.out.println(qspec.printExtendedSQL("n.1.1, n.2.2", controlPairs));
                 System.out.println(
                         qspec.printExtendedSQL("'obfs.45337', 'obfs.45338', 'obfs.45346'",
                                 controlPairs, false));
             } catch (IOException e) {
                 fail(e.getMessage());
+            }

         /**
          * This method prints sql based upon the &lt;returnfield&gt; tag in the
          * pathquery document. This allows for customization of the returned fields
          * pathquery document. This allows for customization of the returned fields.
          * If the boolean useXMLIndex paramter is false, it uses a recursive query on
          * xml_nodes to find the fields to be included by their path expression, and
          * avoids the use of the xml_index table.
+         *
          * @param doclist
          *            the list of document ids to search by
          * @param unaccessableNodePair
          *            the node pair(start id and end id) which this user could not
          *            access it
          * @param useXMLIndex a boolean flag indicating whether to search using xml_index
          */
         public String printExtendedSQL(String doclist,
                 Hashtable unaccessableNodePair, boolean useXMLIndex)
+        {
             if (useXMLIndex) {
                 return printExtendedSQL(doclist, unaccessableNodePair);
             } else {
                 StringBuffer self = new StringBuffer();
                 boolean firstfield = true;
                 //put the returnfields into the query
                 //the for loop allows for multiple fields
                 for (int i = 0; i < returnFieldList.size(); i++) {
                     if (firstfield) {
                         firstfield = false;
                         self.append("(");
                     } else {
                         self.append(" UNION (");
+                    }
                     String path  = (String) returnFieldList.elementAt(i);
                     self.append("select xml_nodes.docid, ");
                     self.append("'"+ path  + "' as path, ");
                     self.append("xml_nodes.nodedata, ");
                     self.append("xml_nodes.parentnodeid ");
                     self.append("from xml_nodes, xml_documents ");
                     self.append("where parentnodeid IN ");
                     self.append(QueryTerm.useNestedStatements(path));
                     self.append(" AND xml_nodes.docid in (");
                     self.append(doclist);
                     self.append(")");
                     self.append(" AND xml_nodes.nodetype = 'TEXT'");
                     self.append(" AND xml_nodes.rootnodeid = xml_documents.rootnodeid");
                     // add control part for extended query
                     Enumeration en = unaccessableNodePair.keys();
                     while (en.hasMoreElements()) {
                         // Get control pairs in object
                         Long startNodeIdObject = (Long) en.nextElement();
                         Long endNodeIdObject = (Long) unaccessableNodePair
                                 .get(startNodeIdObject);
                         // change it to long
                         long startNodeId = startNodeIdObject.longValue();
                         long endNodeId = endNodeIdObject.longValue();
                         // add into query
                         self.append(" AND( xml_nodes.nodeid < ");
                         self.append(startNodeId);
                         self.append(" OR xml_nodes.nodeid > ");
                         self.append(endNodeId);
                         self.append(")");
+                    }
                     self.append(")");
+                }
                 return self.toString();
+            }
+        }
         /**
          * This method prints sql based upon the &lt;returnfield&gt; tag in the
          * pathquery document. This allows for customization of the returned fields.
          * It uses the xml_index table and so assumes that this table has been
          * built.
+         *
          * @param doclist
          *            the list of document ids to search by
          * @param unaccessableNodePair
          *            the node pair(start id and end id) which this user could not
          *            access it
          */
         public String printExtendedSQL(String doclist,
         public String printExtendedSQL(String doclist,
                 Hashtable unaccessableNodePair)
+        {
             StringBuffer self = new StringBuffer();

         self.append(") ");
         return self.toString();
+      }
       /**
        * returns a string array of the contents of a particular node.
        * If the node appears more than once, the contents are returned
-...
         try
+        {
           dbconn=DBConnectionPool.getDBConnection("DBQuery.getNodeContent");
             serialNumber=dbconn.getCheckOutSerialNumber();
           serialNumber=dbconn.getCheckOutSerialNumber();
           pstmt = dbconn.prepareStatement(query.toString());
           // Execute the SQL query using the JDBC connection

          * 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)
         public static String useNestedStatements(String pathexpr)
+        {
             StringBuffer nestedStmts = new StringBuffer();
             Vector nodes = new Vector();

Project

General

Profile

Metacat

Revision 2069

Added by Matt Jones over 20 years ago