fix nested sources and size

Author: fupelaqu

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

@@ -73,10 +73,6 @@ case class ElasticQuery(filter: ElasticFilter) {
 
           val nestedParents = getNestedParents(nestedElements.last, Seq.empty)
 
-          nestedParentsPath.foreach { case (path, (element, children)) =>
-            println(s"parent: $path, children: ${children.map(_.path).mkString(", ")}")
-          }
-
           def buildNestedQuery(n: NestedElement): Query = {
             val children = nestedParentsPath.get(n.path).map(_._2).getOrElse(Seq.empty)
             if (children.nonEmpty) {

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

@@ -13,7 +13,7 @@ import com.sksamuel.elastic4s.http.search.SearchBodyBuilderFn
 import com.sksamuel.elastic4s.script.Script
 import com.sksamuel.elastic4s.script.ScriptType.Source
 import com.sksamuel.elastic4s.searches.aggs.{Aggregation, FilterAggregation}
-import com.sksamuel.elastic4s.searches.queries.{Query, RawQuery}
+import com.sksamuel.elastic4s.searches.queries.Query
 import com.sksamuel.elastic4s.searches.{MultiSearchRequest, SearchRequest}
 import com.sksamuel.elastic4s.searches.sort.FieldSort
 

sql/bridge/src/main/scala/app/softnetwork/elastic/sql/bridge/ElasticQuery.scala

@@ -1,24 +1,27 @@
 package app.softnetwork.elastic.sql.bridge
 
 import app.softnetwork.elastic.sql.query.{
+  BetweenExpr,
   ElasticBoolQuery,
   ElasticChild,
   ElasticFilter,
-  DistanceCriteria,
   ElasticMatch,
   ElasticNested,
   ElasticParent,
-  BetweenExpr,
   GenericExpression,
   InExpr,
-  IsNotNullExpr,
   IsNotNullCriteria,
+  IsNotNullExpr,
+  IsNullCriteria,
   IsNullExpr,
-  IsNullCriteria
+  NestedElement
 }
 import com.sksamuel.elastic4s.ElasticApi._
+import com.sksamuel.elastic4s.requests.common.FetchSourceContext
 import com.sksamuel.elastic4s.requests.searches.queries.Query
 
+import scala.annotation.tailrec
+
 case class ElasticQuery(filter: ElasticFilter) {
   def query(
     innerHitsNames: Set[String] = Set.empty,
@@ -39,15 +42,77 @@ case class ElasticQuery(filter: ElasticFilter) {
           criteria.asFilter(currentQuery).query(innerHitsNames, currentQuery)
         } else {
           val boolQuery = Option(ElasticBoolQuery(group = true))
-          nestedQuery(
-            relationType.getOrElse(""),
-            criteria
-              .asFilter(boolQuery)
-              .query(innerHitsNames + innerHitsName.getOrElse(""), boolQuery)
-          ) /*.scoreMode(ScoreMode.None)*/
-            .inner(
-              innerHits(innerHitsName.getOrElse("")).from(0).size(limit.map(_.limit).getOrElse(3))
-            )
+          val q = criteria
+            .asFilter(boolQuery)
+            .query(innerHitsNames + innerHitsName.getOrElse(""), boolQuery)
+
+          val nestedElements: Seq[NestedElement] = criteria.nestedElements.sortBy(_.level)
+          nestedElements.foreach(n => println(s"nestedElement: ${n.path}, level: ${n.level}"))
+
+          val nestedParentsPath
+          : collection.mutable.Map[String, (NestedElement, Seq[NestedElement])] =
+            collection.mutable.Map.empty
+
+          @tailrec
+          def getNestedParents(
+                                n: NestedElement,
+                                parents: Seq[NestedElement]
+                              ): Seq[NestedElement] = {
+            n.parent match {
+              case Some(p) =>
+                if (!nestedParentsPath.contains(p.path)) {
+                  nestedParentsPath += p.path -> (p, Seq(n))
+                  getNestedParents(p, p +: parents)
+                } else {
+                  nestedParentsPath += p.path -> (p, nestedParentsPath(p.path)._2 :+ n)
+                  parents
+                }
+              case _ => parents
+            }
+          }
+
+          val nestedParents = getNestedParents(nestedElements.last, Seq.empty)
+
+          def buildNestedQuery(n: NestedElement): Query = {
+            val children = nestedParentsPath.get(n.path).map(_._2).getOrElse(Seq.empty)
+            if (children.nonEmpty) {
+              val innerQueries = children.map(buildNestedQuery)
+              val combinedQuery = if (innerQueries.size == 1) {
+                innerQueries.head
+              } else {
+                must(innerQueries)
+              }
+              nestedQuery(
+                n.path,
+                combinedQuery
+              ) /*.scoreMode(ScoreMode.None)*/
+                .inner(
+                  innerHits(n.innerHitsName)
+                    .from(0)
+                    .size(n.size.getOrElse(3))
+                    .fetchSource(
+                      FetchSourceContext(fetchSource = true, includes = n.sources.toArray)
+                    )
+                )
+            } else {
+              nestedQuery(
+                n.path,
+                q
+              ) /*.scoreMode(ScoreMode.None)*/
+                .inner(
+                  innerHits(n.innerHitsName)
+                    .from(0)
+                    .size(n.size.getOrElse(3))
+                    .fetchSource(
+                      FetchSourceContext(fetchSource = true, includes = n.sources.toArray)
+                    )
+                )
+            }
+          }
+          if (nestedParents.nonEmpty)
+            buildNestedQuery(nestedParents.head)
+          else
+            buildNestedQuery(nestedElements.last)
         }
       case child: ElasticChild =>
         import child._

sql/src/main/scala/app/softnetwork/elastic/sql/query/SQLSearchRequest.scala

@@ -1,7 +1,7 @@
 package app.softnetwork.elastic.sql.query
 
 import app.softnetwork.elastic.sql.function.aggregate.TopHitsAggregation
-import app.softnetwork.elastic.sql.{asString, Identifier, Token}
+import app.softnetwork.elastic.sql.{asString, Token}
 
 case class SQLSearchRequest(
   select: Select = Select(),
@@ -39,7 +39,7 @@ case class SQLSearchRequest(
     NestedElement(
       path = u.path,
       innerHitsName = u.innerHitsName,
-      size = u.limit.map(_.limit),
+      size = limit.map(_.limit),
       children = Nil,
       sources = nestedFields
         .get(u.innerHitsName)
@@ -53,14 +53,14 @@ case class SQLSearchRequest(
     orderBy.map { _.sorts.map(s => s.name -> s.direction) }.getOrElse(Map.empty).toMap
 
   def update(): SQLSearchRequest = {
-    val updated = this.copy(from = from.update(this))
-    updated.copy(
-      select = select.update(updated),
-      where = where.map(_.update(updated)),
-      groupBy = groupBy.map(_.update(updated)),
-      having = having.map(_.update(updated)),
-      orderBy = orderBy.map(_.update(updated))
-    )
+    (for {
+      from    <- Option(this.copy(from = from.update(this)))
+      select  <- Option(from.copy(select = select.update(from)))
+      where   <- Option(select.copy(where = where.map(_.update(select))))
+      groupBy <- Option(where.copy(groupBy = groupBy.map(_.update(where))))
+      having  <- Option(groupBy.copy(having = having.map(_.update(groupBy))))
+      updated <- Option(having.copy(orderBy = orderBy.map(_.update(having))))
+    } yield updated).get
   }
 
   lazy val scriptFields: Seq[Field] = select.fields.filter(_.isScriptField)