fix(query): relax decimal domain assertion to scale and precision

`statistics_to_domain` asserted that the persisted decimal scalar variant
matches the `data_kind()` derived from the current schema size. That is not
an invariant: statistics built from an external Parquet column or page index
carry the variant implied by the Parquet physical type, so a `Decimal128`
scalar can legitimately describe a precision-9 (`Decimal64`-kind) size.

The assertion broke `parquet_rs::prune_pages::test_basic`,
`prune_pages::test_decimal_in_list` and
`prune_row_groups::test_various_rg_scenarios`.

Keep only the invariants that hold - equal scale and a persisted precision no
wider than the current schema precision - and let the domain keep following
the scalar variant, as it did before precision widening became metadata-only.

Author: youngsofun

src/query/storages/common/index/src/range_index.rs

@@ -325,12 +325,19 @@ pub fn statistics_to_domain(mut stats: Vec<&ColumnStatistics>, data_type: &DataT
                     // A metadata-only decimal precision widening leaves persisted block and
                     // segment statistics tagged with the previous precision. The scale and raw
                     // value are unchanged, so build the domain with the current schema size.
+                    //
+                    // Only the scale and the precision direction are checked here. The scalar
+                    // variant is deliberately not compared against `size.data_kind()`: statistics
+                    // built from an external Parquet column/page index carry the variant implied
+                    // by the Parquet physical type, so a `Decimal128` scalar can legitimately
+                    // describe a `Decimal64`-kind size. The domain therefore keeps following the
+                    // scalar variant, as it did before precision widening became metadata-only.
                     let min_decimal = min.as_decimal().unwrap();
                     let max_decimal = max.as_decimal().unwrap();
                     debug_assert_eq!(min_decimal.scale(), size.scale());
                     debug_assert_eq!(max_decimal.scale(), size.scale());
-                    debug_assert_eq!(min_decimal.data_kind(), size.data_kind());
-                    debug_assert_eq!(max_decimal.data_kind(), size.data_kind());
+                    debug_assert!(min_decimal.size().precision() <= size.precision());
+                    debug_assert!(max_decimal.size().precision() <= size.precision());
                     let domain = match min_decimal {
                         DecimalScalar::Decimal64(_, _) => {
                             let domain = SimpleDomain {

src/query/storages/common/index/tests/it/range_pruner.rs

@@ -146,6 +146,31 @@ fn test_decimal_statistics_use_current_schema_size() {
     }
 }
 
+// Statistics built from an external Parquet column/page index carry the scalar variant
+// implied by the Parquet physical type, which may be wider than the variant that the
+// schema size alone would imply (e.g. `Decimal128` for a precision-9 size).
+#[test]
+fn test_decimal_statistics_allow_wider_scalar_variant_than_schema_size() {
+    let size = DecimalSize::new(9, 2).unwrap();
+    let statistics = ColumnStatistics {
+        min: Scalar::Decimal(DecimalScalar::Decimal128(100, size)),
+        max: Scalar::Decimal(DecimalScalar::Decimal128(600, size)),
+        null_count: 0,
+        in_memory_size: 0,
+        distinct_of_values: None,
+    };
+
+    let domain = statistics_to_domain(vec![&statistics], &DataType::Decimal(size));
+    match domain {
+        Domain::Decimal(DecimalDomain::Decimal128(domain, domain_size)) => {
+            assert_eq!(domain.min, 100);
+            assert_eq!(domain.max, 600);
+            assert_eq!(domain_size, size);
+        }
+        domain => panic!("unexpected domain: {domain:?}"),
+    }
+}
+
 #[test]
 fn test_range_index_prunes_nullable_integer_column_eq_numeric_string_literal() {
     fn n(n: i32) -> Scalar {