/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 172

Added by Matt Jones over 24 years ago

completed work on creating structured query prototype in DBQuery and QuerySpecification classes

     /**
      *      Name: QuerySpecification.java
      *   Purpose: A Class that represents a structured query, and can be
      *            constructed from an XML serialization
      *            constructed from an XML serialization conforming to
      *            pathquery.dtd. The printSQL() method can be used to print
      *            a SQL serialization of the query.
      * Copyright: 2000 Regents of the University of California and the
      *            National Center for Ecological Analysis and Synthesis
      *   Authors: Matt Jones
-...
     import org.xml.sax.SAXException;
     import org.xml.sax.SAXParseException;
     import org.xml.sax.helpers.ParserFactory;
     //import oracle.xml.parser.v2.SAXParser;
     /**
      * A Class that represents a structured query,and can be constructed from an
      * XML serialization conforming to "pathquery.dtd"
      * A Class that represents a structured query, and can be
      * constructed from an XML serialization conforming to @see pathquery.dtd.
      * The printSQL() method can be used to print a SQL serialization of the query.
      */
     public class QuerySpecification extends HandlerBase {
-...
       // Query data structures
       private String meta_file_id;
       private String querytitle;
       private Vector doctypeList;
       private QueryGroup query = null;
       private Stack elementStack;
       private Stack queryStack;
       private String currentValue;
       private String currentPathexpr;
       private String parserName = null;
       /**
        * construct an instance of the QuerySpecification class
+       *
        * @param queryspec the XML representation of the query as a Reader
        * @param queryspec the XML representation of the query (should conform
        *                  to pathquery.dtd) as a Reader
        * @param parserName the fully qualified name of a Java Class implementing
        *                  the org.xml.sax.Parser interface
        */
       public QuerySpecification( Reader queryspec ) throws IOException {
       public QuerySpecification( Reader queryspec, String parserName )
              throws IOException {
         super();
         // Initialize the stack
         // Initialize the class variables
         doctypeList = new Vector();
         elementStack = new Stack();
         queryStack   = new Stack();
         this.parserName = parserName;
         // Initialize the parser and read the queryspec
         Parser parser = initializeParser();
-...
       /**
        * construct an instance of the QuerySpecification class
+       *
        * @param queryspec the XML representation of the query as a String
        * @param queryspec the XML representation of the query (should conform
        *                  to pathquery.dtd) as a String
        * @param parserName the fully qualified name of a Java Class implementing
        *                  the org.xml.sax.Parser interface
        */
       public QuerySpecification( String queryspec ) throws IOException {
         this(new StringReader(queryspec));
       public QuerySpecification( String queryspec, String parserName )
              throws IOException {
         this(new StringReader(queryspec), parserName);
+      }
       /** Main routine for testing */
-...
            try {
              FileReader xml = new FileReader(new File(xmlfile));
              QuerySpecification qspec = new QuerySpecification(xml);
              System.out.println(qspec.toSQL());
              QuerySpecification qspec = new QuerySpecification(xml, DEFAULT_PARSER);
              System.out.println(qspec.printSQL());
            } catch (IOException e) {
              System.err.println(e.getMessage());
+           }
-...
+         }
+      }
       /**
        * Set up the SAX parser for reading the XML serialized query
        */
       private Parser initializeParser() {
         Parser parser = null;
         //
         // Set up the SAX document handlers for parsing
         //
         try {
           // Get an instance of the parser
           parser = ParserFactory.makeParser(DEFAULT_PARSER);
           parser = ParserFactory.makeParser(parserName);
           // Set the DocumentHandler to this instance
           parser.setDocumentHandler(this);
-...
         return parser;
+      }
       /**
        * callback method used by the SAX Parser when the start tag of an
        * element is detected. Used in this context to parse and store
        * the query information in class variables.
        */
       public void startElement (String name, AttributeList atts)
              throws SAXException {
-...
+        }
+      }
       /**
        * callback method used by the SAX Parser when the end tag of an
        * element is detected. Used in this context to parse and store
        * the query information in class variables.
        */
       public void endElement (String name) throws SAXException {
         BasicNode leaving = (BasicNode)elementStack.pop();
         if (leaving.getTagName().equals("queryterm")) {
-...
+        }
+      }
       /**
        * callback method used by the SAX Parser when the text sequences of an
        * xml stream are detected. Used in this context to parse and store
        * the query information in class variables.
        */
       public void characters(char ch[], int start, int length) {
         String inputString = new String(ch, start, length);
-...
           currentValue = inputString;
         } else if (currentTag.equals("pathexpr")) {
           currentPathexpr = inputString;
         } else if (currentTag.equals("returndoctype")) {
           doctypeList.add(inputString);
+        }
+      }
       public String toSQL() {
       /**
        * create a SQL serialization of the query that this instance represents
        */
       public String printSQL() {
         StringBuffer self = new StringBuffer();
         // This determines the returned results
         self.append("SELECT docid,docname,doctype,doctitle ");
         self.append("FROM xml_documents WHERE docid IN (");
         self.append("SELECT DISTINCT docid FROM xml_nodes WHERE \n");
         self.append(query.toSQL());
         // This determines the WHERE conditions
         self.append(query.printSQL());
         self.append(") ");
         // Add SQL to filter for doctypes requested in the query
         if (!doctypeList.isEmpty()) {
           boolean firstdoctype = true;
           self.append(" AND (");
           Enumeration en = doctypeList.elements();
           while (en.hasMoreElements()) {
             String currentDoctype = (String)en.nextElement();
             if (firstdoctype) {
               firstdoctype = false;
               self.append(" doctype = '" + currentDoctype + "'");
             } else {
               self.append(" OR doctype = '" + currentDoctype + "'");
+            }
+          }
           self.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.
        */
       public String toString() {
         return "meta_file_id=" + meta_file_id + "\n" +
                "querytitle=" + querytitle + "\n" + query;
-...
         private String booleantype = null; // indicates how query terms are combined
         private Vector children = null;    // the list of query terms and groups
         /**
          * construct a new QueryGroup
+         *
          * @param booleantype the boolean conector used to connect query terms
          *                    in this query group
          */
         public QueryGroup(String booleantype) {
           this.booleantype = booleantype;
           children = new Vector();
+        }
         /**
          * Add a child QueryGroup to this QueryGroup
+         *
          * @param qgroup the query group to be added to the list of terms
          */
         public void addChild(QueryGroup qgroup) {
           children.add((Object)qgroup);
+        }
         /**
          * Add a child QueryTerm to this QueryGroup
+         *
          * @param qterm the query term to be added to the list of terms
          */
         public void addChild(QueryTerm qterm) {
           children.add((Object)qterm);
+        }
         /**
          * Retrieve an Enumeration of query terms for this QueryGroup
          */
         public Enumeration getChildren() {
           return children.elements();
+        }
         public String toSQL() {
         /**
          * create a SQL serialization of the query that this instance represents
          */
         public String printSQL() {
           StringBuffer self = new StringBuffer();
           boolean first = true;
-...
+            }
             if (qobject instanceof QueryGroup) {
               QueryGroup qg = (QueryGroup)qobject;
               self.append(qg.toSQL());
               self.append(qg.printSQL());
             } else if (qobject instanceof QueryTerm) {
               QueryTerm qt = (QueryTerm)qobject;
               self.append(qt.toSQL());
               self.append(qt.printSQL());
             } else {
               System.err.println("qobject wrong type: fatal error");
+            }
-...
           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.
          */
         public String toString() {
           StringBuffer self = new StringBuffer();
-...
         private String value = null;
         private String pathexpr = null;
         /**
          * Construct a new instance of a query term for a free text search
          * (using the value only)
+         *
          * @param casesensitive flag indicating whether case is used to match
          * @param searchmode determines what kind of substring match is performed
          *        (one of starts-with|ends-with|contains|matches-exactly)
          * @param value the text value to match
          */
         public QueryTerm(boolean casesensitive, String searchmode,
                          String value) {
           this.casesensitive = casesensitive;
-...
           this.value = value;
+        }
         /**
          * Construct a new instance of a query term for a structured search
          * (matching the value only for those nodes in the pathexpr)
+         *
          * @param casesensitive flag indicating whether case is used to match
          * @param searchmode determines what kind of substring match is performed
          *        (one of starts-with|ends-with|contains|matches-exactly)
          * @param value the text value to match
          * @param pathexpr the hierarchical path to the nodes to be searched
          */
         public QueryTerm(boolean casesensitive, String searchmode,
                          String value, String pathexpr) {
           this(casesensitive, searchmode, value);
           this.pathexpr = pathexpr;
+        }
         /** determine if the QueryTerm is case sensitive */
         public boolean isCaseSensitive() {
           return casesensitive;
+        }
         /** get the searchmode parameter */
         public String getSearchMode() {
           return searchmode;
+        }
         /** get the Value parameter */
         public String getValue() {
           return value;
+        }
         /** get the path expression parameter */
         public String getPathExpression() {
           return pathexpr;
+        }
         public String toSQL() {
         /**
          * create a SQL serialization of the query that this instance represents
          */
         public String printSQL() {
           StringBuffer self = new StringBuffer();
           //self.append("    Query Term iscasesensitive=" + casesensitive + "\n");
           // Uppercase the search string if case match is not important
           String casevalue = null;
           String nodedataterm = null;
-...
           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.
          */
         public String toString() {
           StringBuffer self = new StringBuffer();

     /**
      *      Name: DBQuery.java
      *   Purpose: A Class that searches a relational DB for elements and
      *            attributes that have free text matches to the query string.
      *            It returns a result set consisting of the root nodeid for
      *            each document that satisfies the query
      *            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
-...
     import java.util.Enumeration;
     /**
      * A Class that searches a relational DB for elements and attributes that
      * have structured text matches to the query string.  It returns a result set
      * consisting of the root nodeid for each document that satisfies the query
      * 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
      */
     public class DBQuery {
       static  String 	defaultDB = "jdbc:oracle:thin:@localhost:1521:test";
       private static String defaultDB = "jdbc:oracle:thin:@localhost:1521:test";
       private Connection	conn = null;
       private String	parserName = null;
       /**
        * the main routine used to test the DBQuery utility.
-...
        */
       static public void main(String[] args) {
          if (args.length < 3)
          if (args.length < 4)
+         {
             System.err.println("Wrong number of arguments!!!");
             System.err.println("USAGE: java DBQuery " +
                                "<xmlfile> <user> <password> [dbstring]");
                                "<xmlfile> <parser> <user> <password> [dbstring]");
             return;
          } else {
             try {
               String xmlfile  = args[0];
               String user     = args[1];
               String password = args[2];
               String parser   = args[1];
               String user     = args[2];
               String password = args[3];
               String dbstring = null;
               if (args.length <= 3) {
               if (args.length <= 4) {
                 dbstring = defaultDB;
               } else {
                 dbstring = args[3];
                 dbstring = args[4];
+              }
               // Open a connection to the database
               Connection dbconn = MetaCatUtil.openDBConnection(
                                   "oracle.jdbc.driver.OracleDriver",
                                   dbstring, user, password);
               // Execute the query
               DBQuery rd = new DBQuery(dbconn);
               DBQuery rd = new DBQuery(dbconn, parser);
               FileReader xml = new FileReader(new File(xmlfile));
               //QuerySpecification qspec = new QuerySpecification(xml);
               //System.out.println(qspec.toSQL());
               Hashtable nodelist = null;
               nodelist = rd.findDocuments(xml);
               // Print the reulting root nodes
               // Print the reulting document listing
               StringBuffer result = new StringBuffer();
               String document = null;
               String docid = null;
-...
        * 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.Parser interface
        */
       public DBQuery( Connection conn )
       public DBQuery( Connection conn, String parserName )
                       throws IOException,
                              SQLException,
                              ClassNotFoundException
+      {
                              ClassNotFoundException {
         this.conn = conn;
         this.parserName = parserName;
+      }
       /**
        * routine to search the elements and attributes looking to match query
+       *
        * @param queryspec the xml serialization of the query (pathquery.dtd)
        * @param queryspec the xml serialization of the query (@see pathquery.dtd)
        */
       public Hashtable findDocuments(Reader queryspec) {
           Hashtable	 docListResult = new Hashtable();
           PreparedStatement pstmt;
           // Now look up the document id
           String docid = null;
           String docname = null;
           String doctype = null;
-...
           StringBuffer document = null;
           try {
             QuerySpecification qspec = new QuerySpecification(queryspec);
             pstmt = conn.prepareStatement(
                   "SELECT docid,docname,doctype,doctitle " +
                   "FROM xml_documents WHERE docid IN (" +
                   qspec.toSQL() + ")");
             // Get the XML query and covert it into a SQL statment
             QuerySpecification qspec = new QuerySpecification(queryspec,
                                        parserName);
             pstmt = conn.prepareStatement( qspec.printSQL() );
             // Execute the SQL query using the JDBC connection
             pstmt.execute();
             ResultSet rs = pstmt.getResultSet();
             boolean tableHasRows = rs.next();

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 172

Added by Matt Jones over 24 years ago