flowable/flowable-engine · error · FlowableDmnExpressionException

Error while executing input entry

Error message

Error while executing input entry: {}

What it means

executeInputExpression in ELExpressionExecutor logs this warning and then throws FlowableDmnExpressionException when evaluating a DMN decision table input entry (condition) expression fails. It means the EL expression in the input entry could not be evaluated against the rule's stack variables, so the decision cannot be computed.

Solutions

1. Read the wrapped exception/stack trace to find the failing expression and root cause.
2. Verify input entry expressions reference variables actually present in the execution context (input data names).
3. Test the expression against sample values and correct syntax/operators.
4. Ensure custom EL functions/beans used in the expression are registered on the DMN engine configuration.

Example fix

// before (DMN XML input entry)
<text>${amount > 1000}</text> <!-- 'amount' not in context -->
// after
<text>${invoiceAmount > 1000}</text> <!-- matches input variable -->

// Validate expression inputs before decision execution
Map<String, Object> vars = dmnExecutionContext.getStackVariables();
if (!vars.containsKey("invoiceAmount")) throw new IllegalArgumentException("Missing DMN input variable invoiceAmount");

try { decisionTableResults = dmnRuleService.createExecuteDecisionBuilder()...execute(); }
catch (FlowableDmnExpressionException e) { log.error("Input entry '{}' failed: {}", e.getExpression(), e.getCause(), e); }

When it happens

Trigger: A DMN decision table input entry expression throws any exception during condition.evaluate — unknown variable in the execution context, wrong operator/function, or class cast issue while evaluating.

Common situations: Typos in input variable names in the DMN XML; using functions not registered in the Flowable EL context; input data supplied under a different name than the expression expects; version migration changed built-in EL functions.

Understand the failure class

Background: "Must be a positive integer", "Invalid value", "Unsupported": the invalid-argument-value error family, when a library rejects the value you pass — this error's family across 35 libraries.

Related errors

• Cannot set value of '', it's readonly!
• Could not create conclusion result
• Could not execute decision: no externalRef defined for
• Decision has multiple results
• decisionTableReferenceKey expression does not resolve to a…

AI-assisted analysis of flowable/flowable-engine@d6d39ce1c6 (2026-09-11). Data as JSON: /api/errors/79b6d368aa61bbf6. Report an issue: GitHub.

Appendix: source

Thrown at modules/flowable-dmn-engine/src/main/java/org/flowable/dmn/engine/impl/el/ELExpressionExecutor.java:58

            throw new IllegalArgumentException("input entry is required");
        }
        if (executionContext == null) {
            throw new IllegalArgumentException("execution context is required");
        }
        
        String inputExpression = inputClause.getInputExpression().getText();
        executionContext.checkExecutionContext(inputExpression);
        
        // pre parse expression
        String parsedExpression = ELInputEntryExpressionPreParser.parse(inputEntry.getText(), inputExpression, inputClause.getInputExpression().getTypeRef());

        Expression expression = expressionManager.createExpression(parsedExpression);
        RuleExpressionCondition condition = new RuleExpressionCondition(expression);
        
        try {
            return condition.evaluate(executionContext.getStackVariables(), executionContext);
        } catch (Exception ex) {
            LOGGER.warn("Error while executing input entry: {}", parsedExpression, ex);
            throw new FlowableDmnExpressionException("error while executing input entry", parsedExpression, ex);
        }
    }

    public static Object executeOutputExpression(OutputClause outputClause, LiteralExpression outputEntry, ExpressionManager expressionManager, ELExecutionContext executionContext) {
        if (outputClause == null) {
            throw new IllegalArgumentException("output clause is required");
        }
        if (outputEntry == null) {
            throw new IllegalArgumentException("output entry is required");
        }
        if (executionContext == null) {
            throw new IllegalArgumentException("execution context is required");
        }
        
        String parsedExpression = ELOutputEntryExpressionPreParser.parse(outputEntry.getText());
        
        Expression expression = expressionManager.createExpression(parsedExpression);

View on GitHub (pinned to d6d39ce1c6)