apache/flink · error · IllegalArgumentException

The positions must be strictly increasing (no permutations…

Error message

The positions must be strictly increasing (no permutations are supported).

What it means

Thrown by checkForMonotonousOrder when positions are not strictly increasing (a position is <= the previous one). This method exists specifically to reject permutations and non-sorted orderings, because some calling code assumes the positions array is already sorted ascending. Contrast with checkAndCoSort which sorts for you.

Solutions

1. Sort the positions array ascending (and co-sort the types array to match) before calling checkForMonotonousOrder.
2. If you want Flink to sort for you, call checkAndCoSort instead.
3. Remove duplicate positions; this check rejects equal consecutive values too.

Example fix

// before
checkForMonotonousOrder(new int[]{0,2,1}, types);
// after
checkForMonotonousOrder(new int[]{0,1,2}, types); // or use checkAndCoSort to sort

for (int i = 1; i < positions.length; i++) {
    if (positions[i] <= positions[i - 1]) {
        throw new IllegalArgumentException(
            "Positions not strictly increasing at " + i + ": " + Arrays.toString(positions));
    }
}
checkForMonotonousOrder(positions, types);

// Sort ascending in one place so the invariant holds
int[] order = IntStream.range(0, positions.length)
    .boxed().sorted(Comparator.comparingInt(i -> positions[i])).mapToInt(Integer::intValue).toArray();
int[] sp = IntStream.of(order).map(i -> positions[i]).toArray();
Class<?>[] st = IntStream.of(order).mapToObj(i -> types[i]).toArray(Class<?>[]::new);

try {
    checkForMonotonousOrder(positions, types);
} catch (IllegalArgumentException e) {
    if (e.getMessage().contains("strictly increasing")) {
        // fall back to the sorting helper
        checkAndCoSort(positions, types);
    } else throw e;
}

When it happens

Trigger: A subclass calls checkForMonotonousOrder with positions like {0,2,1} or {1,1,2} (equal or decreasing). This indicates the caller meant to use checkAndCoSort (which sorts) or passed unsorted indices to code that requires sorted input.

Common situations: User-built index arrays that are not pre-sorted; confusion between the two helpers (sort-vs-validate); refactor that reordered one array but not the parallel one.

Related errors

• The field
• The field ( ) is invalid.
• The position occurs multiple times.
• The positions and types must be of the same length
• The type is invalid (null)

AI-assisted analysis of apache/flink@2f3c205e92 (2026-08-14). Data as JSON: /api/errors/1357c927c8ffb3ad. Report an issue: GitHub.

Appendix: source

Thrown at flink-core/src/main/java/org/apache/flink/api/common/io/GenericCsvInputFormat.java:579

    protected static void checkForMonotonousOrder(int[] positions, Class<?>[] types) {
        if (positions.length != types.length) {
            throw new IllegalArgumentException(
                    "The positions and types must be of the same length");
        }

        int lastPos = -1;

        for (int i = 0; i < positions.length; i++) {
            if (positions[i] < 0) {
                throw new IllegalArgumentException(
                        "The field " + " (" + positions[i] + ") is invalid.");
            }
            if (types[i] == null) {
                throw new IllegalArgumentException("The type " + i + " is invalid (null)");
            }

            if (positions[i] <= lastPos) {
                throw new IllegalArgumentException(
                        "The positions must be strictly increasing (no permutations are supported).");
            }

            lastPos = positions[i];
        }
    }

    private static int max(int[] ints) {
        checkArgument(ints.length > 0);

        int max = ints[0];
        for (int i = 1; i < ints.length; i++) {
            max = Math.max(max, ints[i]);
        }
        return max;
    }
}

View on GitHub (pinned to 2f3c205e92)