fix: disable timestamp column for data skipping (delta-io#1003)

## What changes are proposed in this pull request?
delta-kernel-rs assumes stats to be accurate as microseconds (like the
timestamp type they are represented), but delta spec states that
`add.stats` min/max values truncate strings/timestamps to milliseconds:
> String columns are cut off at a fixed prefix length. Timestamp columns
are truncated down to milliseconds

While that's okay for min-stats, it's incorrect for max-stats: the
file's _actual_ max-value is anywhere from 0-999µs larger than the
recorded stats max-value.

In the short-term we disable timestamp-based file skipping, and long
term will explore a solution like adding 999us to our max stat (in
follow-up issue).

## How was this change tested?
New UT

follow-up in delta-io#1002

Author: zachschuermann

kernel/src/scan/data_skipping.rs

@@ -202,8 +202,13 @@ impl DataSkippingPredicateEvaluator for DataSkippingPredicateCreator {
     }
 
     /// Retrieves the maximum value of a column, if it exists and has the requested type.
-    fn get_max_stat(&self, col: &ColumnName, _data_type: &DataType) -> Option<Expr> {
-        Some(joined_column_expr!("maxValues", col))
+    // TODO(#1002): we currently don't support file skipping on timestamp columns' max stat since
+    // they are truncated to milliseconds in add.stats.
+    fn get_max_stat(&self, col: &ColumnName, data_type: &DataType) -> Option<Expr> {
+        match data_type {
+            &DataType::TIMESTAMP | &DataType::TIMESTAMP_NTZ => None,
+            _ => Some(joined_column_expr!("maxValues", col)),
+        }
     }
 
     /// Retrieves the null count of a column, if it exists.

kernel/src/scan/data_skipping/tests.rs

@@ -339,3 +339,70 @@ fn test_sql_where() {
     do_test(ALL_NULL, pred, PRESENT, None, Some(false));
     do_test(ALL_NULL, pred, MISSING, None, None);
 }
+
+// TODO(#1002): we currently don't support file skipping on timestamp columns' max stat since they
+// are truncated to milliseconds in add.stats.
+#[test]
+fn test_timestamp_skipping_disabled() {
+    let creator = DataSkippingPredicateCreator;
+    let col = &column_name!("timestamp_col");
+
+    assert!(
+        creator.get_min_stat(col, &DataType::TIMESTAMP).is_some(),
+        "get_min_stat should return Some: allow data skipping on timestamp minValues"
+    );
+    assert_eq!(
+        creator.get_max_stat(col, &DataType::TIMESTAMP),
+        None,
+        "get_max_stat should return None: no data skipping on timestamp maxValues"
+    );
+    assert!(
+        creator
+            .get_min_stat(col, &DataType::TIMESTAMP_NTZ)
+            .is_some(),
+        "get_min_stat should return Some: allow data skipping on timestamp_ntz minValues"
+    );
+    assert_eq!(
+        creator.get_max_stat(col, &DataType::TIMESTAMP_NTZ),
+        None,
+        "get_max_stat should return None: no data skipping on timestamp_ntz maxValues"
+    );
+}
+
+// TODO(#1002): we currently don't support file skipping on timestamp columns' max stat since they
+// are truncated to milliseconds in add.stats.
+#[test]
+fn test_timestamp_predicates_dont_data_skip() {
+    let col = &column_expr!("ts_col");
+    for timestamp in [&Scalar::Timestamp(1000000), &Scalar::TimestampNtz(1000000)] {
+        // LT will do minValues -> OK
+        let pred = Pred::lt(col.clone(), timestamp.clone());
+        let skipping_pred = as_data_skipping_predicate(&pred);
+        assert_eq!(
+            skipping_pred.unwrap().to_string(),
+            "Column(minValues.ts_col) < 1000000"
+        );
+
+        // GT will do maxValues -> BLOCKED
+        let pred = Pred::gt(col.clone(), timestamp.clone());
+        let skipping_pred = as_data_skipping_predicate(&pred);
+        assert!(
+            skipping_pred.is_none(),
+            "Expected no data skipping for timestamp predicate: {pred:#?}, got {skipping_pred:#?}"
+        );
+
+        let pred = Pred::eq(col.clone(), timestamp.clone());
+        let skipping_pred = as_data_skipping_predicate(&pred);
+        assert_eq!(
+            skipping_pred.unwrap().to_string(),
+            "AND(NOT(Column(minValues.ts_col) > 1000000), null)"
+        );
+
+        let pred = Pred::ne(col.clone(), timestamp.clone());
+        let skipping_pred = as_data_skipping_predicate(&pred);
+        assert_eq!(
+            skipping_pred.unwrap().to_string(),
+            "OR(NOT(Column(minValues.ts_col) = 1000000), null)"
+        );
+    }
+}