fix: Normalize timestamp literals to nanoseconds in filter pushdown

Ensure all timestamp literals are converted to nanoseconds before generating
KQL and SQL filters for pushdown, regardless of their original precision
(milliseconds, microseconds, etc.).

Problem:
Presto supports multiple timestamp precisions (TIMESTAMP with millisecond
precision, TIMESTAMP_MICROSECONDS, etc.), but CLP's query engine expects
timestamps in a consistent nanosecond format. Previously, timestamp literals
were passed through without precision normalization, causing incorrect
results when different timestamp types were used in queries.

Solution:
Add timestamp normalization logic in ClpFilterToKqlConverter:
- tryEnsureNanosecondTimestamp(): Detects TIMESTAMP and TIMESTAMP_MICROSECONDS types
- ensureNanosecondTimestamp(): Converts timestamp values to nanoseconds using:
  1. Extract epoch seconds via TimestampType.getEpochSecond()
  2. Extract nanosecond fraction via TimestampType.getNanos()
  3. Convert to total nanoseconds: SECONDS.toNanos(seconds) + nanosFraction

Applied to:
- BETWEEN operator: Both lower and upper bounds
- Comparison operators: All timestamp literal values (=, !=, <, >, <=, >=)

This ensures consistent timestamp representation in both KQL filters (sent to
CLP engine) and SQL filters (used for metadata filtering), regardless of the
timestamp precision used in the original Presto query.

Example:
Query: WHERE timestamp BETWEEN TIMESTAMP '2025-01-01' AND TIMESTAMP '2025-01-02'
Before: Literal values passed as milliseconds or microseconds
After: Both bounds normalized to nanosecond representation

Author: jackluo923

presto-clp/src/main/java/com/facebook/presto/plugin/clp/optimization/ClpFilterToKqlConverter.java

@@ -16,6 +16,7 @@
 import com.facebook.presto.common.function.OperatorType;
 import com.facebook.presto.common.type.DecimalType;
 import com.facebook.presto.common.type.RowType;
+import com.facebook.presto.common.type.TimestampType;
 import com.facebook.presto.common.type.Type;
 import com.facebook.presto.common.type.VarcharType;
 import com.facebook.presto.plugin.clp.ClpColumnHandle;
@@ -64,6 +65,7 @@
 import static java.lang.Integer.parseInt;
 import static java.lang.String.format;
 import static java.util.Objects.requireNonNull;
+import static java.util.concurrent.TimeUnit.SECONDS;
 
 /**
  * A translator to translate Presto {@link RowExpression}s into:
@@ -259,8 +261,10 @@ private ClpExpression handleBetween(CallExpression node)
         }
 
         String variable = variableOpt.get();
-        String lowerBound = getLiteralString((ConstantExpression) second);
-        String upperBound = getLiteralString((ConstantExpression) third);
+        Type lowerBoundType = second.getType();
+        String lowerBound = tryEnsureNanosecondTimestamp(lowerBoundType, getLiteralString((ConstantExpression) second));
+        Type upperBoundType = third.getType();
+        String upperBound = tryEnsureNanosecondTimestamp(upperBoundType, getLiteralString((ConstantExpression) third));
         String kql = String.format("%s >= %s AND %s <= %s", variable, lowerBound, variable, upperBound);
         String metadataSqlQuery = metadataFilterColumns.contains(variable)
                 ? String.format("\"%s\" >= %s AND \"%s\" <= %s", variable, lowerBound, variable, upperBound)
@@ -443,6 +447,7 @@ private ClpExpression buildClpExpression(
             RowExpression originalNode)
     {
         String metadataSqlQuery = null;
+        literalString = tryEnsureNanosecondTimestamp(literalType, literalString);
         if (operator.equals(EQUAL)) {
             if (literalType instanceof VarcharType) {
                 return new ClpExpression(
@@ -939,6 +944,26 @@ public static boolean isClpCompatibleNumericType(Type type)
                 || type instanceof DecimalType;
     }
 
+    private static String tryEnsureNanosecondTimestamp(Type type, String literalString)
+    {
+        if (type == TIMESTAMP) {
+            return ensureNanosecondTimestamp(TIMESTAMP, literalString);
+        }
+        else if (type == TIMESTAMP_MICROSECONDS) {
+            return ensureNanosecondTimestamp(TIMESTAMP_MICROSECONDS, literalString);
+        }
+        return literalString;
+    }
+
+    private static String ensureNanosecondTimestamp(TimestampType type, String literalString)
+    {
+        long literalNumber = Long.parseLong(literalString);
+        long seconds = type.getEpochSecond(literalNumber);
+        long nanosecondFraction = type.getNanos(literalNumber);
+        long nanoseconds = SECONDS.toNanos(seconds) + nanosecondFraction;
+        return Long.toString(nanoseconds);
+    }
+
     private static class SubstrInfo
     {
         String variableName;