diff --git a/source/libs/function/inc/tpercentile.h b/source/libs/function/inc/tpercentile.h
index 65b7b38a05..5351594b2f 100644
--- a/source/libs/function/inc/tpercentile.h
+++ b/source/libs/function/inc/tpercentile.h
@@ -26,12 +26,12 @@ extern "C" {
 typedef struct MinMaxEntry {
   union {
     double   dMinVal;
-    int64_t  i64MinVal;
+    //double   i64MinVal;
     uint64_t u64MinVal;
   };
   union {
     double  dMaxVal;
-    int64_t i64MaxVal;
+    //double  i64MaxVal;
     int64_t u64MaxVal;
   };
 } MinMaxEntry;
diff --git a/source/libs/function/src/tpercentile.c b/source/libs/function/src/tpercentile.c
index 93008b565a..c671e7717c 100644
--- a/source/libs/function/src/tpercentile.c
+++ b/source/libs/function/src/tpercentile.c
@@ -63,8 +63,8 @@ static SFilePage *loadDataFromFilePage(tMemBucket *pMemBucket, int32_t slotIdx)
 
 static void resetBoundingBox(MinMaxEntry *range, int32_t type) {
   if (IS_SIGNED_NUMERIC_TYPE(type)) {
-    range->i64MaxVal = INT64_MIN;
-    range->i64MinVal = INT64_MAX;
+    range->dMaxVal = INT64_MIN;
+    range->dMinVal = INT64_MAX;
   } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
     range->u64MaxVal = 0;
     range->u64MinVal = UINT64_MAX;
@@ -80,8 +80,8 @@ static int32_t setBoundingBox(MinMaxEntry *range, int16_t type, double minval, d
   }
 
   if (IS_SIGNED_NUMERIC_TYPE(type)) {
-    range->i64MinVal = (int64_t)minval;
-    range->i64MaxVal = (int64_t)maxval;
+    range->dMinVal = (int64_t)minval;
+    range->dMaxVal = (int64_t)maxval;
   } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
     range->u64MinVal = (uint64_t)minval;
     range->u64MaxVal = (uint64_t)maxval;
@@ -137,21 +137,21 @@ int32_t tBucketIntHash(tMemBucket *pBucket, const void *value) {
 
   int32_t index = -1;
 
-  if (v > pBucket->range.i64MaxVal || v < pBucket->range.i64MinVal) {
+  if (v > pBucket->range.dMaxVal || v < pBucket->range.dMinVal) {
     return index;
   }
 
   // divide the value range into 1024 buckets
-  uint64_t span = (uint64_t)(pBucket->range.i64MaxVal - pBucket->range.i64MinVal);
+  uint64_t span = pBucket->range.dMaxVal - pBucket->range.dMinVal;
   if (span < pBucket->numOfSlots) {
-    int64_t delta = v - pBucket->range.i64MinVal;
+    int64_t delta = v - pBucket->range.dMinVal;
     index = (delta % pBucket->numOfSlots);
   } else {
     double   slotSpan = ((double)span) / pBucket->numOfSlots;
-    uint64_t delta = (uint64_t)(v - pBucket->range.i64MinVal);
+    uint64_t delta = (uint64_t)(v - pBucket->range.dMinVal);
 
-    index = (int32_t)(delta / slotSpan);
-    if (v == pBucket->range.i64MaxVal || index == pBucket->numOfSlots) {
+    index = delta / slotSpan;
+    if (v == pBucket->range.dMaxVal || index == pBucket->numOfSlots) {
       index -= 1;
     }
   }
@@ -318,23 +318,23 @@ void tMemBucketUpdateBoundingBox(MinMaxEntry *r, const char *data, int32_t dataT
     int64_t v = 0;
     GET_TYPED_DATA(v, int64_t, dataType, data);
 
-    if (r->i64MinVal > v) {
-      r->i64MinVal = v;
+    if (r->dMinVal > v) {
+      r->dMinVal = v;
     }
 
-    if (r->i64MaxVal < v) {
-      r->i64MaxVal = v;
+    if (r->dMaxVal < v) {
+      r->dMaxVal = v;
     }
   } else if (IS_UNSIGNED_NUMERIC_TYPE(dataType)) {
     uint64_t v = 0;
     GET_TYPED_DATA(v, uint64_t, dataType, data);
 
-    if (r->i64MinVal > v) {
-      r->i64MinVal = v;
+    if (r->u64MinVal > v) {
+      r->u64MinVal = v;
     }
 
-    if (r->i64MaxVal < v) {
-      r->i64MaxVal = v;
+    if (r->u64MaxVal < v) {
+      r->u64MaxVal = v;
     }
   } else if (IS_FLOAT_TYPE(dataType)) {
     double v = 0;
@@ -438,7 +438,7 @@ static double getIdenticalDataVal(tMemBucket *pMemBucket, int32_t slotIndex) {
 
   double finalResult = 0.0;
   if (IS_SIGNED_NUMERIC_TYPE(pMemBucket->type)) {
-    finalResult = (double)pSlot->range.i64MinVal;
+    finalResult = (double)pSlot->range.dMinVal;
   } else if (IS_UNSIGNED_NUMERIC_TYPE(pMemBucket->type)) {
     finalResult = (double)pSlot->range.u64MinVal;
   } else {
@@ -469,8 +469,8 @@ int32_t getPercentileImpl(tMemBucket *pMemBucket, int32_t count, double fraction
         double maxOfThisSlot = 0;
         double minOfNextSlot = 0;
         if (IS_SIGNED_NUMERIC_TYPE(pMemBucket->type)) {
-          maxOfThisSlot = (double)pSlot->range.i64MaxVal;
-          minOfNextSlot = (double)next.i64MinVal;
+          maxOfThisSlot = (double)pSlot->range.dMaxVal;
+          minOfNextSlot = (double)next.dMinVal;
         } else if (IS_UNSIGNED_NUMERIC_TYPE(pMemBucket->type)) {
           maxOfThisSlot = (double)pSlot->range.u64MaxVal;
           minOfNextSlot = (double)next.u64MinVal;
@@ -577,7 +577,7 @@ int32_t getPercentile(tMemBucket *pMemBucket, double percent, double *result) {
     MinMaxEntry *pRange = &pMemBucket->range;
 
     if (IS_SIGNED_NUMERIC_TYPE(pMemBucket->type)) {
-      *result = (double)(fabs(percent - 100) < DBL_EPSILON ? pRange->i64MaxVal : pRange->i64MinVal);
+      *result = (double)(fabs(percent - 100) < DBL_EPSILON ? pRange->dMaxVal : pRange->dMinVal);
     } else if (IS_UNSIGNED_NUMERIC_TYPE(pMemBucket->type)) {
       *result = (double)(fabs(percent - 100) < DBL_EPSILON ? pRange->u64MaxVal : pRange->u64MinVal);
     } else {
@@ -603,6 +603,6 @@ bool isIdenticalData(tMemBucket *pMemBucket, int32_t index) {
   if (IS_FLOAT_TYPE(pMemBucket->type)) {
     return fabs(pSeg->range.dMaxVal - pSeg->range.dMinVal) < DBL_EPSILON;
   } else {
-    return pSeg->range.i64MinVal == pSeg->range.i64MaxVal;
+    return pSeg->range.dMinVal == pSeg->range.dMaxVal;
   }
 }