Merge pull request #455 from InseeFr/fix/cast-exception

NicoLaval · web-flow · commit df765a2d3ed1 · 2025-12-22T11:05:44.000+01:00
Fix cast exception (Fix #454)
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/exceptions/CastException.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/exceptions/CastException.java
@@ -0,0 +1,33 @@
+package fr.insee.vtl.engine.exceptions;
+
+import fr.insee.vtl.model.Positioned;
+import fr.insee.vtl.model.exceptions.VtlScriptException;
+
+/**
+ * The <code>CastException</code> indicates that a cast operation failed during VTL expression
+ * evaluation.
+ */
+public class CastException extends VtlScriptException {
+
+  /**
+   * Constructor taking the parsing context and the message.
+   *
+   * @param message The exception message.
+   * @param position The parsing context where the exception is thrown.
+   */
+  public CastException(String message, Positioned position) {
+    super(message, position);
+  }
+
+  /**
+   * Constructor taking the parsing context, the message and the mother exception.
+   *
+   * @param message The exception message.
+   * @param cause The mother exception.
+   * @param position The parsing context where the exception is thrown.
+   */
+  public CastException(String message, Exception cause, Positioned position) {
+    super(message + ": " + cause.getMessage(), position);
+    initCause(cause);
+  }
+}
diff --git a/vtl-engine/src/main/java/fr/insee/vtl/engine/expressions/CastExpression.java b/vtl-engine/src/main/java/fr/insee/vtl/engine/expressions/CastExpression.java
@@ -1,6 +1,8 @@
 package fr.insee.vtl.engine.expressions;
 
+import fr.insee.vtl.engine.exceptions.CastException;
 import fr.insee.vtl.engine.exceptions.InvalidArgumentException;
+import fr.insee.vtl.engine.exceptions.VtlRuntimeException;
 import fr.insee.vtl.model.Positioned;
 import fr.insee.vtl.model.ResolvableExpression;
 import fr.insee.vtl.model.exceptions.VtlScriptException;
@@ -76,7 +78,8 @@ public ResolvableExpression castBoolean(ResolvableExpression expr) {
                 return exprValue ? 1D : 0D;
               });
     }
-    throw new ClassCastException("Cast Boolean to " + outputClass + isNotSupported);
+    throw new VtlRuntimeException(
+        new CastException("Cast Boolean to " + outputClass + isNotSupported, this));
   }
 
   private ResolvableExpression castDouble(ResolvableExpression expr) {
@@ -98,8 +101,9 @@ private ResolvableExpression castDouble(ResolvableExpression expr) {
                 Double exprValue = (Double) expr.resolve(context);
                 if (exprValue == null) return null;
                 if (exprValue % 1 != 0)
-                  throw new UnsupportedOperationException(
-                      exprValue + " can not be casted into integer");
+                  throw new VtlRuntimeException(
+                      new CastException(
+                          exprValue + " can not be casted into integer", CastExpression.this));
                 return exprValue.longValue();
               });
     if (outputClass.equals(Double.class))
@@ -115,7 +119,8 @@ private ResolvableExpression castDouble(ResolvableExpression expr) {
                 if (exprValue == null) return null;
                 return !exprValue.equals(0D);
               });
