fix(optimizer): Handle CAST wrapping an RPC function call

Summary:
The AIFunctionRewriteOptimizer rewrites meta.ai.embedding to CAST(fb_text_embedding(...) AS ARRAY<DOUBLE>) because fb_text_embedding returns ARRAY<REAL> but meta.ai.embedding is defined to return ARRAY<DOUBLE>.

When the RpcFunctionOptimizer processes this plan, it creates an RPC node for fb_text_embedding, but the CAST of __rpc_result remains in the Project node. The VerifyProjectionLocality sanity check then fails because it expects any CallExpression in a REMOTE projection (like CAST) to be an external function (Python UDF), but the CAST from the AI rewrite is just a plain type conversion, not an external function.

This causes queries with meta.ai.embedding and meta_ai_function_use_rpc_backend=true to fail with:
  Expect expression CAST(__rpc_result) to be an external function

Fix: In RpcFunctionOptimizer.createRpcRewriter().rewriteCall(), handle the case where a CAST wraps an RPC function call. When the node is a CAST and its argument is an RPC function (e.g., fb_text_embedding), extract the inner RPC call and use the CAST target type (e.g., ARRAY<DOUBLE>) for the result variable instead of the inner call's type (e.g., ARRAY<REAL>). This eliminates the CAST from the plan, so the RPC node directly outputs the correct type, and VerifyProjectionLocality no longer sees a problematic CAST.

The fix follows the same pattern as the existing TRY handling in the same method - it intercepts the CAST before the general RPC function check, processes the inner call, and returns the result variable directly.

Fixes the issue where meta.ai.embedding was not usable with the RPC backend, forcing users to either use fb_text_embedding directly or disable the RPC backend and use the slower Python UDF path. Now meta.ai.embedding works with the RPC backend, enabling 20-50x speedup for embedding workloads.

== RELEASE NOTES ==

General Changes
* Fix a query failure that occurred when the result of a remote function (RPC) call was wrapped in a ``CAST`` expression. :pr:`28179`

Reviewed By: sebastianopeluso

Differential Revision: D112621072

Author: zhichenxu-meta

presto-main-base/src/main/java/com/facebook/presto/sql/planner/optimizations/RpcFunctionOptimizer.java

@@ -279,6 +279,34 @@ && isLambdaOrBindWithLambda(node.getArguments().get(0))) {
                         }
                     }
 
+                    // Handle CAST of RPC function, e.g., CAST(fb_text_embedding(...) AS ARRAY<DOUBLE>)
+                    // This happens when AIFunctionRewriteOptimizer wraps fb_text_embedding (which returns
+                    // ARRAY<REAL>) in a CAST to ARRAY<DOUBLE> to match meta.ai.embedding's return type.
+                    // We extract the inner RPC call and use the CAST target type for the result variable,
+                    // eliminating the CAST from the plan. This avoids the VerifyProjectionLocality check
+                    // which expects CASTs of RPC results to be external functions.
+                    if (node.getDisplayName().equalsIgnoreCase("CAST") && !node.getArguments().isEmpty()) {
+                        RowExpression arg = node.getArguments().get(0);
+                        if (arg instanceof CallExpression) {
+                            CallExpression innerCall = (CallExpression) arg;
+                            if (rpcFunctionNames.contains(
+                                    innerCall.getDisplayName().toLowerCase(Locale.ENGLISH))) {
+                                // Rewrite children of the inner call first
+                                CallExpression rewritten = (CallExpression) treeRewriter.defaultRewrite(innerCall, context);
+
+                                // Use the CAST target type (node.getType()) for the result variable,
+                                // not the inner call's type. This eliminates the need for the CAST.
+                                VariableReferenceExpression resultVar = variableAllocator.newVariable(
+                                        "__rpc_result_",
+                                        node.getType());
+
+                                context.addCall(innerCall, rewritten, resultVar);
+
+                                return resultVar;
+                            }
+                        }
+                    }
+
                     if (!rpcFunctionNames.contains(
                             node.getDisplayName().toLowerCase(Locale.ENGLISH))) {
                         return null;