554 lines
17 KiB
Python
554 lines
17 KiB
Python
"""
|
|
Query result caching module for NHS Patient Pathway Analysis.
|
|
|
|
Provides file-based caching for Snowflake query results with TTL-based invalidation.
|
|
Supports different TTLs for historical data vs data including the current date.
|
|
|
|
Cache keys are generated from query hashes. Results are stored as compressed JSON.
|
|
|
|
Usage:
|
|
from data_processing.cache import QueryCache, get_cache
|
|
|
|
cache = get_cache()
|
|
|
|
# Check for cached result
|
|
result = cache.get(query, params)
|
|
if result is None:
|
|
# Execute query and cache result
|
|
result = execute_query(query, params)
|
|
cache.set(query, params, result, includes_current_data=False)
|
|
"""
|
|
|
|
from dataclasses import dataclass
|
|
from datetime import datetime, date
|
|
from pathlib import Path
|
|
from typing import Any, Optional
|
|
import gzip
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import time
|
|
|
|
from config import get_snowflake_config, CacheConfig
|
|
from core.logging_config import get_logger
|
|
|
|
logger = get_logger(__name__)
|
|
|
|
|
|
@dataclass
|
|
class CacheEntry:
|
|
"""Metadata for a cached query result."""
|
|
cache_key: str
|
|
query_hash: str
|
|
created_at: datetime
|
|
expires_at: datetime
|
|
includes_current_data: bool
|
|
row_count: int
|
|
file_size_bytes: int
|
|
file_path: Path
|
|
|
|
|
|
@dataclass
|
|
class CacheStats:
|
|
"""Statistics about the cache."""
|
|
enabled: bool
|
|
cache_dir: Path
|
|
total_entries: int
|
|
total_size_mb: float
|
|
max_size_mb: int
|
|
oldest_entry: Optional[datetime]
|
|
newest_entry: Optional[datetime]
|
|
hit_count: int
|
|
miss_count: int
|
|
|
|
|
|
class QueryCache:
|
|
"""
|
|
File-based cache for Snowflake query results.
|
|
|
|
Results are stored as gzipped JSON files with TTL-based expiration.
|
|
Supports different TTLs for historical vs current data.
|
|
|
|
Attributes:
|
|
config: CacheConfig with cache settings
|
|
cache_dir: Path to cache directory
|
|
"""
|
|
|
|
def __init__(self, config: Optional[CacheConfig] = None, base_path: Optional[Path] = None):
|
|
"""
|
|
Initialize the query cache.
|
|
|
|
Args:
|
|
config: Optional CacheConfig. If not provided, loads from snowflake.toml
|
|
base_path: Base path for relative cache directory. Defaults to cwd.
|
|
"""
|
|
if config is None:
|
|
sf_config = get_snowflake_config()
|
|
config = sf_config.cache
|
|
|
|
self._config = config
|
|
self._base_path = base_path or Path.cwd()
|
|
|
|
# Resolve cache directory
|
|
cache_dir = Path(config.directory)
|
|
if not cache_dir.is_absolute():
|
|
cache_dir = self._base_path / cache_dir
|
|
self._cache_dir = cache_dir
|
|
|
|
# Stats tracking (in-memory only, reset on restart)
|
|
self._hit_count = 0
|
|
self._miss_count = 0
|
|
|
|
# Ensure cache directory exists if enabled
|
|
if self._config.enabled:
|
|
self._cache_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
@property
|
|
def config(self) -> CacheConfig:
|
|
"""Return the cache configuration."""
|
|
return self._config
|
|
|
|
@property
|
|
def cache_dir(self) -> Path:
|
|
"""Return the cache directory path."""
|
|
return self._cache_dir
|
|
|
|
@property
|
|
def is_enabled(self) -> bool:
|
|
"""Return True if caching is enabled."""
|
|
return self._config.enabled
|
|
|
|
def _generate_cache_key(self, query: str, params: Optional[tuple] = None) -> str:
|
|
"""
|
|
Generate a cache key from query and parameters.
|
|
|
|
Uses SHA256 hash of query + params to create unique key.
|
|
"""
|
|
# Normalize query (strip whitespace, lowercase)
|
|
normalized_query = " ".join(query.lower().split())
|
|
|
|
# Combine query and params
|
|
key_content = normalized_query
|
|
if params:
|
|
key_content += "|" + "|".join(str(p) for p in params)
|
|
|
|
# Hash to create key
|
|
hash_obj = hashlib.sha256(key_content.encode("utf-8"))
|
|
return hash_obj.hexdigest()[:32] # Use first 32 chars for readability
|
|
|
|
def _get_cache_file_path(self, cache_key: str) -> Path:
|
|
"""Get the file path for a cache entry."""
|
|
return self._cache_dir / f"{cache_key}.json.gz"
|
|
|
|
def _get_meta_file_path(self, cache_key: str) -> Path:
|
|
"""Get the metadata file path for a cache entry."""
|
|
return self._cache_dir / f"{cache_key}.meta.json"
|
|
|
|
def _is_expired(self, meta: dict) -> bool:
|
|
"""Check if a cache entry is expired based on its metadata."""
|
|
expires_at = datetime.fromisoformat(meta["expires_at"])
|
|
return datetime.now() > expires_at
|
|
|
|
def get(
|
|
self,
|
|
query: str,
|
|
params: Optional[tuple] = None,
|
|
check_expiry: bool = True
|
|
) -> Optional[list[dict]]:
|
|
"""
|
|
Get a cached query result.
|
|
|
|
Args:
|
|
query: SQL query string
|
|
params: Optional query parameters
|
|
check_expiry: If True, returns None for expired entries
|
|
|
|
Returns:
|
|
Cached result as list of dicts, or None if not cached/expired
|
|
"""
|
|
if not self.is_enabled:
|
|
self._miss_count += 1
|
|
return None
|
|
|
|
cache_key = self._generate_cache_key(query, params)
|
|
cache_file = self._get_cache_file_path(cache_key)
|
|
meta_file = self._get_meta_file_path(cache_key)
|
|
|
|
# Check if files exist
|
|
if not cache_file.exists() or not meta_file.exists():
|
|
self._miss_count += 1
|
|
logger.debug(f"Cache miss (not found): {cache_key}")
|
|
return None
|
|
|
|
# Load and check metadata
|
|
try:
|
|
with open(meta_file, "r", encoding="utf-8") as f:
|
|
meta = json.load(f)
|
|
|
|
if check_expiry and self._is_expired(meta):
|
|
self._miss_count += 1
|
|
logger.debug(f"Cache miss (expired): {cache_key}")
|
|
return None
|
|
|
|
# Load cached data
|
|
with gzip.open(cache_file, "rt", encoding="utf-8") as f:
|
|
data = json.load(f)
|
|
|
|
self._hit_count += 1
|
|
logger.info(f"Cache hit: {cache_key} ({meta['row_count']} rows)")
|
|
return data
|
|
|
|
except (json.JSONDecodeError, KeyError, OSError) as e:
|
|
logger.warning(f"Cache read error for {cache_key}: {e}")
|
|
self._miss_count += 1
|
|
# Clean up corrupted entry
|
|
self._delete_entry(cache_key)
|
|
return None
|
|
|
|
def set(
|
|
self,
|
|
query: str,
|
|
params: Optional[tuple],
|
|
data: list[dict],
|
|
includes_current_data: bool = False,
|
|
custom_ttl_seconds: Optional[int] = None
|
|
) -> Optional[CacheEntry]:
|
|
"""
|
|
Cache a query result.
|
|
|
|
Args:
|
|
query: SQL query string
|
|
params: Optional query parameters
|
|
data: Query result as list of dicts
|
|
includes_current_data: If True, uses shorter TTL for current data
|
|
custom_ttl_seconds: Optional custom TTL (overrides config)
|
|
|
|
Returns:
|
|
CacheEntry with metadata, or None if caching disabled/failed
|
|
"""
|
|
if not self.is_enabled:
|
|
return None
|
|
|
|
cache_key = self._generate_cache_key(query, params)
|
|
cache_file = self._get_cache_file_path(cache_key)
|
|
meta_file = self._get_meta_file_path(cache_key)
|
|
|
|
# Determine TTL
|
|
if custom_ttl_seconds is not None:
|
|
ttl = custom_ttl_seconds
|
|
elif includes_current_data:
|
|
ttl = self._config.ttl_current_data_seconds
|
|
else:
|
|
ttl = self._config.ttl_seconds
|
|
|
|
now = datetime.now()
|
|
expires_at = datetime.fromtimestamp(now.timestamp() + ttl)
|
|
|
|
try:
|
|
# Write compressed data
|
|
with gzip.open(cache_file, "wt", encoding="utf-8", compresslevel=6) as f:
|
|
json.dump(data, f, default=str)
|
|
|
|
file_size = cache_file.stat().st_size
|
|
|
|
# Write metadata
|
|
meta = {
|
|
"cache_key": cache_key,
|
|
"query_hash": hashlib.sha256(query.encode()).hexdigest()[:16],
|
|
"created_at": now.isoformat(),
|
|
"expires_at": expires_at.isoformat(),
|
|
"includes_current_data": includes_current_data,
|
|
"row_count": len(data),
|
|
"file_size_bytes": file_size,
|
|
"ttl_seconds": ttl,
|
|
}
|
|
|
|
with open(meta_file, "w", encoding="utf-8") as f:
|
|
json.dump(meta, f, indent=2)
|
|
|
|
logger.info(f"Cached {len(data)} rows as {cache_key} (expires in {ttl}s)")
|
|
|
|
# Check if we need to enforce size limit
|
|
self._enforce_size_limit()
|
|
|
|
return CacheEntry(
|
|
cache_key=cache_key,
|
|
query_hash=str(meta["query_hash"]),
|
|
created_at=now,
|
|
expires_at=expires_at,
|
|
includes_current_data=includes_current_data,
|
|
row_count=len(data),
|
|
file_size_bytes=file_size,
|
|
file_path=cache_file,
|
|
)
|
|
|
|
except (OSError, TypeError) as e:
|
|
logger.error(f"Failed to cache result: {e}")
|
|
return None
|
|
|
|
def invalidate(self, query: str, params: Optional[tuple] = None) -> bool:
|
|
"""
|
|
Invalidate a specific cache entry.
|
|
|
|
Args:
|
|
query: SQL query string
|
|
params: Optional query parameters
|
|
|
|
Returns:
|
|
True if entry was deleted, False if not found
|
|
"""
|
|
cache_key = self._generate_cache_key(query, params)
|
|
return self._delete_entry(cache_key)
|
|
|
|
def _delete_entry(self, cache_key: str) -> bool:
|
|
"""Delete a cache entry by key."""
|
|
cache_file = self._get_cache_file_path(cache_key)
|
|
meta_file = self._get_meta_file_path(cache_key)
|
|
|
|
deleted = False
|
|
|
|
if cache_file.exists():
|
|
cache_file.unlink()
|
|
deleted = True
|
|
|
|
if meta_file.exists():
|
|
meta_file.unlink()
|
|
deleted = True
|
|
|
|
if deleted:
|
|
logger.debug(f"Deleted cache entry: {cache_key}")
|
|
|
|
return deleted
|
|
|
|
def clear(self) -> int:
|
|
"""
|
|
Clear all cache entries.
|
|
|
|
Returns:
|
|
Number of entries deleted
|
|
"""
|
|
if not self._cache_dir.exists():
|
|
return 0
|
|
|
|
count = 0
|
|
for file in self._cache_dir.glob("*.json*"):
|
|
try:
|
|
file.unlink()
|
|
count += 1
|
|
except OSError as e:
|
|
logger.warning(f"Failed to delete {file}: {e}")
|
|
|
|
# Reset stats
|
|
self._hit_count = 0
|
|
self._miss_count = 0
|
|
|
|
logger.info(f"Cleared {count} cache files")
|
|
return count // 2 # Divide by 2 since we have .json.gz and .meta.json
|
|
|
|
def clear_expired(self) -> int:
|
|
"""
|
|
Remove expired cache entries.
|
|
|
|
Returns:
|
|
Number of expired entries deleted
|
|
"""
|
|
if not self._cache_dir.exists():
|
|
return 0
|
|
|
|
count = 0
|
|
for meta_file in self._cache_dir.glob("*.meta.json"):
|
|
try:
|
|
with open(meta_file, "r", encoding="utf-8") as f:
|
|
meta = json.load(f)
|
|
|
|
if self._is_expired(meta):
|
|
cache_key = meta_file.stem.replace(".meta", "")
|
|
self._delete_entry(cache_key)
|
|
count += 1
|
|
except (OSError, json.JSONDecodeError):
|
|
# Delete corrupted metadata files
|
|
cache_key = meta_file.stem.replace(".meta", "")
|
|
self._delete_entry(cache_key)
|
|
count += 1
|
|
|
|
logger.info(f"Cleared {count} expired cache entries")
|
|
return count
|
|
|
|
def _get_total_size_mb(self) -> float:
|
|
"""Calculate total cache size in MB."""
|
|
if not self._cache_dir.exists():
|
|
return 0.0
|
|
|
|
total_bytes = sum(
|
|
f.stat().st_size
|
|
for f in self._cache_dir.glob("*")
|
|
if f.is_file()
|
|
)
|
|
return total_bytes / (1024 * 1024)
|
|
|
|
def _enforce_size_limit(self) -> int:
|
|
"""
|
|
Enforce cache size limit by removing oldest entries.
|
|
|
|
Returns:
|
|
Number of entries removed
|
|
"""
|
|
max_size_mb = self._config.max_size_mb
|
|
current_size_mb = self._get_total_size_mb()
|
|
|
|
if current_size_mb <= max_size_mb:
|
|
return 0
|
|
|
|
# Get all entries sorted by creation time
|
|
entries = []
|
|
for meta_file in self._cache_dir.glob("*.meta.json"):
|
|
try:
|
|
with open(meta_file, "r", encoding="utf-8") as f:
|
|
meta = json.load(f)
|
|
entries.append((
|
|
meta_file.stem.replace(".meta", ""),
|
|
datetime.fromisoformat(meta["created_at"]),
|
|
meta.get("file_size_bytes", 0)
|
|
))
|
|
except (OSError, json.JSONDecodeError, KeyError):
|
|
# Clean up corrupted entry
|
|
cache_key = meta_file.stem.replace(".meta", "")
|
|
self._delete_entry(cache_key)
|
|
|
|
# Sort by creation time (oldest first)
|
|
entries.sort(key=lambda x: x[1])
|
|
|
|
# Remove oldest entries until under limit
|
|
removed = 0
|
|
size_to_remove_bytes = (current_size_mb - max_size_mb * 0.9) * 1024 * 1024 # Target 90% of limit
|
|
removed_bytes = 0
|
|
|
|
for cache_key, created_at, file_size in entries:
|
|
if removed_bytes >= size_to_remove_bytes:
|
|
break
|
|
|
|
self._delete_entry(cache_key)
|
|
removed_bytes += file_size
|
|
removed += 1
|
|
|
|
logger.info(f"Removed {removed} cache entries to enforce size limit")
|
|
return removed
|
|
|
|
def get_stats(self) -> CacheStats:
|
|
"""Get cache statistics."""
|
|
if not self._cache_dir.exists():
|
|
return CacheStats(
|
|
enabled=self.is_enabled,
|
|
cache_dir=self._cache_dir,
|
|
total_entries=0,
|
|
total_size_mb=0.0,
|
|
max_size_mb=self._config.max_size_mb,
|
|
oldest_entry=None,
|
|
newest_entry=None,
|
|
hit_count=self._hit_count,
|
|
miss_count=self._miss_count,
|
|
)
|
|
|
|
entries = []
|
|
for meta_file in self._cache_dir.glob("*.meta.json"):
|
|
try:
|
|
with open(meta_file, "r", encoding="utf-8") as f:
|
|
meta = json.load(f)
|
|
entries.append(datetime.fromisoformat(meta["created_at"]))
|
|
except (OSError, json.JSONDecodeError, KeyError):
|
|
pass
|
|
|
|
oldest = min(entries) if entries else None
|
|
newest = max(entries) if entries else None
|
|
|
|
return CacheStats(
|
|
enabled=self.is_enabled,
|
|
cache_dir=self._cache_dir,
|
|
total_entries=len(entries),
|
|
total_size_mb=self._get_total_size_mb(),
|
|
max_size_mb=self._config.max_size_mb,
|
|
oldest_entry=oldest,
|
|
newest_entry=newest,
|
|
hit_count=self._hit_count,
|
|
miss_count=self._miss_count,
|
|
)
|
|
|
|
def list_entries(self) -> list[CacheEntry]:
|
|
"""List all cache entries with metadata."""
|
|
if not self._cache_dir.exists():
|
|
return []
|
|
|
|
entries = []
|
|
for meta_file in self._cache_dir.glob("*.meta.json"):
|
|
try:
|
|
with open(meta_file, "r", encoding="utf-8") as f:
|
|
meta = json.load(f)
|
|
|
|
cache_key = meta["cache_key"]
|
|
entries.append(CacheEntry(
|
|
cache_key=cache_key,
|
|
query_hash=meta.get("query_hash", ""),
|
|
created_at=datetime.fromisoformat(meta["created_at"]),
|
|
expires_at=datetime.fromisoformat(meta["expires_at"]),
|
|
includes_current_data=meta.get("includes_current_data", False),
|
|
row_count=meta.get("row_count", 0),
|
|
file_size_bytes=meta.get("file_size_bytes", 0),
|
|
file_path=self._get_cache_file_path(cache_key),
|
|
))
|
|
except (OSError, json.JSONDecodeError, KeyError):
|
|
pass
|
|
|
|
# Sort by creation time (newest first)
|
|
entries.sort(key=lambda x: x.created_at, reverse=True)
|
|
return entries
|
|
|
|
|
|
# Module-level singleton
|
|
_default_cache: Optional[QueryCache] = None
|
|
|
|
|
|
def get_cache(config: Optional[CacheConfig] = None) -> QueryCache:
|
|
"""
|
|
Get a QueryCache instance (creates singleton on first call).
|
|
|
|
Args:
|
|
config: Optional CacheConfig. If provided, creates new cache with
|
|
this config. If None, uses/creates default cache.
|
|
|
|
Returns:
|
|
QueryCache instance
|
|
"""
|
|
global _default_cache
|
|
|
|
if config is not None:
|
|
# Custom config requested, create new cache
|
|
return QueryCache(config)
|
|
|
|
if _default_cache is None:
|
|
_default_cache = QueryCache()
|
|
|
|
return _default_cache
|
|
|
|
|
|
def reset_cache() -> None:
|
|
"""Reset the default cache singleton."""
|
|
global _default_cache
|
|
_default_cache = None
|
|
|
|
|
|
def is_cache_enabled() -> bool:
|
|
"""Return True if caching is enabled in configuration."""
|
|
config = get_snowflake_config()
|
|
return config.cache.enabled
|
|
|
|
|
|
# Export public API
|
|
__all__ = [
|
|
"QueryCache",
|
|
"CacheEntry",
|
|
"CacheStats",
|
|
"get_cache",
|
|
"reset_cache",
|
|
"is_cache_enabled",
|
|
]
|