Merge branch '2.19'

Author: cowtowncoder

release-notes/VERSION-2.x

@@ -42,6 +42,9 @@ Project: jackson-databind
 #4773: `SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS` should not apply to Maps
   with uncomparable keys
  (requested by @nathanukey)
+#4801: Add `JsonNodeFeature.USE_BIG_DECIMAL_FOR_FLOATS` to allow overriding
+  `DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS`
+ (fix by Joo-Hyuk K)
 #4849 Not able to deserialize Enum with default typing after upgrading 2.15.4 -> 2.17.1
  (reported by Kornel Zemla)
 #4863: Add basic Stream support in `JsonNode`: `valueStream()`, `propertyStream()`,

src/main/java/tools/jackson/databind/cfg/JsonNodeFeature.java

@@ -33,8 +33,6 @@ public enum JsonNodeFeature implements DatatypeFeature
      * order from the input document.
      *<p>
      * Default value: {@code false}
-     *
-     * @since 2.16
      */
     WRITE_PROPERTIES_SORTED(false),
 
@@ -72,10 +70,29 @@ public enum JsonNodeFeature implements DatatypeFeature
      * <p>
      * Default value is {@code false} for backwards-compatibility, but will most likely be changed to
      * {@code true} in 3.0.
+     */
+    FAIL_ON_NAN_TO_BIG_DECIMAL_COERCION(false),
+
+    /**
+     * Determines whether floating-point numbers should be deserialized into
+     * {@link java.math.BigDecimal} when reading {@link tools.jackson.databind.JsonNode}s.
+     * This feature provides more precise control over number deserialization for {@code JsonNode}
+     * and takes precedence over {@link tools.jackson.databind.DeserializationFeature#USE_BIG_DECIMAL_FOR_FLOATS}
+     * if explicitly set.
      *
-     * @since 2.16
+     * <p>
+     * Behavior follows these rules:
+     * <ul>
+     *   <li>If explicitly enabled, floating-point numbers will be read as {@link java.math.BigDecimal}.</li>
+     *   <li>If explicitly disabled, floating-point numbers will be read as {@link java.lang.Double}.</li>
+     *   <li>If left undefined (default), the behavior follows {@code DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS}.</li>
+     * </ul>
+     *
+     * <p>
+     * Default value is {@code false} but unless explicitly set, handling
+     * depends on more general {@code DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS}).
      */
-    FAIL_ON_NAN_TO_BIG_DECIMAL_COERCION(false)
+    USE_BIG_DECIMAL_FOR_FLOATS(false),
     ;
 
     private final static int FEATURE_INDEX = DatatypeFeatures.FEATURE_INDEX_JSON_NODE;

src/main/java/tools/jackson/databind/deser/jackson/BaseNodeDeserializer.java

@@ -5,6 +5,7 @@
 
 import tools.jackson.core.*;
 import tools.jackson.databind.*;
+import tools.jackson.databind.cfg.DatatypeFeatures;
 import tools.jackson.databind.cfg.JsonNodeFeature;
 import tools.jackson.databind.deser.std.StdDeserializer;
 import tools.jackson.databind.jsontype.TypeDeserializer;
