appsmithorg/appsmith · error · AppsmithPluginException

PE-UQI-5000

PE-UQI-5000

Error message

{} is not a known conditional operator. Please reach out to Appsmith customer support to report this

What it means

Thrown by PluginUtils.parseWhereClause when the 'condition' field of a UQI where-clause map cannot be mapped to a ConditionalOperator enum value. ConditionalOperator.valueOf is invoked on the trimmed, upper-cased string; any value that is not exactly one of EQ, NOT_EQ, LT, LTE, GT, GTE, CONTAINS, IN, NOT_IN, AND, OR (and any others declared on the enum) raises IllegalArgumentException, which is caught and re-thrown as PLUGIN_UQI_WHERE_CONDITION_UNKNOWN with the offending operator string as the argument.

Source

Thrown at app/server/appsmith-interfaces/src/main/java/com/appsmith/external/helpers/PluginUtils.java:370

    }

    public static Condition parseWhereClause(Map<String, Object> whereClause) {
        // Only proceed if this is a valid condition
        if (whereClause == null || !(whereClause.containsKey(KEY) || whereClause.containsKey(CHILDREN))) {
            return null;
        }
        Condition condition = new Condition();

        Object unparsedOperator = whereClause.getOrDefault(CONDITION, ConditionalOperator.EQ.name());

        ConditionalOperator operator;
        try {
            operator = ConditionalOperator.valueOf(
                    ((String) unparsedOperator).trim().toUpperCase());
        } catch (IllegalArgumentException e) {
            // The operator could not be cast into a known type. Throw an exception
            log.error(e.getMessage());
            throw new AppsmithPluginException(AppsmithPluginError.PLUGIN_UQI_WHERE_CONDITION_UNKNOWN, unparsedOperator);
        }

        condition.setOperator(operator);

        // For logical operators, we must walk all the children and add the same as values to this condition
        if (operator.equals(ConditionalOperator.AND) || operator.equals(ConditionalOperator.OR)) {
            List<Condition> children = new ArrayList<>();
            List<Map<String, Object>> conditionList = (List) whereClause.get(CHILDREN);
            for (Map<String, Object> unparsedCondition : conditionList) {
                Condition childCondition = parseWhereClause(unparsedCondition);
                if (childCondition != null) {
                    children.add(childCondition);
                }
            }
            if (!children.isEmpty()) {
                condition.setValue(children);
            }
        } else {

View on GitHub (pinned to 8cd9021c24)

Solutions

1. Check the value of whereClause['condition'] in the request payload - it must be one of the ConditionalOperator enum names (case-insensitive).
2. Replace synonyms with the canonical enum name (e.g. 'equals' -> 'EQ', 'not equal' -> 'NOT_EQ', 'less than' -> 'LT').
3. If you need a custom operator, ensure the frontend submits the exact enum string and not a display label.
4. Wrap dynamic operator input in a whitelist check against ConditionalOperator.values() before sending the request.

Example fix

// before
operator = ConditionalOperator.valueOf(
    ((String) unparsedOperator).trim().toUpperCase());

// after - validate against the known enum set
String normalized = ((String) unparsedOperator).trim().toUpperCase();
ConditionalOperator operator = Arrays.stream(ConditionalOperator.values())
    .filter(op -> op.name().equals(normalized))
    .findFirst()
    .orElseThrow(() -> new AppsmithPluginException(
        AppsmithPluginError.PLUGIN_UQI_WHERE_CONDITION_UNKNOWN,
        unparsedOperator));

public static boolean isKnownOperator(String raw) {
    if (raw == null) return false;
    String normalized = raw.trim().toUpperCase();
    return Arrays.stream(ConditionalOperator.values())
        .map(ConditionalOperator::name)
        .anyMatch(normalized::equals);
}

// guard before calling parseWhereClause
if (!isKnownOperator((String) whereClause.get(CONDITION))) {
    // reject or default to EQ
    whereClause.put(CONDITION, ConditionalOperator.EQ.name());
}

public static ConditionalOperator safeOperator(Object raw) {
    if (!(raw instanceof String)) return null;
    String n = ((String) raw).trim().toUpperCase();
    return Arrays.stream(ConditionalOperator.values())
        .filter(op -> op.name().equals(n))
        .findFirst()
        .orElse(null);
}

try {
    Condition c = PluginUtils.parseWhereClause(whereClause);
} catch (AppsmithPluginException e) {
    if (e.getError() == AppsmithPluginError.PLUGIN_UQI_WHERE_CONDITION_UNKNOWN) {
        // fallback: drop the offending clause or default to EQ
        log.warn("Unknown operator in clause, skipping: {}", whereClause);
        return null;
    }
    throw e;
}

When it happens

Trigger: A plugin action (e.g. a UQI-based query like S3, Firestore, Google Sheets) submits a whereClause whose 'condition' key holds a string that is not a known ConditionalOperator - e.g. 'equals', 'is', 'containsExactly', an empty string, a typo like 'CONTAIN', or a localized/translated operator name. Also occurs when a frontend sends a numeric or null value, which fails the (String) cast before reaching the enum lookup.

Common situations: Hand-authored JSON filter payloads that use SQL-style operators (=, <>) instead of Appsmith operator names; copy/paste from documentation that uses a different operator vocabulary; upgrading Appsmith and relying on an operator that was renamed or removed; client-side dropdown that accidentally submits a label rather than its value.

Related errors

• PE-ARG-5000
• PE-ARG-5000
• PE-PLG-5000
• PE-DSE-5003
• PE-ARG-5000

AI-assisted analysis of appsmithorg/appsmith@8cd9021c24 (2026-08-12). Data as JSON: /api/errors/d4005aa94153dfb1. Report an issue: GitHub.