-    throw new ClassCastException("Cast Double to " + outputClass + isNotSupported);
+    throw new VtlRuntimeException(
+        new CastException("Cast Double to " + outputClass + isNotSupported, this));
   }
 
   private ResolvableExpression castInstant(ResolvableExpression expr, String mask) {
@@ -125,18 +130,24 @@ private ResolvableExpression castInstant(ResolvableExpression expr, String mask)
           .withPosition(expr)
           .using(
               context -> {
-                var value = expr.resolve(context);
-                Instant exprValue;
-                if (value instanceof LocalDate date) {
-                  exprValue = date.atStartOfDay().toInstant(ZoneOffset.UTC);
-                } else {
-                  exprValue = (Instant) value;
+                try {
+                  var value = expr.resolve(context);
+                  Instant exprValue;
+                  if (value instanceof LocalDate date) {
+                    exprValue = date.atStartOfDay().toInstant(ZoneOffset.UTC);
+                  } else {
+                    exprValue = (Instant) value;
+                  }
+                  if (exprValue == null) return null;
+                  DateTimeFormatter maskFormatter = DateTimeFormatter.ofPattern(mask);
+                  return maskFormatter.format(exprValue.atOffset(ZoneOffset.UTC));
+                } catch (Exception e) {
+                  throw new VtlRuntimeException(
+                      new CastException("Failed to cast date to string", e, CastExpression.this));
                 }
-                if (exprValue == null) return null;
-                DateTimeFormatter maskFormatter = DateTimeFormatter.ofPattern(mask);
-                return maskFormatter.format(exprValue.atOffset(ZoneOffset.UTC));
               });
-    throw new ClassCastException("Cast Date to " + outputClass + isNotSupported);
+    throw new VtlRuntimeException(
+        new CastException("Cast Date to " + outputClass + isNotSupported, this));
   }
 
   private ResolvableExpression castLong(ResolvableExpression expr) {
@@ -168,7 +179,8 @@ private ResolvableExpression castLong(ResolvableExpression expr) {
                 if (exprValue == null) return null;
                 return !exprValue.equals(0L);
               });
-    throw new ClassCastException("Cast Long to " + outputClass + isNotSupported);
+    throw new VtlRuntimeException(
+        new CastException("Cast Long to " + outputClass + isNotSupported, this));
   }
 
   private ResolvableExpression castString(ResolvableExpression expr, String mask) {
@@ -178,18 +190,54 @@ private ResolvableExpression castString(ResolvableExpression expr, String mask)
           .withPosition(expr)
           .using(
               context -> {
-                String exprValue = (String) expr.resolve(context);
-                if (exprValue == null) return null;
-                return Long.valueOf(exprValue);
+                String exprValue = null;
+                try {
+                  exprValue = (String) expr.resolve(context);
+                  if (exprValue == null) return null;
+                  if (exprValue.isEmpty()) {
+                    throw new VtlRuntimeException(
+                        new CastException(
+                            "Cannot cast empty string \"\" to integer", CastExpression.this));
+                  }
+                  return Long.valueOf(exprValue);
+                } catch (VtlRuntimeException e) {
+                  // Re-throw VtlRuntimeException as-is
+                  throw e;
+                } catch (NumberFormatException e) {
+                  String value = exprValue != null ? exprValue : "null";
+                  throw new VtlRuntimeException(
+                      new CastException(
+                          "Failed to cast string \"" + value + "\" to integer",
+                          e,
+                          CastExpression.this));
+                }
               });
     } else if (outputClass.equals(Double.class)) {
       return ResolvableExpression.withType(Double.class)
           .withPosition(expr)
           .using(
               context -> {
-                String exprValue = (String) expr.resolve(context);
-                if (exprValue == null) return null;
-                return Double.valueOf(exprValue);
+                String exprValue = null;
+                try {
+                  exprValue = (String) expr.resolve(context);
+                  if (exprValue == null) return null;
+                  if (exprValue.isEmpty()) {
+                    throw new VtlRuntimeException(
+                        new CastException(
+                            "Cannot cast empty string \"\" to number", CastExpression.this));
+                  }
+                  return Double.valueOf(exprValue);
+                } catch (VtlRuntimeException e) {
+                  // Re-throw VtlRuntimeException as-is
+                  throw e;
+                } catch (NumberFormatException e) {
+                  String value = exprValue != null ? exprValue : "null";
+                  throw new VtlRuntimeException(
+                      new CastException(
+                          "Failed to cast string \"" + value + "\" to number",
+                          e,
+                          CastExpression.this));
+                }
               });
     } else if (outputClass.equals(Boolean.class)) {
       return ResolvableExpression.withType(Boolean.class)
@@ -205,42 +253,76 @@ private ResolvableExpression castString(ResolvableExpression expr, String mask)
           .withPosition(expr)
           .using(
               context -> {
-                if (mask == null) return null;
-                String exprValue = (String) expr.resolve(context);
-                if (exprValue == null) return null;
-                // The spec is pretty vague about date and time. Apparently, date is a point in time
-                // so a good java
-                // representation is Instant. But date can be created using only year/month and date
-                // mask, leaving
-                // any time information.
-                DateTimeFormatter maskFormatter =
-                    DateTimeFormatter.ofPattern(mask).withZone(ZoneOffset.UTC);
+                String exprValue = null;
                 try {
-                  return LocalDateTime.parse(exprValue, maskFormatter).toInstant(ZoneOffset.UTC);
-                } catch (DateTimeParseException dtp) {
-                  return LocalDate.parse(exprValue, maskFormatter)
-                      .atStartOfDay()
-                      .toInstant(ZoneOffset.UTC);
+                  if (mask == null) return null;
+                  exprValue = (String) expr.resolve(context);
+                  if (exprValue == null) return null;
+                  if (exprValue.isEmpty()) {
+                    throw new VtlRuntimeException(
+                        new CastException(
+                            "Cannot cast empty string \"\" to date (mask: \"" + mask + "\")",
+                            CastExpression.this));
+                  }
+                  // The spec is pretty vague about date and time. Apparently, date is a point
+                  // in time so a good Java representation is Instant. But date can be created
+                  // using only year/month and date mask, leaving any time information.
+                  DateTimeFormatter maskFormatter =
+                      DateTimeFormatter.ofPattern(mask).withZone(ZoneOffset.UTC);
+                  try {
+                    return LocalDateTime.parse(exprValue, maskFormatter).toInstant(ZoneOffset.UTC);
+                  } catch (DateTimeParseException dtp) {
+                    return LocalDate.parse(exprValue, maskFormatter)
+                        .atStartOfDay()
+                        .toInstant(ZoneOffset.UTC);
+                  }
+                } catch (VtlRuntimeException e) {
+                  // Re-throw VtlRuntimeException as-is
+                  throw e;
+                } catch (Exception e) {
+                  String value = exprValue != null ? exprValue : "null";
+                  throw new VtlRuntimeException(
+                      new CastException(
+                          "Failed to cast string \""
+                              + value
+                              + "\" to date with mask \""
+                              + mask
+                              + "\"",
+                          e,
+                          CastExpression.this));
                 }
               });
     } else if (outputClass.equals(PeriodDuration.class)) {
       return ResolvableExpression.withType(PeriodDuration.class)
           .withPosition(expr)
           .using(
               context -> {
-                String value = (String) expr.tryCast(String.class).resolve(context);
-                return PeriodDuration.parse(value).normalizedYears().normalizedStandardDays();
+                try {
+                  String value = (String) expr.tryCast(String.class).resolve(context);
+                  return PeriodDuration.parse(value).normalizedYears().normalizedStandardDays();
+                } catch (Exception e) {
+                  throw new VtlRuntimeException(
+                      new CastException(
+                          "Failed to cast string to duration", e, CastExpression.this));
+                }
               });
     } else if (outputClass.equals(Interval.class)) {
       return ResolvableExpression.withType(Interval.class)
           .withPosition(expr)
           .using(
               context -> {
-                String value = (String) expr.tryCast(String.class).resolve(context);
-                return Interval.parse(value);
+                try {
+                  String value = (String) expr.tryCast(String.class).resolve(context);
+                  return Interval.parse(value);
+                } catch (Exception e) {
+                  throw new VtlRuntimeException(
+                      new CastException(
+                          "Failed to cast string to interval", e, CastExpression.this));
+                }
               });
     } else {
-      throw new ClassCastException("Cast String to " + outputClass + isNotSupported);
+      throw new VtlRuntimeException(
+          new CastException("Cast String to " + outputClass + isNotSupported, this));
     }
   }
 
