Simplify field matching in exclude source vectors - #156466

The fetch phase decides which vector fields to strip from _source by
compiling the field patterns of the request into an automaton. It did so
unconditionally, before establishing whether the mapping held any vector
embeddings at all, so an index with none paid for a matcher that had
nothing to match. Worse, a request asking for enough field patterns
exceeded Lucene's determinization work limit, and the resulting
TooComplexToDeterminizeException failed the search even on indices where
not a single field would have been excluded.

Resolve the vector fields first and return early when the mapping has
none, which skips the whole step for such indices.

Then match the remaining patterns one at a time with Regex#simpleMatch
rather than compiling them. Compiling amortizes its cost over the
strings tested against the result, and the only strings tested here are
the vector fields, of which a mapping holds a handful, while a request
can carry arbitrarily many patterns. The build therefore dominated and
was never repaid. Matching individually suits this shape better and,
because nothing is compiled, no work limit applies.

The inference field patterns come from the mapping rather than from the
request, so their number is bounded. They keep a compiled matcher, now
built through Regex#simpleMatcher so that the automaton is skipped when
it is not needed.

…56613)

* Simplify field matching in exclude source vectors (#156466)

The fetch phase decides which vector fields to strip from _source by
compiling the field patterns of the request into an automaton. It did so
unconditionally, before establishing whether the mapping held any vector
embeddings at all, so an index with none paid for a matcher that had
nothing to match. Worse, a request asking for enough field patterns
exceeded Lucene's determinization work limit, and the resulting
TooComplexToDeterminizeException failed the search even on indices where
not a single field would have been excluded.

Resolve the vector fields first and return early when the mapping has
none, which skips the whole step for such indices.

Then match the remaining patterns one at a time with Regex#simpleMatch
rather than compiling them. Compiling amortizes its cost over the
strings tested against the result, and the only strings tested here are
the vector fields, of which a mapping holds a handful, while a request
can carry arbitrarily many patterns. The build therefore dominated and
was never repaid. Matching individually suits this shape better and,
because nothing is compiled, no work limit applies.

The inference field patterns come from the mapping rather than from the
request, so their number is bounded. They keep a compiled matcher, now
built through Regex#simpleMatcher so that the automaton is skipped when
it is not needed.

(cherry picked from commit 8528446)

* Retrigger CI after gradle.org 503

The fetch phase decides which vector fields to strip from _source by
compiling the field patterns of the request into an automaton. It did so
unconditionally, before establishing whether the mapping held any vector
embeddings at all, so an index with none paid for a matcher that had
nothing to match. Worse, a request asking for enough field patterns
exceeded Lucene's determinization work limit, and the resulting
TooComplexToDeterminizeException failed the search even on indices where
not a single field would have been excluded.

Resolve the vector fields first and return early when the mapping has
none, which skips the whole step for such indices.

Then match the remaining patterns one at a time with Regex#simpleMatch
rather than compiling them. Compiling amortizes its cost over the
strings tested against the result, and the only strings tested here are
the vector fields, of which a mapping holds a handful, while a request
can carry arbitrarily many patterns. The build therefore dominated and
was never repaid. Matching individually suits this shape better and,
because nothing is compiled, no work limit applies.

The inference field patterns come from the mapping rather than from the
request, so their number is bounded. They keep a compiled matcher, now
built through Regex#simpleMatcher so that the automaton is skipped when
it is not needed.

The fetch phase decides which vector fields to strip from _source by
compiling the field patterns of the request into an automaton. It did so
unconditionally, before establishing whether the mapping held any vector
embeddings at all, so an index with none paid for a matcher that had
nothing to match. Worse, a request asking for enough field patterns
exceeded Lucene's determinization work limit, and the resulting
TooComplexToDeterminizeException failed the search even on indices where
not a single field would have been excluded.

Resolve the vector fields first and return early when the mapping has
none, which skips the whole step for such indices.

Then match the remaining patterns one at a time with Regex#simpleMatch
rather than compiling them. Compiling amortizes its cost over the
strings tested against the result, and the only strings tested here are
the vector fields, of which a mapping holds a handful, while a request
can carry arbitrarily many patterns. The build therefore dominated and
was never repaid. Matching individually suits this shape better and,
because nothing is compiled, no work limit applies.

The inference field patterns come from the mapping rather than from the
request, so their number is bounded. They keep a compiled matcher, now
built through Regex#simpleMatcher so that the automaton is skipped when
it is not needed.