BigDecimal precision not retained for polymorphic deserialization

[rost5000]

I used the gradle project, using implementation:

implementation(
            "com.fasterxml.jackson.core:jackson-annotations:2.10.3",
            "com.fasterxml.jackson.core:jackson-core:2.10.3",
            "com.fasterxml.jackson.core:jackson-databind:2.10.3",
)

A simple test have failed:

public class JacksonTest {
    @Test
    public void doTest() throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerSubtypes(NodeParent.class);


        HttpRestClientTest.NodeRoot root = mapper.readValue(
                "{\"type\": \"NodeParent\",\"node\": {\"amount\": 9999999999999999.99} }",
                NodeRoot.class
        );

        assertEquals(new BigDecimal("9999999999999999.99"), root.getNode().getVal());

    }


    public static class NodeRoot {
        private String type;
        private Node node;

        @Override
        public String toString() {
            return "NodeRoot{" +
                    "node=" + node +
                    '}';
        }

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }

        public Node getNode() {
            return node;
        }

        @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXTERNAL_PROPERTY, property = "type")
        @JsonSubTypes(value = {
                @JsonSubTypes.Type(value = NodeParent.class, name = "NodeParent")
        })
        public void setNode(Node node) {
            this.node = node;
        }
    }


    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class NodeParent extends Node {

        @Override
        public String toString() {
            return "NodeParent{" +
                    ", val=" + val +
                    '}';
        }
    }

    @JsonIgnoreProperties(ignoreUnknown = true)
    public static abstract class Node {
        @JsonProperty("amount")
        BigDecimal val;

        public BigDecimal getVal() {
            return val;
        }

        public void setVal(BigDecimal val) {
            this.val = val;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "val=" + val +
                    '}';
        }
    }
}

The output is expected: <9999999999999999.99> but was: <1.0E+16>

What should I do?

[cowtowncoder]

This sounds like a bug, from quick look. Thank you for providing reproduction!

One thing you can try is to enable setting DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS and see if that makes a difference.
It should not be needed here (since property is clearly typed as BigDecimal) but it is relevant for conversions and coercions that would happen in other cases so maybe worth checking as workaround.

[cowtowncoder]

Hmmh. Probably related to buffering needed for polymorphic types.

[cowtowncoder]

Ah. Ok, yes, DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS does actually prevent this.
The problem is due to buffering needed to support JsonTypeInfo.As.EXTERNAL_PROPERTY (as well as in other cases where location of type id not guaranteed to be before value).
JSON being textual format, parser does not really have concept of what accuracy is needed for floating-point values, and for buffering, for now, has to decide how to decode it before knowing how value is to be used. Double is quite a bit faster to process than BigDecimal and this is the default.

I will add a failing test and perhaps some time in future handling can be improved to defer decoding, to allow full precision even in cases like this. But until then I think you should just enable feature I mentioned and retain full accuracy.

[rost5000]

It's works. Thank you for you quick replaying)

[cowtowncoder]

@rost5000 glad it works; thank you for reporting the issue and verifying work-around.

[cowtowncoder]

Was able to figure out a way to fix this for 2.12.0.