Changeset 6821

Timestamp:

11/17/15 17:14:53 (9 years ago)

Author:

Oliver Schonefeld

Message:

• implement basic SRU 2.0 query handling ... kind of ...

Location:

SRUServer/trunk/src/main/java/eu/clarin/sru/server

Files:

• CQLQueryParser.java (added)
• SRUConstants.java (modified) (1 diff)
• SRUQuery.java (added)
• SRUQueryParser.java (added)
• SRURequest.java (modified) (1 diff)
• SRURequestImpl.java (modified) (15 diffs)
• SRUServer.java (modified) (2 diffs)
• SRUServerConfig.java (modified) (6 diffs)

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRUConstants.java

@@ -206 +206 @@
 
 
+    // other constants
+
+    /**
+     * shortqueryType identifier for cql
+     */
+    public static final String SRU_QUERY_TYPE_CQL = "cql";
+
+
     /* hide constructor */
     private SRUConstants() {

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRURequest.java

@@ -100 +100 @@
     public SRURecordPacking getRecordPacking();
 
+
     /**
      * Get the <em>query</em> parameter of this request. Only available for
      * <em>searchRetrieve</em> requests.
      *
-     * @return the parsed query or <code>null</code> if not a
+     * @return the parsed query as an AST or <code>null</code> if not a
      *         <em>searchRetrieve</em> request
      */
-    public CQLNode getQuery();
+    public SRUQuery<?> getQuery();
+
+
+    /**
+     * Get the <em>queryType</em> parameter of this request. Only available for
+     * <em>searchRetrieve</em> requests.
+     *
+     * @return the queryType of the parsed query or <code>null</code> if not a
+     *         <em>searchRetrieve</em> request
+     */
+    public String getQueryType();
+
+
+    /**
+     * Check if the request was made with the given queryType. Only available
+     * for <em>searchRetrieve</em> requests.
+     *
+     * @param queryType
+     *            the queryType to compare with
+     * @return <code>true</code> if the queryType matches, <code>false</code>
+     *         otherwise
+     */
+    public boolean isQueryType(String queryType);
 
 
     /**
      * Get the <em>startRecord</em> parameter of this request. Only available
-     * for <em>searchRetrieve</em> requests. If the client did not provide
-     * a value for the request, it is set to <code>1</code>.
+     * for <em>searchRetrieve</em> requests. If the client did not provide a
+     * value for the request, it is set to <code>1</code>.
      *
      * @return the number of the start record

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRURequestImpl.java

@@ -21 +21 @@
 import java.util.Collections;
 import java.util.Enumeration;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import javax.servlet.http.HttpServletRequest;
@@ -83 +85 @@
     private SRURecordXmlEscaping recordXmlEscaping;
     private SRURecordPacking recordPacking;
-    private CQLNode query;
-    private String queryType;
+    private SRUQuery<?> query;
     private int startRecord = DEFAULT_START_RECORD;
     private int maximumRecords = -1;
@@ -104 +105 @@
         HTTP_ACCEPT,
         RESPONSE_TYPE,
-        QUERY,
-        QUERY_TYPE,
+//        QUERY,
+//        QUERY_TYPE,
         START_RECORD,
         MAXIMUM_RECORDS,
@@ -147 +148 @@
             case RESPONSE_TYPE:
                 return PARAM_RESPONSE_TYPE;
-            case QUERY:
-                return PARAM_QUERY;
-            case QUERY_TYPE:
-                return PARAM_QUERY_TYPE;
+//            case QUERY:
+//                return PARAM_QUERY;
+//            case QUERY_TYPE:
+//                return PARAM_QUERY_TYPE;
             case START_RECORD:
                 return PARAM_START_RECORD;
@@ -168 +169 @@
             case RECORD_PACKING:
                 /*
-                 * FIXME: make this better
+                 * 'recordPacking' only exists in SRU 2.0; the old variant is
+                 * handled by the case for RECORD_XML_ESCAPING
                  */
                 if (version == SRUVersion.VERSION_2_0) {
                     return PARAM_RECORD_PACKING;
                 } else {
-                    throw new InternalError("should not happen");
+                    return null;
                 }
             case RECORD_SCHEMA:
@@ -231 +233 @@
         new ParameterInfo(Parameter.RESPONSE_TYPE, false,
                 SRUVersion.VERSION_2_0, SRUVersion.VERSION_2_0),
-        new ParameterInfo(Parameter.QUERY, true,
-                SRUVersion.VERSION_1_1, SRUVersion.VERSION_2_0),
-        new ParameterInfo(Parameter.QUERY_TYPE, true,
-                SRUVersion.VERSION_2_0, SRUVersion.VERSION_2_0),
+//        new ParameterInfo(Parameter.QUERY, true,
+//                SRUVersion.VERSION_1_1, SRUVersion.VERSION_2_0),
+//        new ParameterInfo(Parameter.QUERY_TYPE, true,
+//                SRUVersion.VERSION_2_0, SRUVersion.VERSION_2_0),
         new ParameterInfo(Parameter.START_RECORD, false,
                 SRUVersion.VERSION_1_1, SRUVersion.VERSION_2_0),
@@ -290 +292 @@
                 logger.debug("handling request as SRU 2.0, because no '{}' " +
                         "parameter was found in the request", PARAM_VERSION);
-                if (getParameter(PARAM_QUERY, false, false) != null) {
-                    logger.debug("found parameter '{}' therefore " +
+                if ((getParameter(PARAM_QUERY, false, false) != null) ||
+                        (getParameter(PARAM_QUERY_TYPE, false, false) != null)) {
+                    logger.debug("found parameter '{}' or '{}' therefore " +
                             "assuming '{}' operation",
-                            PARAM_QUERY, SRUOperation.SEARCH_RETRIEVE);
+                            PARAM_QUERY, PARAM_QUERY_TYPE,
+                            SRUOperation.SEARCH_RETRIEVE);
                     operation = SRUOperation.SEARCH_RETRIEVE;
                 } else if (getParameter(PARAM_SCAN_CLAUSE, false, false) != null) {
@@ -429 +433 @@
             for (ParameterInfo parameter : parameter_set) {
                 final String name = parameter.getName(version);
+                if (name == null) {
+                    /*
+                     * this parameter is not supported in the SRU version that
+                     * was used for the request
+                     */
+                    continue;
+                }
                 final String value = getParameter(name, true, true);
                 if (value != null) {
@@ -472 +483 @@
                                             "\" is not supported.");
                         }
-                        break;
-                    case QUERY:
-                        query = parseCQLParameter(name, value);
-                        break;
-                    case QUERY_TYPE:
-                        queryType = parseQueryTypeParameter(name, value);
                         break;
                     case START_RECORD:
@@ -517 +522 @@
                         break;
                     case SCAN_CLAUSE:
-                        scanClause = parseCQLParameter(name, value);
+                        scanClause = parseScanQueryParameter(name, value);
                         break;
                     case RESPONSE_POSITION:
@@ -566 +571 @@
 
             /*
+             * handle query and queryType
+             */
+            if (operation == SRUOperation.SEARCH_RETRIEVE) {
+                /*
+                 * determine queryType
+                 */
+                String queryType = null;
+                if (version == SRUVersion.VERSION_2_0) {
+                    parameterNames.remove(PARAM_QUERY_TYPE);
+                    String value = getParameter(PARAM_QUERY_TYPE, true, true);
+                    if (value == null) {
+                        queryType = SRUConstants.SRU_QUERY_TYPE_CQL;
+                    } else {
+                        boolean badCharacters = false;
+                        for (int i = 0; i < value.length(); i++) {
+                            final char ch = value.charAt(i);
+                            if (!((ch >= 'a' && ch <= 'z') ||
+                                    (ch >= 'A' && ch <= 'Z') ||
+                                    (ch >= '0' && ch <= '9') ||
+                                    ((i > 0) && ((ch == '-') || ch == '_')))) {
+                                addDiagnostic(SRUConstants.SRU_UNSUPPORTED_PARAMETER_VALUE,
+                                        PARAM_QUERY_TYPE, "Value contains illegal characters.");
+                                badCharacters = true;
+                                break;
+                            }
+                        }
+                        if (!badCharacters) {
+                            queryType = value;
+                        }
+                    }
+                } else {
+                    // SRU 1.1 and SRU 1.2 only support CQL
+                    queryType = SRUConstants.SRU_QUERY_TYPE_CQL;
+                }
+
+
+                if (queryType != null) {
+                    logger.debug("looking for query parser for query type '{}'",
+                            queryType);
+                    final SRUQueryParser<?> queryParser =
+                            config.findQueryParser(queryType);
+                    if (queryParser != null) {
+                        /*
+                         * gather query parameters (as required by QueryParser
+                         * implementation
+                         */
+                        final Map<String, String> queryParameters =
+                                new HashMap<String, String>();
+                        List<String> missingParameter = null;
+                        for (String name : queryParser.getQueryParameterNames()) {
+                            parameterNames.remove(name);
+                            final String value = getParameter(name, true, false);
+                            if (value != null) {
+                                queryParameters.put(name, value);
+                            } else {
+                                if (missingParameter == null) {
+                                    missingParameter = new ArrayList<String>();
+                                }
+                                missingParameter.add(name);
+                            }
+                        }
+
+                        if (missingParameter == null) {
+                            logger.debug("parsing query with parser for " +
+                                    "type '{}' and parameters {}",
+                                    queryParser.getQueryType(),
+                                    queryParameters);
+                            query = queryParser.parseQuery(version,
+                                    queryParameters, this);
+                        } else {
+                            logger.debug("parameters {} missing, cannot parse query",
+                                    missingParameter);
+                            for (String name : missingParameter) {
+                                addDiagnostic(
+                                        SRUConstants.SRU_MANDATORY_PARAMETER_NOT_SUPPLIED,
+                                        name, "Mandatory parameter '" + name +
+                                                "' is missing or empty. " +
+                                                "Required to perform query " +
+                                                "of query type '" +
+                                                queryType + "'.");
+                            }
+                        }
+                    } else {
+                        logger.debug("no parser for query type '{}' found", queryType);
+                        addDiagnostic(SRUConstants.SRU_CANNOT_PROCESS_QUERY_REASON_UNKNOWN, null,
+                                "Cannot find query parser for query type '" + queryType + "'.");
+                    }
+                } else {
+                    logger.debug("cannot determine query type");
+                    addDiagnostic(SRUConstants.SRU_CANNOT_PROCESS_QUERY_REASON_UNKNOWN, null,
+                            "Cannot determine query type.");
+                }
+            }
+
+
+            /*
              *  check if any parameters where not consumed and
              *  add appropriate warnings
@@ -702 +803 @@
 
     @Override
-    public CQLNode getQuery() {
+    public SRUQuery<?> getQuery() {
         return query;
+    }
+
+
+    @Override
+    public boolean isQueryType(String queryType) {
+        if ((queryType != null) && (query != null)) {
+            return query.getQueryType().equals(queryType);
+        }
+        return false;
+    }
+
+
+    @Override
+    public String getQueryType() {
+        if (query != null) {
+            return query.getQueryType();
+        }
+        return null;
     }
 
@@ -892 +1011 @@
                 if (diagnosticIfEmpty) {
                     addDiagnostic(SRUConstants.SRU_UNSUPPORTED_PARAMETER_VALUE,
-                            name, "An empty parameter \"" + PARAM_OPERATION +
+                            name, "An empty parameter \"" + name +
                             "\" is not supported.");
                 }
@@ -935 +1054 @@
 
 
-    private String parseQueryTypeParameter(String param, String value) {
-        if (value != null) {
-            for (int i = 0; i < value.length(); i++) {
-                final char ch = value.charAt(i);
-                if (!((ch >= 'a' && ch <= 'z') ||
-                        (ch >= 'A' && ch <= 'Z') ||
-                        (ch >= '0' && ch <= '9') ||
-                        ((i > 0) && ((ch == '-') || ch == '_')))) {
-                    addDiagnostic(SRUConstants.SRU_UNSUPPORTED_PARAMETER_VALUE,
-                            param, "Value contains illegal characters.");
-                }
-            }
-        }
-        return value;
-    }
-
-
     private int parseNumberedParameter(String param, String value,
             int minValue) {
@@ -972 +1074 @@
 
 
-    private CQLNode parseCQLParameter(String param, String value) {
+    private CQLNode parseScanQueryParameter(String param, String value) {
         CQLNode result = null;
 

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRUServer.java

@@ -979 +979 @@
 
     private void writeEchoedSearchRetrieveRequest(SRUXMLStreamWriter out,
-            SRUNamespaces ns, SRURequestImpl request, CQLNode cql)
+            SRUNamespaces ns, SRURequestImpl request, SRUQuery<?> query)
             throws XMLStreamException, SRUException {
         // echoedSearchRetrieveRequest
@@ -990 +990 @@
         }
 
-        // echoedSearchRetrieveRequest/query
-        out.writeStartElement(ns.getResponseNS(), "query");
-        out.writeCharacters(request.getRawQuery());
-        out.writeEndElement(); // "query"
-
-        // echoedSearchRetrieveRequest/xQuery
-        out.setDefaultNamespace(ns.getXcqlNS());
-        out.writeStartElement(ns.getResponseNS(), "xQuery");
-        out.writeDefaultNamespace(ns.getXcqlNS());
-        out.writeXCQL(cql, true);
-        out.writeEndElement(); // "xQuery" element
+        /*
+         * XXX: unclear, if <query> should only be echoed if queryType is CQL!?
+         */
+        if (SRUConstants.SRU_QUERY_TYPE_CQL.equals(query.getQueryType())) {
+            final CQLQueryParser.CQLQuery cql = (CQLQueryParser.CQLQuery) query;
+            // echoedSearchRetrieveRequest/query
+            out.writeStartElement(ns.getResponseNS(), "query");
+            out.writeCharacters(cql.getRawQuery());
+            out.writeEndElement(); // "query"
+
+            // echoedSearchRetrieveRequest/xQuery
+            out.setDefaultNamespace(ns.getXcqlNS());
+            out.writeStartElement(ns.getResponseNS(), "xQuery");
+            out.writeDefaultNamespace(ns.getXcqlNS());
+            out.writeXCQL(cql.getParsedQuery(), true);
+            out.writeEndElement(); // "xQuery" element
+        }
 
         // echoedSearchRetrieveRequest/startRecord

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRUServerConfig.java

@@ -637 +637 @@
     private final IndexInfo indexInfo;
     private final List<SchemaInfo> schemaInfo;
+    private final List<SRUQueryParser<?>> queryParsers;
 
 
@@ -659 +660 @@
             DatabaseInfo databaseinfo,
             IndexInfo indexInfo,
-            List<SchemaInfo> schemaInfo) {
+            List<SchemaInfo> schemaInfo,
+            List<SRUQueryParser<?>> queryParsers) {
         this.minVersion                  = minVersion;
         this.maxVersion                  = maxVersion;
@@ -685 +687 @@
             this.schemaInfo = null;
         }
+        this.queryParsers = Collections.unmodifiableList(queryParsers);
 
         // build baseUrl
@@ -853 +856 @@
                         return schema;
                     }
+                }
+            }
+        }
+        return null;
+    }
+
+
+    public SRUQueryParser<?> findQueryParser(String queryType) {
+        if (queryType != null) {
+            for (SRUQueryParser<?> queryParser : queryParsers) {
+                if (queryParser.getQueryType().equals(queryType)) {
+                    return queryParser;
                 }
             }
@@ -1079 +1094 @@
                     SRU_RESPONSE_BUFFER_SIZE, false,
                     DEFAULT_RESPONSE_BUFFER_SIZE, 0, -1);
+
+            /*
+             * FIXME: add interface to register additional query parsers
+             */
+            List<SRUQueryParser<?>> queryParsers =
+                    new ArrayList<SRUQueryParser<?>>();
+            queryParsers.add(new CQLQueryParser());
 
             return new SRUServerConfig(minVersion,
@@ -1100 +1122 @@
                     databaseInfo,
                     indexInfo,
-                    schemaInfo);
+                    schemaInfo,
+                    queryParsers);
         } catch (IOException e) {
             throw new SRUConfigException("error reading configuration file", e);