resolve the comments

Author: jialuoo

bigframes/core/compile/sqlglot/expressions/constants.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import math
+
 import sqlglot.expressions as sge
 
 _ZERO = sge.Cast(this=sge.convert(0), to="INT64")
@@ -23,3 +25,13 @@
 # FLOAT64 has 11 exponent bits, so max values is about 2**(2**10)
 # ln(2**(2**10)) == (2**10)*ln(2) ~= 709.78, so EXP(x) for x>709.78 will overflow.
 _FLOAT64_EXP_BOUND = sge.convert(709.78)
+
+# The natural logarithm of the maximum value for a signed 64-bit integer.
+# This is used to check for potential overflows in power operations involving integers
+# by checking if `exponent * log(base)` exceeds this value.
+_INT64_LOG_BOUND = math.log(2**63 - 1)
+
+# Represents the largest integer N where all integers from -N to N can be
+# represented exactly as a float64. Float64 types have a 53-bit significand precision,
+# so integers beyond this value may lose precision.
+_FLOAT64_MAX_INT_PRECISION = 2**53

bigframes/core/compile/sqlglot/expressions/numeric_ops.py

@@ -223,16 +223,13 @@ def _(left: TypedExpr, right: TypedExpr) -> sge.Expression:
 def _int_pow_op(
     left_expr: sge.Expression, right_expr: sge.Expression
 ) -> sge.Expression:
-    import math
-
-    overflow_value = math.log(2**63 - 1)
     overflow_cond = sge.and_(
         sge.NEQ(this=left_expr, expression=sge.convert(0)),
         sge.GT(
             this=sge.Mul(
                 this=right_expr, expression=sge.Ln(this=sge.Abs(this=left_expr))
             ),
-            expression=sge.convert(overflow_value),
+            expression=sge.convert(constants._INT64_LOG_BOUND),
         ),
     )
 
@@ -271,7 +268,10 @@ def _float_pow_op(
     )
 
     # Float64 lose integer precision beyond 2**53, beyond this insufficient precision to get parity
-    exp_too_big = sge.GT(this=sge.Abs(this=right_expr), expression=sge.convert(2**53))
+    exp_too_big = sge.GT(
+        this=sge.Abs(this=right_expr),
+        expression=sge.convert(constants._FLOAT64_MAX_INT_PRECISION),
+    )
     # Treat very large exponents as +=INF
     norm_exp = sge.Case(
         ifs=[