Changeset 6842

Timestamp:

11/25/15 10:28:02 (8 years ago)

Author:

Oliver Schonefeld

Message:

• add 'searchTerms' query parser (SRU 2.0)

Location:

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

Files:

• CQLQueryParser.java (modified) (4 diffs)
• SRUConstants.java (modified) (1 diff)
• SRUQueryBase.java (added)
• SRUQueryParser.java (modified) (1 diff)
• SRUQueryParserRegistry.java (modified) (1 diff)
• SRURequestImpl.java (modified) (1 diff)
• SearchTermsQueryParser.java (added)

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

@@ -34 +34 @@
     private static final List<String> QUERY_PARAMETER_NAMES =
             Collections.unmodifiableList(Arrays.asList(PARAM_QUERY));
-    
+
 
     @Override
@@ -43 +43 @@
 
     @Override
+    public boolean supportsVersion(SRUVersion version) {
+        if (version == null) {
+            throw new NullPointerException("version == null");
+        }
+        /*
+         * CQL is supported by all SRU versions ...
+         */
+        return true;
+    }
+
+
+    @Override
     public String getQueryTypeDefintion() {
         return null;
     }
+
 
     @Override
@@ -91 +104 @@
 
 
-    public static final class CQLQuery implements SRUQuery<CQLNode> {
-        private final String rawQuery;
-        private final CQLNode parsedQuery;
-
+    public static final class CQLQuery extends SRUQueryBase<CQLNode> {
 
         private CQLQuery(String rawQuery, CQLNode parsedQuery) {
-            this.rawQuery = rawQuery;
-            this.parsedQuery = parsedQuery;
+            super(rawQuery, parsedQuery);
         }
 
@@ -106 +115 @@
             return SRUConstants.SRU_QUERY_TYPE_CQL;
         }
-
-        @Override
-        public String getRawQuery() {
-            return rawQuery;
-        }
-
-        @Override
-        public CQLNode getParsedQuery() {
-            return parsedQuery;
-        }
     }
 

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

@@ -209 +209 @@
 
     /**
-     * shortqueryType identifier for cql
+     * shorthand queryType identifier for CQL
      */
-    public static final String SRU_QUERY_TYPE_CQL = "cql";
+    public static final String SRU_QUERY_TYPE_CQL          = "cql";
+    public static final String SRU_QUERY_TYPE_SEARCH_TERMS = "searchTerms";
 
 

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

@@ -36 +36 @@
 
     /**
+     * Check if query is supported by a specific version of SRU/CQL
+     *
+     * @param version
+     *            the version
+     * @return <code>true</code> if version is supported, <code>false</code>
+     *         otherwise
+     */
+    public boolean supportsVersion(SRUVersion version);
+
+
+    /**
      * The URI for the for the query type’s definition.
      *

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

@@ -38 +38 @@
     public SRUQueryParserRegistry() {
         queryParsers.add(new CQLQueryParser());
+        queryParsers.add(new SearchTermsQueryParser());
     }
 

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

@@ -607 +607 @@
                             queryParsers.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);
+                        if (queryParser.supportsVersion(version)) {
+                            /*
+                             * 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 {
-                                if (missingParameter == null) {
-                                    missingParameter = new ArrayList<String>();
+                                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 + "'.");
                                 }
-                                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 + "'.");
-                            }
+                            logger.debug("query parser for query type '{}' " +
+                                    "is not supported by SRU version {}",
+                                    queryType, version);
+                            addDiagnostic(SRUConstants.SRU_CANNOT_PROCESS_QUERY_REASON_UNKNOWN, null,
+                                    "Query parser for query type '" +
+                                            queryType + "' is nut supported " +
+                                            "by SRU version '" +
+                                            version.getVersionString() + "'.");
                         }
                     } else {