introduce BinaryExpression

Author: fupelaqu

sql/src/main/scala/app/softnetwork/elastic/sql/SQLGroupBy.scala

@@ -95,8 +95,16 @@ object BucketSelectorScript {
       extractBucketsPath(left) ++ extractBucketsPath(right)
     case relation: ElasticRelation => extractBucketsPath(relation.criteria)
     case _: SQLMatch               => Map.empty //MATCH is not supported in bucket_selector
-    case SQLComparisonDateMath(identifier, _, _, _, _, _) if identifier.aggregation =>
-      Map(identifier.aliasOrName -> identifier.aliasOrName)
+    case b: BinaryExpression =>
+      import b._
+      if (left.aggregation && right.aggregation)
+        Map(left.aliasOrName -> left.aliasOrName, right.aliasOrName -> right.aliasOrName)
+      else if (left.aggregation)
+        Map(left.aliasOrName -> left.aliasOrName)
+      else if (right.aggregation)
+        Map(right.aliasOrName -> right.aliasOrName)
+      else
+        Map.empty
     case e: Expression if e.aggregation =>
       import e._
       Map(identifier.aliasOrName -> identifier.aliasOrName)
@@ -129,9 +137,9 @@ object BucketSelectorScript {
 
       // build the RHS as a Painless ZonedDateTime (apply +/- interval using TimeInterval.painless)
       val rightBase = (arithOp, interval) match {
-        case (Some(Add), Some(i))       => s"$now.plus(${i.painless})"
+        case (Some(Add), Some(i))      => s"$now.plus(${i.painless})"
         case (Some(Subtract), Some(i)) => s"$now.minus(${i.painless})"
-        case _                          => now
+        case _                         => now
       }
 
       val rightZdt = dateFunc match {

sql/src/main/scala/app/softnetwork/elastic/sql/SQLWhere.scala

@@ -178,6 +178,33 @@ case class SQLExpression(
   override def asFilter(currentQuery: Option[ElasticBoolQuery]): ElasticFilter = this
 }
 
+sealed trait BinaryExpression extends Expression {
+  def left: SQLIdentifier
+  def right: SQLIdentifier
+  override def identifier: SQLIdentifier = left
+  override def maybeValue: Option[SQLToken] = Some(right)
+  override lazy val aggregation: Boolean = left.aggregation || right.aggregation
+}
+
+case class SQLBinaryExpression(
+  left: SQLIdentifier,
+  operator: SQLComparisonOperator, // Gt, Ge, Lt, Le, Eq, ...
+  right: SQLIdentifier,
+  maybeNot: Option[Not.type] = None
+) extends BinaryExpression
+    with PainlessScript {
+  override def update(request: SQLSearchRequest): SQLCriteria =
+    this.copy(left = left.update(request), right = right.update(request))
+
+  override def asFilter(currentQuery: Option[ElasticBoolQuery]): ElasticFilter = this
+
+  override def painless: String = {
+    val painlessOp = (if (maybeNot.isDefined) operator.not else operator).painless
+    s"${left.painless} $painlessOp ${right.painless}"
+  }
+
+}
+
 case class SQLIsNull(identifier: SQLIdentifier) extends Expression {
   override val operator: SQLOperator = IsNull
 
@@ -355,9 +382,9 @@ case class SQLComparisonDateMath(
         val base = s"${dateTimeFunction.script}"
         val dateMath =
           (arithmeticOperator, interval) match {
-            case (Some(Add), Some(i))       => s"$base+${i.script}"
+            case (Some(Add), Some(i))      => s"$base+${i.script}"
             case (Some(Subtract), Some(i)) => s"$base-${i.script}"
-            case _                          => base
+            case _                         => base
           }
         dateTimeFunction match {
           case _: CurrentDateFunction => s"$dateMath/d"