Struct PlanCacheKey 

pub struct PlanCacheKey {
    pub hash: u64,
    /* private fields */
}

Query Plan Cache Key

Supports fast lookups using the hash of the query text as the key. Also store query text for conflict detection.

When a plan carries a non-stale PartitionSpec the key includes a partition fingerprint so that a change in the underlying data layout (e.g. re-indexing) automatically yields a cache miss, forcing the planner to produce a fresh physical plan. Callers that only have the query text (the common lookup path before planning) query with fingerprint == None, which will not match entries that were stored with a fingerprint — effectively isolating partitioned plans from the cache until the caller can provide the current layout version.

Cache key now includes optional space_name and schema_version to prevent cross-space plan reuse and stale plans after schema changes.

Cache key includes optional param_type_signature so that the same query text with different parameter type signatures produces a different key, but different parameter values do not (allowing cached plan reuse across executions with different values of the same types).

Fields

hash: u64

Query the hash value of the text

Implementations

impl PlanCacheKey

pub fn from_query(query: &str) -> Self

Creating Cache Keys from Query Text

pub fn from_query_with_space( query: &str, space_name: Option<String>, schema_version: Option<u64>, ) -> Self

Create a key scoped to a specific space and schema version.

param_type_signature is a hash of the parameter types (not values) so the same query with different param values but same types reuses the cached plan.

pub fn from_query_with_full_context( query: &str, space_name: Option<String>, schema_version: Option<u64>, param_type_signature: Option<u64>, index_version: Option<u64>, ) -> Self

Create a key with all available context dimensions.

pub fn from_query_with_context(query: &str, context: PlanCacheContext) -> Self

pub fn from_query_with_partition(query: &str, spec: &PartitionSpec) -> Self

Create a key that additionally captures a physical partition layout, preventing stale cached plans from being reused after layout changes.

pub fn from_query_with_partition_and_context( query: &str, spec: &PartitionSpec, context: PlanCacheContext, ) -> Self

Create a partition-scoped key that also carries the full compatibility context (space / schema / index / param types / optimizer / planning config). Used so partitioned plans are invalidated on DDL, cross-space reuse is blocked, and a changed layout fingerprint forces a replan.

pub fn verify_query(&self, query: &str) -> bool

Verify that the query text matches (for conflict detection)

pub fn query_text(&self) -> &str

Get query text (for debugging or logging)

pub fn has_partition_fingerprint(&self) -> bool

Whether this key holds a partition fingerprint.

pub fn space_name(&self) -> Option<&str>

Return the space name, if any.

pub fn schema_version(&self) -> Option<u64>

Return the schema version, if any.

Trait Implementations

impl Clone for PlanCacheKey

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PlanCacheKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for PlanCacheKey

impl Hash for PlanCacheKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PlanCacheKey

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for PlanCacheKey