{"record":{"id":"6797b75f686fbcbd","repo":"apache/beam","slug":"iterator-at-position-i-was-null","errorCode":null,"errorMessage":"Iterator at position \" + i + \" was null.","messagePattern":"Iterator at position \" \\+ i \\+ \" was null\\.","errorType":"exception","errorClass":"IllegalArgumentException","httpStatus":null,"severity":"error","filePath":"sdks/java/core/src/main/java/org/apache/beam/sdk/fn/stream/PrefetchableIterators.java","lineNumber":199,"sourceCode":"    };\n  }\n\n  /**\n   * Concatentates the {@link Iterator}s.\n   *\n   * <p>{@link Iterable}s are first converted into a {@link PrefetchableIterable} via {@link\n   * #maybePrefetchable}.\n   *\n   * <p>The returned {@link PrefetchableIterable} ensures that iterators which are returned\n   * guarantee that {@link PrefetchableIterator#isReady} always advances till it finds an {@link\n   * Iterable} that is not {@link PrefetchableIterator#isReady}. {@link\n   * PrefetchableIterator#prefetch} is also guaranteed to advance past empty iterators till it finds\n   * one that is not ready.\n   */\n  public static <T> PrefetchableIterator<T> concat(Iterator<T>... iterators) {\n    for (int i = 0; i < iterators.length; ++i) {\n      if (iterators[i] == null) {\n        throw new IllegalArgumentException(\"Iterator at position \" + i + \" was null.\");\n      }\n    }\n    if (iterators.length == 0) {\n      return emptyIterator();\n    } else if (iterators.length == 1) {\n      return maybePrefetchable(iterators[0]);\n    }\n    return concatIterators(Arrays.asList(iterators).iterator());\n  }\n}\n","sourceCodeStart":181,"sourceCodeEnd":210,"githubUrl":"https://github.com/apache/beam/blob/12126d8942aaf848030c478b4c6a28c6af861c66/sdks/java/core/src/main/java/org/apache/beam/sdk/fn/stream/PrefetchableIterators.java#L181-L210","documentation":"PrefetchableIterators.concat validates every varargs iterator is non-null before chaining them. A null element would fail during iteration with an NPE, so concat fails immediately with this IllegalArgumentException stating the position of the null iterator.","triggerScenarios":"Calling PrefetchableIterators.concat(iteratorA, null) or passing an iterator array containing null elements.","commonSituations":"Collecting iterators from conditional branches where a branch produced null; building a collection of iterators from optional lookups that returned null.","solutions":["Filter out null iterators before calling concat","Replace null iterators with Collections.emptyIterator()","Fix the source producing the null iterator to return an empty iterator instead","Null-check each iterator before composing"],"exampleFix":"// before\nIterator<T> it = PrefetchableIterators.concat(it1, null, it2);\n// after\nIterator<T> it = PrefetchableIterators.concat(\n    it1,\n    maybeNull != null ? maybeNull : java.util.Collections.<T>emptyIterator(),\n    it2);","handlingStrategy":"type-guard","validationCode":"for (int i = 0; i < iterators.length; i++) {\n  java.util.Objects.requireNonNull(iterators[i], \"iterator at \" + i);\n}","typeGuard":"static <T> Iterator<T> orEmpty(Iterator<T> it) {\n  return it != null ? it : java.util.Collections.<T>emptyIterator();\n}","tryCatchPattern":"try {\n  return PrefetchableIterators.concat(iterators);\n} catch (IllegalArgumentException e) {\n  return PrefetchableIterators.emptyIterator();\n}","preventionTips":["Return Collections.emptyIterator() instead of null from iterator factories","Null-check iterators assembled from conditional branches","Avoid arrays built with null slots when aggregating iterators"],"tags":["java","null","argument-validation","iterators"],"backgroundTag":"null-argument","analyzedSha":"12126d8942aaf848030c478b4c6a28c6af861c66","analyzedAt":"2026-09-13T01:50:10.254Z","contentChangedAt":"2026-09-13T01:50:10.254Z","schemaVersion":2},"datasetVersion":"2026-09-14T16:17:12.679Z"}