@@ -530,7 +531,7 @@ protected final JsonNode _fromFloat(JsonParser p, DeserializationContext ctxt,
     {
         // 13-Jan-2024, tatu: With 2.17 we have `JsonParser.getNumberTypeFP()` which
         //   will return concrete FP type if format has one (JSON doesn't; most binary
-        //   formats do.
+        //   formats do).
         //   But with `DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS` we have mechanism
         //   that may override optimal physical representation. So heuristics to use are:
         //
@@ -548,7 +549,14 @@ protected final JsonNode _fromFloat(JsonParser p, DeserializationContext ctxt,
             }
             return nodeFactory.numberNode(nr);
         }
-        if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
+        // [databind#4801] Add JsonNodeFeature.USE_BIG_DECIMAL_FOR_FLOATS
+        DatatypeFeatures dtf = ctxt.getDatatypeFeatures();
+        Boolean dtfState = dtf.getExplicitState(JsonNodeFeature.USE_BIG_DECIMAL_FOR_FLOATS);
+        boolean useBigDecimal = (dtfState == null) // not explicitly set
+                ? ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                    : dtfState.booleanValue();
+
+        if (useBigDecimal) {
             // [databind#4194] Add an option to fail coercing NaN to BigDecimal
             // Currently, Jackson 2.x allows such coercion, but Jackson 3.x will not
             if (p.isNaN()) {

src/main/java/tools/jackson/databind/introspect/PotentialCreator.java

@@ -35,7 +35,7 @@ public class PotentialCreator
      * Parameter definitions if (and only if) this represents a
      * Property-based Creator.
      */
-    private List<BeanPropertyDefinition> propertyDefs;
+    private List<BeanPropertyDefinition> _propertyDefs;
 
     public PotentialCreator(AnnotatedWithParams cr,
             JsonCreator.Mode cm)
@@ -67,7 +67,7 @@ public PotentialCreator overrideMode(JsonCreator.Mode mode) {
 
     @SuppressWarnings("unchecked")
     public void assignPropertyDefs(List<? extends BeanPropertyDefinition> propertyDefs) {
-        this.propertyDefs = (List<BeanPropertyDefinition>) propertyDefs;
+        _propertyDefs = (List<BeanPropertyDefinition>) propertyDefs;
     }
 
     public PotentialCreator introspectParamNames(MapperConfig<?> config)
@@ -214,10 +214,10 @@ public String implicitNameSimple(int ix) {
     }
 
     public BeanPropertyDefinition[] propertyDefs() {
-        if (propertyDefs == null || propertyDefs.isEmpty()) {
+        if (_propertyDefs == null || _propertyDefs.isEmpty()) {
             return new BeanPropertyDefinition[0];
         }
-        return propertyDefs.toArray(new BeanPropertyDefinition[propertyDefs.size()]);
+        return _propertyDefs.toArray(new BeanPropertyDefinition[_propertyDefs.size()]);
     }
 
     /*

src/test/java/tools/jackson/databind/node/NodeFeaturesTest.java

@@ -1,5 +1,7 @@
 package tools.jackson.databind.node;
 
+import java.math.BigDecimal;
+
 import org.junit.jupiter.api.Test;
 
 import tools.jackson.databind.*;
@@ -156,4 +158,56 @@ public void testWriteSortedProperties() throws Exception
     /* Other features
     /**********************************************************************
      */
+
+    // [databind#4801] USE_BIG_DECIMAL_FOR_FLOATS
+    @Test
+    public void testBigDecimalForJsonNodeFeature() throws Exception {
+        final String JSON = "0.1234567890123456789012345678912345"; // Precision-sensitive
+
+        BigDecimal expectedBigDecimal = new BigDecimal("0.1234567890123456789012345678912345"); // Full precision
+        BigDecimal expectedDoubleLossy = new BigDecimal("0.12345678901234568"); // Precision loss
+
+        ObjectMapper mapper;
+
+        // Case 1: Both enabled → Should use BigDecimal
+        mapper = JsonMapper.builder()
+                .enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .enable(JsonNodeFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .build();
+        assertEquals(expectedBigDecimal, mapper.readTree(JSON).decimalValue());
+
+        // Case 2: Global enabled, JsonNodeFeature disabled → Should use Double (truncated decimal)
+        mapper = JsonMapper.builder()
+                .enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .disable(JsonNodeFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .build();
+        assertEquals(expectedDoubleLossy, mapper.readTree(JSON).decimalValue());
+
+        // Case 3: Global enabled, JsonNodeFeature undefined → Should use BigDecimal (default to global)
+        mapper = JsonMapper.builder()
+                .enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .build();
+        assertEquals(expectedBigDecimal, mapper.readTree(JSON).decimalValue());
+
+        // Case 4: Global disabled, JsonNodeFeature enabled → Should use BigDecimal
+        mapper = JsonMapper.builder()
+                .disable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .enable(JsonNodeFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .build();
+        assertEquals(expectedBigDecimal, mapper.readTree(JSON).decimalValue());
+
+        // Case 5: Both disabled → Should use Double (truncated decimal)
+        mapper = JsonMapper.builder()
+                .disable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .disable(JsonNodeFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .build();
+        assertEquals(expectedDoubleLossy, mapper.readTree(JSON).decimalValue());
+
+        // Case 6: Global disabled, JsonNodeFeature undefined → Should use Double (default to global, truncated decimal)
+        mapper = JsonMapper.builder()
+                .disable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)
+                .build();
+        assertEquals(expectedDoubleLossy, mapper.readTree(JSON).decimalValue());
+    }
+
 }