rename MathScript to DateMathScript, add SQLNull type

fupelaqu · fupelaqu · commit d5c8d7010b2a · 2025-10-01T06:29:47.000+02:00
diff --git a/es6/sql-bridge/src/main/scala/app/softnetwork/elastic/sql/bridge/package.scala b/es6/sql-bridge/src/main/scala/app/softnetwork/elastic/sql/bridge/package.scala
@@ -1,6 +1,6 @@
 package app.softnetwork.elastic.sql
 
-import app.softnetwork.elastic.sql.`type`.{SQLBigInt, SQLDouble}
+import app.softnetwork.elastic.sql.`type`.{SQLBigInt, SQLDouble, SQLTemporal, SQLVarchar}
 import app.softnetwork.elastic.sql.function.aggregate.COUNT
 import app.softnetwork.elastic.sql.function.geo.{Distance, Meters}
 import app.softnetwork.elastic.sql.operator._
@@ -468,17 +468,24 @@ package object bridge {
       case _ =>
     }
     val r =
-      out match {
+      fromTo.out match {
         case _: SQLDouble =>
           rangeQuery(identifier.name) gte fromTo.from.value.asInstanceOf[Double] lte fromTo.to.value
             .asInstanceOf[Double]
         case _: SQLBigInt =>
           rangeQuery(identifier.name) gte fromTo.from.value.asInstanceOf[Long] lte fromTo.to.value
             .asInstanceOf[Long]
-        case _ =>
+        case _: SQLVarchar =>
           rangeQuery(identifier.name) gte String.valueOf(fromTo.from.value) lte String.valueOf(
             fromTo.to.value
           )
+        case _: SQLTemporal =>
+          // TODO
+          throw new IllegalArgumentException(
+            "Range queries on temporal values are not supported yet"
+          )
+        case other =>
+          throw new IllegalArgumentException(s"Unsupported type for range query: $other")
       }
     maybeNot match {
       case Some(_) => not(r)
diff --git a/sql/bridge/src/main/scala/app/softnetwork/elastic/sql/bridge/package.scala b/sql/bridge/src/main/scala/app/softnetwork/elastic/sql/bridge/package.scala
@@ -1,6 +1,6 @@
 package app.softnetwork.elastic.sql
 
-import app.softnetwork.elastic.sql.`type`.{SQLBigInt, SQLDouble}
+import app.softnetwork.elastic.sql.`type`.{SQLBigInt, SQLDouble, SQLTemporal, SQLVarchar}
 import app.softnetwork.elastic.sql.function.aggregate.COUNT
 import app.softnetwork.elastic.sql.function.geo.{Distance, Meters}
 import app.softnetwork.elastic.sql.operator._
@@ -468,13 +468,22 @@ package object bridge {
       case _ =>
     }
     val r =
-      out match {
+      fromTo.out match {
         case _: SQLDouble =>
-          rangeQuery(identifier.name) gte fromTo.from.value.asInstanceOf[Double] lte fromTo.to.value.asInstanceOf[Double]
+          rangeQuery(identifier.name) gte fromTo.from.value.asInstanceOf[Double] lte fromTo.to.value
+            .asInstanceOf[Double]
         case _: SQLBigInt =>
-          rangeQuery(identifier.name) gte fromTo.from.value.asInstanceOf[Long] lte fromTo.to.value.asInstanceOf[Long]
-        case _ =>
-          rangeQuery(identifier.name) gte String.valueOf(fromTo.from.value) lte String.valueOf(fromTo.to.value)
+          rangeQuery(identifier.name) gte fromTo.from.value.asInstanceOf[Long] lte fromTo.to.value
+            .asInstanceOf[Long]
+        case _: SQLVarchar =>
+          rangeQuery(identifier.name) gte String.valueOf(fromTo.from.value) lte String.valueOf(
+            fromTo.to.value
+          )
+        case _: SQLTemporal =>
+          // TODO
+          throw new IllegalArgumentException("Range queries on temporal values are not supported yet")
+        case other =>
+          throw new IllegalArgumentException(s"Unsupported type for range query: $other")
       }
     maybeNot match {
       case Some(_) => not(r)
diff --git a/sql/src/main/scala/app/softnetwork/elastic/sql/function/package.scala b/sql/src/main/scala/app/softnetwork/elastic/sql/function/package.scala
@@ -63,8 +63,8 @@ package object function {
     def toScript: Option[String] = {
       val orderedFunctions = FunctionUtils.transformFunctions(this).reverse
       orderedFunctions.foldLeft(Option("")) {
-        case (expr, f: MathScript) if expr.isDefined => Option(s"${expr.get}${f.script}")
-        case (_, _)                                  => None // ignore non math scripts
+        case (expr, f: DateMathScript) if expr.isDefined => Option(s"${expr.get}${f.script}")
+        case (_, _)                                      => None // ignore non math scripts
       } match {
         case Some(s) if s.nonEmpty =>
           out match {
@@ -75,6 +75,8 @@ package object function {
       }
     }
 
+    override def dateMathScript: Boolean = toScript.isDefined
+
     override def system: Boolean = functions.lastOption.exists(_.system)
 
     def applyTo(expr: Token): Unit = {
diff --git a/sql/src/main/scala/app/softnetwork/elastic/sql/function/time/package.scala b/sql/src/main/scala/app/softnetwork/elastic/sql/function/time/package.scala
@@ -1,6 +1,6 @@
 package app.softnetwork.elastic.sql.function
 
-import app.softnetwork.elastic.sql.{Expr, Identifier, MathScript, PainlessScript, TokenRegex}
+import app.softnetwork.elastic.sql.{DateMathScript, Expr, Identifier, PainlessScript, TokenRegex}
 import app.softnetwork.elastic.sql.operator.time._
 import app.softnetwork.elastic.sql.`type`.{
   SQLDate,
@@ -18,7 +18,7 @@ package object time {
 
   sealed trait IntervalFunction[IO <: SQLTemporal]
       extends TransformFunction[IO, IO]
-      with MathScript {
+      with DateMathScript {
     def operator: IntervalOperator
 
     override def fun: Option[IntervalOperator] = Some(operator)
@@ -93,13 +93,13 @@ package object time {
   sealed trait CurrentDateTimeFunction
       extends DateTimeFunction
       with CurrentFunction
-      with MathScript {
+      with DateMathScript {
     override def painless: String =
       SQLTypeUtils.coerce(now, this.baseType, this.out, nullable = false)
     override def script: String = "now"
   }
 
-  sealed trait CurrentDateFunction extends DateFunction with CurrentFunction with MathScript {
+  sealed trait CurrentDateFunction extends DateFunction with CurrentFunction with DateMathScript {
     override def painless: String =
       SQLTypeUtils.coerce(s"$now.toLocalDate()", this.baseType, this.out, nullable = false)
     override def script: String = "now"
@@ -315,6 +315,7 @@ package object time {
     override def toSQL(base: String): String = {
       s"$sql($base, ${interval.sql})"
     }
+    override def dateMathScript: Boolean = identifier.dateMathScript
   }
 
   case object DateSub extends Expr("DATE_SUB") with TokenRegex {
@@ -332,6 +333,7 @@ package object time {
     override def toSQL(base: String): String = {
       s"$sql($base, ${interval.sql})"
     }
+    override def dateMathScript: Boolean = identifier.dateMathScript
   }
 
   sealed trait FunctionWithDateTimeFormat {
@@ -452,6 +454,7 @@ package object time {
     override def toSQL(base: String): String = {
       s"$sql($base, ${interval.sql})"
     }
+    override def dateMathScript: Boolean = identifier.dateMathScript
   }
 
   case object DateTimeSub extends Expr("DATETIME_SUB") with TokenRegex {
@@ -469,6 +472,7 @@ package object time {
     override def toSQL(base: String): String = {
       s"$sql($base, ${interval.sql})"
     }
+    override def dateMathScript: Boolean = identifier.dateMathScript
   }
 
   case object DateTimeParse extends Expr("DATETIME_PARSE") with TokenRegex with PainlessScript {
diff --git a/sql/src/main/scala/app/softnetwork/elastic/sql/operator/time/package.scala b/sql/src/main/scala/app/softnetwork/elastic/sql/operator/time/package.scala
@@ -1,10 +1,10 @@
 package app.softnetwork.elastic.sql.operator
 
-import app.softnetwork.elastic.sql.{Expr, MathScript}
+import app.softnetwork.elastic.sql.{DateMathScript, Expr}
 
 package object time {
 
-  sealed trait IntervalOperator extends Operator with BinaryOperator with MathScript {
+  sealed trait IntervalOperator extends Operator with BinaryOperator with DateMathScript {
     override def script: String = sql
     override def toString: String = s" $sql "
     override def painless: String = this match {
diff --git a/sql/src/main/scala/app/softnetwork/elastic/sql/package.scala b/sql/src/main/scala/app/softnetwork/elastic/sql/package.scala
@@ -42,6 +42,7 @@ package object sql {
     }
     def system: Boolean = false
     def nullable: Boolean = !system
+    def dateMathScript: Boolean = false
   }
 
   trait PainlessScript extends Token {
@@ -53,8 +54,9 @@ package object sql {
     def params: Map[String, Any]
   }
 
-  trait MathScript extends Token {
+  trait DateMathScript extends Token {
     def script: String
+    override def dateMathScript: Boolean = true
   }
 
   trait Updateable extends Token {
diff --git a/sql/src/main/scala/app/softnetwork/elastic/sql/time/package.scala b/sql/src/main/scala/app/softnetwork/elastic/sql/time/package.scala
@@ -77,7 +77,7 @@ package object time {
 
   }
 
-  sealed trait TimeUnit extends PainlessScript with MathScript {
+  sealed trait TimeUnit extends PainlessScript with DateMathScript {
     lazy val regex: Regex = s"\\b(?i)$sql(s)?\\b".r
 
     def timeUnit: String = sql.toUpperCase() + "S"
@@ -124,7 +124,7 @@ package object time {
 
   case object Interval extends Expr("INTERVAL") with TokenRegex
 
-  sealed trait TimeInterval extends PainlessScript with MathScript {
+  sealed trait TimeInterval extends PainlessScript with DateMathScript {
     def value: Int
     def unit: TimeUnit
     override def sql: String = s"$Interval $value ${unit.sql}"
@@ -148,7 +148,7 @@ package object time {
             case _                         => Left(s"Invalid interval unit $unit for TIME")
           }
         case SQLTypes.DateTime =>
-          Right(SQLTypes.Timestamp)
+          Right(SQLTypes.DateTime)
         case SQLTypes.Timestamp =>
           Right(SQLTypes.Timestamp)
         case SQLTypes.Temporal =>
diff --git a/sql/src/main/scala/app/softnetwork/elastic/sql/type/SQLType.scala b/sql/src/main/scala/app/softnetwork/elastic/sql/type/SQLType.scala
@@ -7,6 +7,8 @@ sealed trait SQLType {
 
 trait SQLAny extends SQLType
 
+trait SQLNull extends SQLType
+
 trait SQLTemporal extends SQLType
 
 trait SQLDate extends SQLTemporal
diff --git a/sql/src/main/scala/app/softnetwork/elastic/sql/type/SQLTypes.scala b/sql/src/main/scala/app/softnetwork/elastic/sql/type/SQLTypes.scala
@@ -3,7 +3,7 @@ package app.softnetwork.elastic.sql.`type`
 object SQLTypes {
   case object Any extends SQLAny { val typeId = "ANY" }
 
-  case object Null extends SQLAny { val typeId = "NULL" }
+  case object Null extends SQLNull { val typeId = "NULL" }
 
   case object Temporal extends SQLTemporal { val typeId = "TEMPORAL" }
 

Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,7 @@ package object sql {`
`42`	`42`	`}`
`43`	`43`	`def system: Boolean = false`
`44`	`44`	`def nullable: Boolean = !system`
	`45`	`+ def dateMathScript: Boolean = false`
`45`	`46`	`}`
`46`	`47`
`47`	`48`	`trait PainlessScript extends Token {`
`@@ -53,8 +54,9 @@ package object sql {`
`53`	`54`	`def params: Map[String, Any]`
`54`	`55`	`}`
`55`	`56`
`56`		`- trait MathScript extends Token {`
	`57`	`+ trait DateMathScript extends Token {`
`57`	`58`	`def script: String`
	`59`	`+ override def dateMathScript: Boolean = true`
`58`	`60`	`}`
`59`	`61`
`60`	`62`	`trait Updateable extends Token {`