fix ^ evaluates as bitwise XOR instead of exponentiation (#22314)

## Which issue does this PR close?

- Closes #22252.

## Rationale for this change

In PostgreSQL, the `^` operator represents exponentiation, but
DataFusion was interpreting it as bitwise XOR. This caused
PostgreSQL-dialect queries such as `SELECT 2 ^ 3;` to return `1` instead
of `8`.

This change aligns DataFusion's PostgreSQL SQL semantics with PostgreSQL
for this operator while preserving existing non-PostgreSQL behavior.

## What changes are included in this PR?

- Added PostgreSQL-specific handling for `BinaryOperator::PGExp` during
SQL expression lowering.
- Lowered PostgreSQL `^` expressions to the built-in `power(left,
right)` scalar function instead of treating them as bitwise XOR.
- Kept existing generic-dialect `^` behavior unchanged.
- Kept PostgreSQL bitwise XOR behavior unchanged via `#`.
- Added a sqllogictest regression covering `SELECT 2 ^ 3;` under the
PostgreSQL parser dialect.

## Are these changes tested?

Yes.

Added a regression test in scalar.slt to verify that PostgreSQL-dialect
`^` is evaluated as exponentiation.

Validated with:

```bash
cargo test -p datafusion-sqllogictest --test sqllogictests scalar
```

## Are there any user-facing changes?

Yes.

For the PostgreSQL SQL parser dialect, `^` now behaves as exponentiation
instead of bitwise XOR, matching PostgreSQL semantics. Generic-dialect
behavior is unchanged, and PostgreSQL bitwise XOR remains available
through `#`.

Author: xiedeyantu

datafusion/sql/src/expr/binary_op.rs

@@ -16,8 +16,10 @@
 // under the License.
 
 use crate::planner::{ContextProvider, SqlToRel};
-use datafusion_common::{Result, not_impl_err};
+use datafusion_common::{Result, internal_datafusion_err, not_impl_err};
 use datafusion_expr::Operator;
+use datafusion_expr::expr::ScalarFunction;
+use datafusion_expr::{BinaryExpr, Expr};
 use sqlparser::ast::BinaryOperator;
 
 impl<S: ContextProvider> SqlToRel<'_, S> {
@@ -72,4 +74,34 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
             _ => not_impl_err!("Unsupported binary operator: {:?}", op),
         }
     }
+
+    pub(crate) fn build_binary_expr(
+        &self,
+        op: &BinaryOperator,
+        left: Expr,
+        right: Expr,
+    ) -> Result<Expr> {
+        if matches!(op, BinaryOperator::PGExp) {
+            let fun_name = "power";
+            let fun = self
+                .context_provider
+                .get_function_meta(fun_name)
+                .ok_or_else(|| {
+                    internal_datafusion_err!(
+                        "Unable to find expected '{fun_name}' function"
+                    )
+                })?;
+
+            return Ok(Expr::ScalarFunction(ScalarFunction::new_udf(
+                fun,
+                vec![left, right],
+            )));
+        }
+
+        Ok(Expr::BinaryExpr(BinaryExpr::new(
+            Box::new(left),
+            self.parse_sql_binary_op(op)?,
+            Box::new(right),
+        )))
+    }
 }

datafusion/sql/src/expr/mod.rs

@@ -142,11 +142,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
         }
 
         let RawBinaryExpr { op, left, right } = binary_expr;
-        Ok(Expr::BinaryExpr(BinaryExpr::new(
-            Box::new(left),
-            self.parse_sql_binary_op(&op)?,
-            Box::new(right),
-        )))
+        self.build_binary_expr(&op, left, right)
     }
 
     pub fn sql_to_expr_with_alias(

datafusion/sqllogictest/test_files/scalar.slt

@@ -1300,6 +1300,12 @@ NULL -32
 statement ok
 set datafusion.sql_parser.dialect = postgresql;
 
+# postgresql exponentiation uses caret
+query R
+select 2 ^ 3;
+----
+8
+
 # postgresql bitwise xor with column and scalar
 query I rowsort
 select c # 856 from signed_integers;