Changed query interface to accomodate for new parameters

Author: bhermann

src/it/scala/de/upb/cs/swt/delphi/webapi/SearchQueryTest.scala

@@ -17,6 +17,7 @@
 package de.upb.cs.swt.delphi.webapi
 
 import de.upb.cs.swt.delphi.webapi.featuredefinitions.FeatureExtractor
+import de.upb.cs.swt.delphi.webapi.search.{QueryRequest, SearchQuery}
 import org.scalatest.{FlatSpec, Matchers}
 
 import scala.util.Success
@@ -26,7 +27,7 @@ class SearchQueryTest extends FlatSpec with Matchers {
     val configuration = new Configuration()
     val q = new SearchQuery(configuration, new FeatureExtractor(configuration))
 
-    val response = q.search("[if_icmpeq (opcode:159)]>1")
+    val response = q.search(QueryRequest("[if_icmpeq (opcode:159)]>1"))
     response shouldBe a [Success[_]]
   }
 }

src/main/scala/de/upb/cs/swt/delphi/webapi/RetrieveQuery.scala

@@ -16,15 +16,12 @@
 
 package de.upb.cs.swt.delphi.webapi
 
-import com.sksamuel.elastic4s.http.{ElasticClient, RequestSuccess, Response}
 import com.sksamuel.elastic4s.http.ElasticDsl.{termQuery, _}
-import com.sksamuel.elastic4s.http.search.{SearchHit, SearchHits, SearchResponse}
+import com.sksamuel.elastic4s.http.search.SearchResponse
+import com.sksamuel.elastic4s.http.{ElasticClient, RequestSuccess, Response}
 import com.sksamuel.elastic4s.searches.queries.Query
 import com.sksamuel.elastic4s.searches.queries.term.TermQuery