diff --git a/vtl-engine/src/test/java/fr/insee/vtl/engine/visitors/expression/functions/GenericFunctionsTest.java b/vtl-engine/src/test/java/fr/insee/vtl/engine/visitors/expression/functions/GenericFunctionsTest.java
@@ -3,6 +3,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import fr.insee.vtl.engine.exceptions.CastException;
 import fr.insee.vtl.engine.exceptions.InvalidArgumentException;
 import java.time.Instant;
 import java.time.Period;
@@ -126,14 +127,14 @@ public void testCastExprDataset() throws ScriptException {
             () -> {
               engine.eval("g := cast(\"\", integer);");
             })
-        .isInstanceOf(NumberFormatException.class)
-        .hasMessage("For input string: \"\"");
+        .isInstanceOf(CastException.class)
+        .hasMessage("Cannot cast empty string \"\" to integer");
     assertThatThrownBy(
             () -> {
               engine.eval("h := cast(\"\", number);");
             })
-        .isInstanceOf(NumberFormatException.class)
-        .hasMessage("empty String");
+        .isInstanceOf(CastException.class)
+        .hasMessage("Cannot cast empty string \"\" to number");
 
     // Cast Boolean to...
     engine.eval("i := cast(true, integer);");
@@ -170,7 +171,7 @@ public void testCastExprDataset() throws ScriptException {
             () -> {
               engine.eval("v := cast(1.1, integer);");
             })
-        .isInstanceOf(UnsupportedOperationException.class)
+        .isInstanceOf(CastException.class)
         .hasMessage("1.1 can not be casted into integer");
     engine.eval("w := cast(1.1, number);");
     assertThat(context.getAttribute("w")).isEqualTo(1.1D);
diff --git a/vtl-spark/pom.xml b/vtl-spark/pom.xml
@@ -32,7 +32,7 @@
             <groupId>fr.insee.trevas</groupId>
             <artifactId>vtl-engine</artifactId>
             <version>2.1.0-SNAPSHOT</version>
-            <scope>test</scope>
+            <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.spark</groupId>
diff --git a/vtl-spark/src/main/java/fr/insee/vtl/spark/SparkDataset.java b/vtl-spark/src/main/java/fr/insee/vtl/spark/SparkDataset.java
diff --git a/vtl-spark/src/main/java/fr/insee/vtl/spark/SparkProcessingEngine.java b/vtl-spark/src/main/java/fr/insee/vtl/spark/SparkProcessingEngine.java
