Refactor StaticSelector.match to avoid throwing exceptions

Summary:
The `addVariableValues` method in `StaticSelector` previously iterated over all `variableNames` and caught `IllegalArgumentException` for each name not present as a named group in the pattern. This is inefficient and relies on exception handling for control flow.

This change pre-computes the named groups for each regex pattern at construction time into an `ImmutableMap<Pattern, ImmutableSet<String>>`. The `addVariableValues` method now looks up the pre-computed groups for the given pattern and only iterates over matching group names, avoiding the need to catch exceptions entirely.

Differential Revision: D93437091

Author: ceekay47

presto-resource-group-managers/src/main/java/com/facebook/presto/resourceGroups/StaticSelector.java

@@ -18,6 +18,7 @@
 import com.facebook.presto.spi.resourceGroups.SelectionCriteria;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 
@@ -55,6 +56,7 @@ public class StaticSelector
     private final Optional<Pattern> principalRegex;
     private final ResourceGroupIdTemplate group;
     private final Set<String> variableNames;
+    private final ImmutableMap<Pattern, ImmutableSet<String>> patternNamedGroups;
 
     public StaticSelector(
             Optional<Pattern> userRegex,
@@ -83,6 +85,12 @@ public StaticSelector(
         sourceRegex.ifPresent(s -> addNamedGroups(s, variableNames));
         this.variableNames = ImmutableSet.copyOf(variableNames);
 
+        ImmutableMap.Builder<Pattern, ImmutableSet<String>> patternGroupsBuilder = ImmutableMap.builder();
+        userRegex.ifPresent(u -> patternGroupsBuilder.put(u, extractNamedGroups(u)));
+        sourceRegex.ifPresent(s -> patternGroupsBuilder.put(s, extractNamedGroups(s)));
+        principalRegex.ifPresent(p -> patternGroupsBuilder.put(p, extractNamedGroups(p)));
+        this.patternNamedGroups = patternGroupsBuilder.build();
+
         Set<String> unresolvedVariables = Sets.difference(group.getVariableNames(), variableNames);
         checkArgument(unresolvedVariables.isEmpty(), "unresolved variables %s in resource group ID '%s', available: %s\"", unresolvedVariables, group, variableNames);
     }
@@ -167,19 +175,28 @@ private static void addNamedGroups(Pattern pattern, HashSet<String> variables)
         }
     }
 
+    private static ImmutableSet<String> extractNamedGroups(Pattern pattern)
+    {
+        ImmutableSet.Builder<String> groups = ImmutableSet.builder();
+        Matcher matcher = NAMED_GROUPS_PATTERN.matcher(pattern.pattern());
+        while (matcher.find()) {
+            groups.add(matcher.group(1));
+        }
+        return groups.build();
+    }
+
     private void addVariableValues(Pattern pattern, String candidate, Map<String, String> mapping)
     {
-        for (String key : variableNames) {
-            Matcher keyMatcher = pattern.matcher(candidate);
-            if (keyMatcher.find()) {
-                try {
-                    String value = keyMatcher.group(key);
-                    if (value != null) {
-                        mapping.put(key, value);
-                    }
-                }
-                catch (IllegalArgumentException ignored) {
-                    // there was no capturing group with the specified name
+        Set<String> groups = patternNamedGroups.getOrDefault(pattern, ImmutableSet.of());
+        if (groups.isEmpty()) {
+            return;
+        }
+        Matcher keyMatcher = pattern.matcher(candidate);
+        if (keyMatcher.find()) {
+            for (String key : groups) {
+                String value = keyMatcher.group(key);
+                if (value != null) {
+                    mapping.put(key, value);
                 }
             }
         }