add support for date time functions

build.sbt

@@ -19,7 +19,7 @@ ThisBuild / organization := "app.softnetwork"
 
 name := "softclient4es"
 
-ThisBuild / version := "0.4.0"
+ThisBuild / version := "0.5.0"
 
 ThisBuild / scalaVersion := scala213
 

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

@@ -7,11 +7,12 @@ import app.softnetwork.elastic.sql.{
   BucketSelectorScript,
   Count,
   ElasticBoolQuery,
+  Field,
   Max,
   Min,
   SQLBucket,
   SQLCriteria,
-  SQLField,
+  SQLFunctionUtils,
   SortOrder,
   Sum
 }
@@ -57,7 +58,7 @@ case class ElasticAggregation(
 
 object ElasticAggregation {
   def apply(
-    sqlAgg: SQLField,
+    sqlAgg: Field,
     having: Option[SQLCriteria],
     bucketsDirection: Map[String, SortOrder]
   ): ElasticAggregation = {
@@ -88,6 +89,23 @@ object ElasticAggregation {
 
     var aggPath = Seq[String]()
 
+    val (aggFuncs, transformFuncs) = SQLFunctionUtils.aggregateAndTransformFunctions(identifier)
+
+    require(aggFuncs.size == 1, s"Multiple aggregate functions not supported: $aggFuncs")
+
+    def aggWithFieldOrScript(
+      buildField: (String, String) => Aggregation,
+      buildScript: (String, Script) => Aggregation
+    ): Aggregation = {
+      if (transformFuncs.nonEmpty) {
+        val scriptSrc = identifier.painless
+        val script = Script(scriptSrc).lang("painless")
+        buildScript(aggName, script)
+      } else {
+        buildField(aggName, sourceField)
+      }
+    }
+
     val _agg =
       aggType match {
         case Count =>
@@ -96,10 +114,10 @@ object ElasticAggregation {
           else {
             valueCountAgg(aggName, sourceField)
           }
-        case Min => minAgg(aggName, sourceField)
-        case Max => maxAgg(aggName, sourceField)
-        case Avg => avgAgg(aggName, sourceField)
-        case Sum => sumAgg(aggName, sourceField)
+        case Min => aggWithFieldOrScript(minAgg, (name, s) => minAgg(name, sourceField).script(s))
+        case Max => aggWithFieldOrScript(maxAgg, (name, s) => maxAgg(name, sourceField).script(s))
+        case Avg => aggWithFieldOrScript(avgAgg, (name, s) => avgAgg(name, sourceField).script(s))
+        case Sum => aggWithFieldOrScript(sumAgg, (name, s) => sumAgg(name, sourceField).script(s))
       }
 
     val filteredAggName = "filtered_agg"

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

@@ -9,12 +9,13 @@ import app.softnetwork.elastic.sql.{
   ElasticNested,
   ElasticParent,
   SQLBetween,
+  SQLComparisonDateMath,
   SQLExpression,
   SQLIn,
   SQLIsNotNull,
   SQLIsNull
 }
-import com.sksamuel.elastic4s.ElasticApi.{bool, _}
+import com.sksamuel.elastic4s.ElasticApi._
 import com.sksamuel.elastic4s.searches.queries.Query
 
 case class ElasticQuery(filter: ElasticFilter) {
@@ -69,6 +70,7 @@ case class ElasticQuery(filter: ElasticFilter) {
       case between: SQLBetween[Double]     => between
       case geoDistance: ElasticGeoDistance => geoDistance
       case matchExpression: ElasticMatch   => matchExpression
+      case dateMath: SQLComparisonDateMath => dateMath
       case other =>
         throw new IllegalArgumentException(s"Unsupported filter type: ${other.getClass.getName}")
     }

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

@@ -1,11 +1,11 @@
 package app.softnetwork.elastic.sql.bridge
 
-import app.softnetwork.elastic.sql.{SQLBucket, SQLCriteria, SQLExcept, SQLField}
+import app.softnetwork.elastic.sql.{Field, SQLBucket, SQLCriteria, SQLExcept}
 import com.sksamuel.elastic4s.searches.SearchRequest
 import com.sksamuel.elastic4s.http.search.SearchBodyBuilderFn
 
 case class ElasticSearchRequest(
-  fields: Seq[SQLField],
+  fields: Seq[Field],
   except: Option[SQLExcept],
   sources: Seq[String],
   criteria: Option[SQLCriteria],

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

@@ -4,6 +4,7 @@ import com.sksamuel.elastic4s.ElasticApi
 import com.sksamuel.elastic4s.ElasticApi._
 import com.sksamuel.elastic4s.http.ElasticDsl.BuildableTermsNoOp
 import com.sksamuel.elastic4s.http.search.SearchBodyBuilderFn
+import com.sksamuel.elastic4s.script.Script
 import com.sksamuel.elastic4s.searches.aggs.Aggregation
 import com.sksamuel.elastic4s.searches.queries.Query
 import com.sksamuel.elastic4s.searches.{MultiSearchRequest, SearchRequest}
@@ -95,6 +96,17 @@ package object bridge {
         }
     }
 
+    _search = scriptFields match {
+      case Nil => _search
+      case _ =>
+        _search scriptfields scriptFields.map { field =>
+          scriptField(
+            field.scriptName,
+            Script(script = field.painless).lang("painless").scriptType("source")
+          )
+        }
+    }
+
     _search = orderBy match {
       case Some(o) if aggregates.isEmpty && buckets.isEmpty =>
         _search sortBy o.sorts.map(sort =>
@@ -134,7 +146,7 @@ package object bridge {
     value match {
       case n: SQLNumeric[_] if !aggregation =>
         operator match {
-          case _: Ge.type =>
+          case Ge =>
             maybeNot match {
               case Some(_) =>
                 applyNumericOp(n)(
@@ -147,7 +159,7 @@ package object bridge {
                   d => rangeQuery(identifier.name) gte d
                 )
             }
-          case _: Gt.type =>
+          case Gt =>
             maybeNot match {
               case Some(_) =>
                 applyNumericOp(n)(
@@ -160,7 +172,7 @@ package object bridge {
                   d => rangeQuery(identifier.name) gt d
                 )
             }
-          case _: Le.type =>
+          case Le =>
             maybeNot match {
               case Some(_) =>
                 applyNumericOp(n)(
@@ -173,7 +185,7 @@ package object bridge {
                   d => rangeQuery(identifier.name) lte d
                 )
             }
-          case _: Lt.type =>
+          case Lt =>
             maybeNot match {
               case Some(_) =>
                 applyNumericOp(n)(
@@ -186,7 +198,7 @@ package object bridge {
                   d => rangeQuery(identifier.name) lt d
                 )
             }
-          case _: Eq.type =>
+          case Eq =>
             maybeNot match {
               case Some(_) =>
                 applyNumericOp(n)(
@@ -199,7 +211,7 @@ package object bridge {
                   d => termQuery(identifier.name, d)
                 )
             }
-          case _: Ne.type =>
+          case Ne | Diff =>
             maybeNot match {
               case Some(_) =>
                 applyNumericOp(n)(
@@ -216,49 +228,49 @@ package object bridge {
         }
       case l: SQLLiteral if !aggregation =>
         operator match {
-          case _: Like.type =>
+          case Like =>
             maybeNot match {
               case Some(_) =>
                 not(regexQuery(identifier.name, toRegex(l.value)))
               case _ =>
                 regexQuery(identifier.name, toRegex(l.value))
             }
-          case _: Ge.type =>
+          case Ge =>
             maybeNot match {
               case Some(_) =>
                 rangeQuery(identifier.name) lt l.value
               case _ =>
                 rangeQuery(identifier.name) gte l.value
             }
-          case _: Gt.type =>
+          case Gt =>
             maybeNot match {
               case Some(_) =>
                 rangeQuery(identifier.name) lte l.value
               case _ =>
                 rangeQuery(identifier.name) gt l.value
             }
-          case _: Le.type =>
+          case Le =>
             maybeNot match {
               case Some(_) =>
                 rangeQuery(identifier.name) gt l.value
               case _ =>
                 rangeQuery(identifier.name) lte l.value
             }
-          case _: Lt.type =>
+          case Lt =>
             maybeNot match {
               case Some(_) =>
                 rangeQuery(identifier.name) gte l.value
               case _ =>
                 rangeQuery(identifier.name) lt l.value
             }
-          case _: Eq.type =>
+          case Eq =>
             maybeNot match {
               case Some(_) =>
                 not(termQuery(identifier.name, l.value))
               case _ =>
                 termQuery(identifier.name, l.value)
             }
-          case _: Ne.type =>
+          case Ne | Diff =>
             maybeNot match {
               case Some(_) =>
                 termQuery(identifier.name, l.value)
@@ -269,14 +281,14 @@ package object bridge {
         }
       case b: SQLBoolean if !aggregation =>
         operator match {
-          case _: Eq.type =>
+          case Eq =>
             maybeNot match {
               case Some(_) =>
                 not(termQuery(identifier.name, b.value))
               case _ =>
                 termQuery(identifier.name, b.value)
             }
-          case _: Ne.type =>
+          case Ne | Diff =>
             maybeNot match {
               case Some(_) =>
                 termQuery(identifier.name, b.value)
@@ -289,6 +301,26 @@ package object bridge {
     }
   }
 
+  implicit def dateMathToQuery(dateMath: SQLComparisonDateMath): Query = {
+    import dateMath._
+    if (aggregation)
+      return matchAllQuery()
+    dateTimeFunction match {
+      case _: CurrentTimeFunction =>
+        scriptQuery(Script(script = script).lang("painless").scriptType("source"))
+      case _ =>
+        val op = if (maybeNot.isDefined) operator.not else operator
+        op match {
+          case Gt        => rangeQuery(identifier.name) gt script
+          case Ge        => rangeQuery(identifier.name) gte script
+          case Lt        => rangeQuery(identifier.name) lt script
+          case Le        => rangeQuery(identifier.name) lte script
+          case Eq        => rangeQuery(identifier.name) gte script lte script
+          case Ne | Diff => not(rangeQuery(identifier.name) gte script lte script)
+        }
+    }
+  }
+
   implicit def isNullToQuery(
     isNull: SQLIsNull
   ): Query = {