-import de.upb.cs.swt.delphi.webapi.artifacts.{Artifact, ArtifactMetadata, ArtifactTransformer}
-import org.joda.time.DateTime
-import org.joda.time.format.{DateTimeFormatter, ISODateTimeFormat}
-import spray.json.{DefaultJsonProtocol, DeserializationException, JsString, JsValue, RootJsonFormat}
+import de.upb.cs.swt.delphi.webapi.artifacts.ArtifactTransformer
 
 object RetrieveQuery {
   def retrieve(identifier: String)(implicit configuration: Configuration) = {

src/main/scala/de/upb/cs/swt/delphi/webapi/Server.scala

@@ -23,12 +23,14 @@ import akka.http.scaladsl.model.{HttpResponse, StatusCodes}
 import akka.http.scaladsl.server.{HttpApp, Route}
 import akka.stream.ActorMaterializer
 import akka.util.Timeout
-import de.upb.cs.swt.delphi.webapi.featuredefinitions.{FeatureExtractor, FeatureListMapping}
 import de.upb.cs.swt.delphi.instancemanagement.InstanceRegistry
-import spray.json._
 import de.upb.cs.swt.delphi.webapi.artifacts.ArtifactJson._
+import de.upb.cs.swt.delphi.webapi.search.QueryRequestJson._
+import de.upb.cs.swt.delphi.webapi.featuredefinitions.FeatureExtractor
+import de.upb.cs.swt.delphi.webapi.search.{QueryRequest, SearchQuery}
+import spray.json._
 
-import scala.concurrent.{ExecutionContext, Future}
+import scala.concurrent.ExecutionContext
 import scala.util.{Failure, Success}
 
 /**
@@ -111,11 +113,10 @@ object Server extends HttpApp with JsonSupport with AppLogging {
   def search: Route = {
     post {
       parameter('pretty.?) { (pretty) =>
-        entity(as[JsValue]) { input =>
-          val query = input.asJsObject.fields("query").convertTo[String]
-          log.info(s"Received search query: $query")
+        entity(as[QueryRequest]) { input =>
+          log.info(s"Received search query: ${input.query}")
           complete(
-            new SearchQuery(configuration, featureExtractor).search(query) match {
+            new SearchQuery(configuration, featureExtractor).search(input) match {
               case Success(result) => prettyPrint(pretty, result.toJson)
               case Failure(e) => e.getMessage
             }

src/main/scala/de/upb/cs/swt/delphi/webapi/search/QueryRequest.scala

@@ -0,0 +1,3 @@
+package de.upb.cs.swt.delphi.webapi.search
+
+case class QueryRequest (query : String, limit : Option[Int] = Some(50))

src/main/scala/de/upb/cs/swt/delphi/webapi/search/QueryRequestJson.scala

@@ -0,0 +1,7 @@
+package de.upb.cs.swt.delphi.webapi.search
+
+import spray.json.DefaultJsonProtocol
+
+object QueryRequestJson extends DefaultJsonProtocol {
+  implicit val queryRequestFormat = jsonFormat2(QueryRequest)
+}

src/main/scala/de/upb/cs/swt/delphi/webapi/search/SearchQuery.scala

@@ -14,30 +14,30 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package de.upb.cs.swt.delphi.webapi
+package de.upb.cs.swt.delphi.webapi.search
 
-import com.sksamuel.elastic4s.http.{ElasticClient, RequestSuccess}
-import de.upb.cs.swt.delphi.webapi.featuredefinitions.FeatureExtractor
-import de.upb.cs.swt.delphi.webapi.querylanguage._
 import com.sksamuel.elastic4s.http.ElasticDsl._
 import com.sksamuel.elastic4s.http.search.SearchHits
+import com.sksamuel.elastic4s.http.{ElasticClient, RequestSuccess}
 import com.sksamuel.elastic4s.searches.queries.{NoopQuery, Query}
+import de.upb.cs.swt.delphi.webapi.Configuration
 import de.upb.cs.swt.delphi.webapi.artifacts.ArtifactTransformer
+import de.upb.cs.swt.delphi.webapi.featuredefinitions.FeatureExtractor
+import de.upb.cs.swt.delphi.webapi.search.querylanguage._
 
 import scala.util.{Failure, Success, Try}
 
 class SearchQuery(configuration: Configuration, featureExtractor: FeatureExtractor) {
   private val client = ElasticClient(configuration.elasticsearchClientUri)
 
-  private def checkAndExecuteParsedQuery(ast: CombinatorialExpr): Try[SearchHits] = {
+  private def checkAndExecuteParsedQuery(ast: CombinatorialExpr, limit : Int): Try[SearchHits] = {
     val fields = collectFieldNames(ast)
-    if (fields.diff(featureExtractor.featureList.toSeq).size > 0) return Failure(null)
+    if (fields.diff(featureExtractor.featureList.toSeq).size > 0) return Failure(new IllegalArgumentException("Unknown field name used."))
 
     val query = searchWithType(configuration.esProjectIndex)
       .query(translate(ast))
       .sourceInclude(ArtifactTransformer.baseFields ++ fields.intersect(featureExtractor.featureList.toSeq).map(i => addPrefix(i)))
-
-
+      .limit(limit)
 
     val response = client.execute {
       query
@@ -110,12 +110,12 @@ class SearchQuery(configuration: Configuration, featureExtractor: FeatureExtract
     }
   }
 
-  def search(query: String) = {
-    val parserResult = new Syntax(query).QueryRule.run()
+  def search(query: QueryRequest) = {
+    val parserResult = new Syntax(query.query).QueryRule.run()
     parserResult match {
       case Failure(e) => Failure(e)
       case Success(ast) => {
-        checkAndExecuteParsedQuery(ast) match {
+        checkAndExecuteParsedQuery(ast, query.limit.getOrElse(50)) match {
           case Failure(e) => Failure(e)
           case Success(hits) => Success(ArtifactTransformer.transformResults(hits))
         }