Avoid expensive operations in frequently executed code paths by implementing performance optimizations such as lookup tables, result caching, conditional initialization, and object reuse. Key optimization strategies: 1. **Replace expensive algorithms with faster alternatives**: Use lookup tables instead of linear searches like `std::find_first_of` when checking for special characters in strings. 2. **Cache redundant computations**: Avoid performing the same expensive checks multiple times by caching results in appropriate data structures like `unsafe_unique_array`. 3. **Minimize initialization overhead**: Only perform expensive initialization when necessary (e.g., after state changes) rather than on every iteration or function call. 4. **Reuse expensive objects**: Make costly-to-create objects like compiled regex patterns static to avoid recreation overhead. Example of lookup table optimization: ```cpp // Instead of: std::find_first_of(string_data, string_end, special_chars, special_chars + special_chars_length) // Use a lookup table for O(1) character checking: static bool special_char_lookup[256] = {false}; // Initialize once // Check: if (special_char_lookup[static_cast(ch)]) ``` Example of conditional initialization: ```cpp // Instead of initializing on every chunk: static void MultiFileScan(...) { InitializeFileScanState(context, data, gstate.projection_ids); // Every call } // Initialize only when needed: static void MultiFileScan(...) { if (file_changed || !initialized) { InitializeFileScanState(context, data, gstate.projection_ids); } } ``` These optimizations can provide significant performance improvements, with reported speedups of 2x or more in critical code paths.