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

Timestamp:

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

Author:

Oliver Schonefeld

Message:

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

File:

• SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRURequestImpl.java (modified) (15 diffs)

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;