Phoenix500526 commented on code in PR #23201:
URL: https://github.com/apache/datafusion/pull/23201#discussion_r3492314342
##########
datafusion/execution/src/cache/mod.rs:
##########
@@ -165,3 +168,145 @@ impl Display for TableScopedPath {
}
}
}
+
+/// A fingerprint of the `file_schema` used to compute a file's statistics.
+///
+/// Captures exactly the attributes that determine the layout and meaning of
+/// `Statistics::column_statistics`: each column's name, data type and
+/// nullability, in order. It deliberately excludes field/schema metadata,
which
+/// cannot affect statistics — including it would needlessly fragment the
cache.
+#[derive(Clone, Debug)]
+pub struct SchemaFingerprint {
+ columns: Vec<(String, DataType, bool)>,
+ /// Precomputed hash of `columns`, so hashing a key on every cache lookup
is
+ /// O(1) rather than O(schema width). Computed once in `from_schema` with a
+ /// fixed-seed hasher so it is stable across keys; `PartialEq` still
compares
+ /// `columns` exactly, so a hash collision can never make two different
+ /// schemas share a cache entry.
+ hash: u64,
+}
+
+impl SchemaFingerprint {
+ /// Builds a fingerprint from the `file_schema` used to compute statistics
+ /// (the schema of the columns physically read, not the full table schema —
+ /// partition columns and their statistics are handled separately).
+ pub fn from_schema(file_schema: &Schema) -> Self {
+ let columns: Vec<(String, DataType, bool)> = file_schema
+ .fields()
+ .iter()
+ .map(|f| (f.name().clone(), f.data_type().clone(),
f.is_nullable()))
+ .collect();
+ let mut hasher = DefaultHasher::new();
+ columns.hash(&mut hasher);
+ Self {
+ columns,
+ hash: hasher.finish(),
+ }
+ }
+}
+
+impl PartialEq for SchemaFingerprint {
+ fn eq(&self, other: &Self) -> bool {
+ // Cheap hash gate first, then an exact comparison so collisions are
safe.
+ self.hash == other.hash && self.columns == other.columns
+ }
+}
+
+impl Eq for SchemaFingerprint {}
+
+impl Hash for SchemaFingerprint {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ state.write_u64(self.hash);
+ }
+}
+
+impl DFHeapSize for SchemaFingerprint {
+ fn heap_size(&self, ctx: &mut DFHeapSizeCtx) -> usize {
+ self.columns.heap_size(ctx)
+ }
+}
+
+/// Cache key for the file-statistics cache.
+///
+/// Like [`TableScopedPath`] it is scoped by table and path, but it
additionally
+/// carries a [`SchemaFingerprint`]. File statistics are computed against a
+/// specific `file_schema`, so the same path read under different schemas must
+/// not share an entry; the fingerprint keeps those entries distinct while a
+/// repeated read of the same schema still reuses its entry.
+#[derive(PartialEq, Eq, Hash, Clone, Debug)]
+pub struct FileStatisticsCacheKey {
+ pub table: Option<TableReference>,
+ pub path: Path,
+ // `Arc` so building a key per file is a cheap refcount bump rather than a
+ // deep clone of the fingerprint. `Arc`'s `Eq`/`Hash` compare the inner
value,
+ // so keying remains by schema contents (not pointer identity).
+ pub schema: Arc<SchemaFingerprint>,
+}
+
+impl DFHeapSize for FileStatisticsCacheKey {
+ fn heap_size(&self, ctx: &mut DFHeapSizeCtx) -> usize {
+ self.path.as_ref().heap_size(ctx)
+ + self.table.heap_size(ctx)
+ + self.schema.as_ref().heap_size(ctx)
Review Comment:
Yes, it makes sense. Since the schema is shared through an Arc, and the heap
allocation behind it is shared by both the cache keys and the ListingTable, I
chose to skip counting its heap size.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
