finalizing implementation of having and order by with aggregates and buckets

Author: fupelaqu

es6/sql-bridge/src/main/scala/app/softnetwork/elastic/sql/bridge/ElasticAggregation.scala

@@ -2,18 +2,22 @@ package app.softnetwork.elastic.sql.bridge
 
 import app.softnetwork.elastic.sql.{
   AggregateFunction,
+  Asc,
   Avg,
+  BucketSelectorScript,
   Count,
   ElasticBoolQuery,
   Max,
   Min,
   SQLBucket,
   SQLCriteria,
   SQLField,
+  SortOrder,
   Sum
 }
 import com.sksamuel.elastic4s.ElasticApi.{
   avgAgg,
+  bucketSelectorAggregation,
   cardinalityAgg,
   filterAgg,
   maxAgg,
@@ -23,11 +27,13 @@ import com.sksamuel.elastic4s.ElasticApi.{
   termsAgg,
   valueCountAgg
 }
+import com.sksamuel.elastic4s.script.Script
 import com.sksamuel.elastic4s.searches.aggs.{
   Aggregation,
   FilterAggregation,
   NestedAggregation,
-  TermsAggregation
+  TermsAggregation,
+  TermsOrder
 }
 
 import scala.language.implicitConversions
@@ -42,17 +48,24 @@ case class ElasticAggregation(
   nestedAgg: Option[NestedAggregation] = None,
   filteredAgg: Option[FilterAggregation] = None,
   aggType: AggregateFunction,
-  agg: Aggregation
+  agg: Aggregation,
+  direction: Option[SortOrder] = None
 ) {
   val nested: Boolean = nestedAgg.nonEmpty
   val filtered: Boolean = filteredAgg.nonEmpty
 }
 
 object ElasticAggregation {
-  def apply(sqlAgg: SQLField, filter: Option[SQLCriteria]): ElasticAggregation = {
+  def apply(
+    sqlAgg: SQLField,
+    having: Option[SQLCriteria],
+    bucketsDirection: Map[String, SortOrder]
+  ): ElasticAggregation = {
     import sqlAgg._
     val sourceField = identifier.name
 
+    val direction = bucketsDirection.get(identifier.identifierName)
+
     val field = fieldAlias match {
       case Some(alias) => alias.alias
       case _           => sourceField
@@ -92,7 +105,7 @@ object ElasticAggregation {
     val filteredAggName = "filtered_agg"
 
     val filteredAgg: Option[FilterAggregation] =
-      filter match {
+      having match {
         case Some(f) =>
           val boolQuery = Option(ElasticBoolQuery(group = true))
           Some(
@@ -135,44 +148,60 @@ object ElasticAggregation {
       nestedAgg = nestedAgg,
       filteredAgg = filteredAgg,
       aggType = aggType,
-      agg = _agg
+      agg = _agg,
+      direction = direction
     )
   }
 
-  /*
-  def apply(
+  def buildBuckets(
     buckets: Seq[SQLBucket],
+    bucketsDirection: Map[String, SortOrder],
     aggregations: Seq[Aggregation],
-    current: Option[TermsAggregation]
+    aggregationsDirection: Map[String, SortOrder],
+    having: Option[SQLCriteria]
   ): Option[TermsAggregation] = {
-    buckets match {
-      case Nil =>
-        current.map(_.copy(subaggs = aggregations))
-      case bucket +: tail =>
-        val agg = termsAgg(bucket.name, s"${bucket.identifier.name}.keyword")
-        current match {
-          case Some(a) =>
-            apply(tail, aggregations, Some(agg)) match {
-              case Some(subAgg) =>
-                Some(a.copy(subaggs = a.subaggs :+ subAgg))
-              case _ => Some(a)
-            }
+    Console.println(bucketsDirection)
+    buckets.reverse.foldLeft(Option.empty[TermsAggregation]) { (current, bucket) =>
+      val agg = {
+        bucketsDirection.get(bucket.identifier.identifierName) match {
+          case Some(direction) =>
+            termsAgg(bucket.name, s"${bucket.identifier.name}.keyword")
+              .order(Seq(direction match {
+                case Asc => TermsOrder(bucket.name, asc = true)
+                case _   => TermsOrder(bucket.name, asc = false)
+              }))
           case None =>
-            apply(tail, aggregations, Some(agg))
+            termsAgg(bucket.name, s"${bucket.identifier.name}.keyword")
         }
-    }
-  }
-   */
-
-  def buildBuckets(
-    buckets: Seq[SQLBucket],
-    aggregations: Seq[Aggregation]
-  ): Option[TermsAggregation] = {
-    buckets.reverse.foldLeft(Option.empty[TermsAggregation]) { (current, bucket) =>
-      val agg = termsAgg(bucket.name, s"${bucket.identifier.name}.keyword")
+      }
       current match {
         case Some(subAgg) => Some(agg.copy(subaggs = Seq(subAgg)))
-        case None         => Some(agg.copy(subaggs = aggregations))
+        case None =>
+          val aggregationsWithOrder: Seq[TermsOrder] = aggregationsDirection.toSeq.map { kv =>
+            kv._2 match {
+              case Asc => TermsOrder(kv._1, asc = true)
+              case _   => TermsOrder(kv._1, asc = false)
+            }
+          }
+          val withAggregationOrders =
+            if (aggregationsWithOrder.nonEmpty)
+              agg.order(aggregationsWithOrder)
+            else
+              agg
+          val withHaving = having match {
+            case Some(criteria) =>
+              import BucketSelectorScript._
+              val script = toPainless(criteria)
+              val bucketsPath = extractBucketsPath(criteria)
+
+              val bucketSelector =
+                bucketSelectorAggregation("having_filter", Script(script), bucketsPath)
+
+              withAggregationOrders.copy(subaggs = aggregations :+ bucketSelector)
+
+            case None => withAggregationOrders.copy(subaggs = aggregations)
+          }
+          Some(withHaving)
       }
     }
   }

es6/sql-bridge/src/main/scala/app/softnetwork/elastic/sql/bridge/package.scala

@@ -21,14 +21,17 @@ package object bridge {
       request.limit.map(_.limit),
       request,
       request.buckets,
-      request.aggregates.map(ElasticAggregation(_, request.having.flatMap(_.criteria)))
+      request.aggregates.map(
+        ElasticAggregation(_, request.having.flatMap(_.criteria), request.sorts)
+      )
     ).minScore(request.score)
 
   implicit def requestToSearchRequest(request: SQLSearchRequest): SearchRequest = {
     import request._
     val notNestedBuckets = buckets.filterNot(_.identifier.nested)
     val nestedBuckets = buckets.filter(_.identifier.nested).groupBy(_.nestedBucket.getOrElse(""))
-    val aggregations = aggregates.map(ElasticAggregation(_, request.having.flatMap(_.criteria)))
+    val aggregations =
+      aggregates.map(ElasticAggregation(_, request.having.flatMap(_.criteria), request.sorts))
     val notNestedAggregations = aggregations.filterNot(_.nested)
     val nestedAggregations =
       aggregations.filter(_.nested).groupBy(_.nestedAgg.map(_.name).getOrElse(""))
@@ -41,13 +44,22 @@ package object bridge {
         nestedAggregations.map { case (nested, aggs) =>
           val first = aggs.head
           val aggregations = aggs.map(_.agg)
-          val buckets = ElasticAggregation.buildBuckets(
-            nestedBuckets.getOrElse(nested, Seq.empty),
-            aggregations
-          ) match {
-            case Some(b) => Seq(b)
-            case _       => aggregations
-          }
+          val aggregationDirections: Map[String, SortOrder] =
+            aggs
+              .filter(_.direction.isDefined)
+              .map(agg => agg.agg.name -> agg.direction.getOrElse(Asc))
+              .toMap
+          val buckets =
+            ElasticAggregation.buildBuckets(
+              nestedBuckets.getOrElse(nested, Seq.empty),
+              request.sorts -- aggregationDirections.keys,
+              aggregations,
+              aggregationDirections,
+              request.having.flatMap(_.criteria)
+            ) match {
+              case Some(b) => Seq(b)
+              case _       => aggregations
+            }
           val filtered: Option[Aggregation] =
             first.filteredAgg.map(filtered => filtered.subAggregations(buckets))
           first.nestedAgg.get.subAggregations(filtered.map(Seq(_)).getOrElse(buckets))
@@ -62,10 +74,17 @@ package object bridge {
       case _ =>
         _search aggregations {
           val first = notNestedAggregations.head
+          val aggregationDirections: Map[String, SortOrder] = notNestedAggregations
+            .filter(_.direction.isDefined)
+            .map(agg => agg.agg.name -> agg.direction.get)
+            .toMap
           val aggregations = notNestedAggregations.map(_.agg)
           val buckets = ElasticAggregation.buildBuckets(
             notNestedBuckets,
-            aggregations
+            request.sorts -- aggregationDirections.keys,
+            aggregations,
+            aggregationDirections,
+            request.having.flatMap(_.criteria)
           ) match {
             case Some(b) => Seq(b)
             case _       => aggregations
@@ -77,7 +96,7 @@ package object bridge {
     }
 
     _search = orderBy match {
-      case Some(o) =>
+      case Some(o) if aggregates.isEmpty && buckets.isEmpty =>
         _search sortBy o.sorts.map(sort =>
           sort.order match {
             case Some(Desc) => FieldSort(sort.field).desc()
@@ -372,7 +391,7 @@ package object bridge {
       .map {
         case Left(l) =>
           l.aggregates
-            .map(ElasticAggregation(_, l.having.flatMap(_.criteria)))
+            .map(ElasticAggregation(_, l.having.flatMap(_.criteria), l.sorts))
             .map(aggregation => {
               val queryFiltered =
                 l.where