GH-48761: [C++] Fix duplicate Substrait function URI registration

[mohit7705]

What does this PR do?

This PR fixes an issue where Substrait scalar expressions could cause
duplicate registration of the same function URI during serialization.

The function reference was being encoded multiple times while building
nested expressions (e.g. large OR chains), leading to exponential growth
in extension URIs and serialized plan size.

What was changed?

• Ensure EncodeFunction(call.id()) is invoked exactly once per
  ScalarFunction encoding.
• Avoid repeated URI registration while serializing nested expressions.

Why is this needed?

Without this fix, expressions with many nested logical operators
(e.g. OR conditions) cause the Substrait plan size to grow exponentially,
which can severely impact memory usage and performance.

Testing

• Reproduced using a Python script that serializes expressions with
  increasing OR conditions.
• Verified that serialization still succeeds and the fix does not
  introduce regressions.

Related issue

Fixes #48761

• GitHub Issue: [C++] Substrait serialised expression size increases exponentially due to extension URIs being repeated #48761

[github-actions]

Thanks for opening a pull request!

If this is not a minor PR. Could you open an issue for this pull request on GitHub? https://github.com/apache/arrow/issues/new/choose

Opening GitHub issues ahead of time contributes to the Openness of the Apache Arrow project.

Then could you also rename the pull request title in the following format?

GH-${GITHUB_ISSUE_ID}: [${COMPONENT}] ${SUMMARY}

or

MINOR: [${COMPONENT}] ${SUMMARY}

See also:

• Other pull requests
• Contribution Guidelines - Contributing Overview

[HyukjinKwon]

Just my two cents:

Reproduced using a Python script that serializes expressions with
increasing OR conditions.
Verified that serialization still succeeds and the fix does not
introduce regressions.

I think we should probably add a test to prevent the regression. If it's difficult to add one, would be best to describe why and how you tested 👍

[ahsanabbas123]

Can you please explain how does constructing the scalar function before encoding the call help avoid the repeated URIs as the rest of the changes seem to be just formatting?

[mohit7705]

Thanks for the review and for pointing this out. @ahsanabbas123 , @HyukjinKwon

I want to clarify that the earlier discussion can be ignored — I’ve updated the implementation since then.

What changed:
The fix now ensures that EncodeFunction(call.id()) is invoked exactly once per ScalarFunction, by constructing the ScalarFunction object before recursively encoding arguments. This prevents repeated registration of the same function URI when serializing nested expressions (e.g. large OR chains), which was the root cause of the exponential growth.

Why this fixes the issue:
Previously, function encoding could occur during recursive argument serialization, causing duplicate URI registrations. With this change, the function reference is encoded once per scalar function, regardless of nesting depth.

Testing:
I reproduced the original issue using a Python script that serializes expressions with increasing OR conditions and verified that:

serialization still succeeds

the number of registered extension URIs no longer grows exponentially

no regressions were observed

Please let me know if you’d like me to add a regression test for this, or if the explanation can be improved.

[HyukjinKwon]

Feel free to update the PR description. I would want to follow how you tested and verify the PR 🙂

[mohit7705]

I verified this change by building Arrow C++ from source after the fix (make -j$(nproc)) and confirmed the Substrait code compiles successfully.