Enum AnyCollection 

#[non_exhaustive]
pub enum AnyCollection {
    Vector(VectorCollection),
    Graph(GraphCollection),
    Metadata(MetadataCollection),
}

Type-erased collection handle for callers that don’t know the collection type.

Dispatches common operations to the inner typed collection via enum match. Zero-cost: no heap allocation, no vtable — just a match arm per variant.

Examples

use velesdb_core::{AnyCollection, Database};

let db = Database::open("./data")?;
if let Some(any) = db.get_any_collection("docs") {
    // `config()`, `flush()`, `point_count()`, `name()`, `execute_query_str()`
    // dispatch across all variants — safe on every kind.
    println!("{}: {} pts", any.name(), any.point_count());

    // Pattern-match when a variant-specific method is needed.
    match &any {
        AnyCollection::Vector(_) => println!("vector collection"),
        AnyCollection::Graph(_)  => println!("graph collection"),
        AnyCollection::Metadata(_) => println!("metadata collection"),
        _ => println!("unknown variant"),
    }
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Vector(VectorCollection)

A vector collection (HNSW + payload + full-text).

Graph(GraphCollection)

A graph collection (edges + optional node embeddings).

Metadata(MetadataCollection)

A metadata-only collection (payload, no vectors).

Implementations

impl AnyCollection

pub fn config(&self) -> CollectionConfig

Returns the collection configuration.

pub fn flush(&self) -> Result<()>

Flushes all state to disk.

Errors

Returns an error if any flush operation fails.

pub fn point_count(&self) -> usize

Returns the number of points in the collection.

pub fn is_empty(&self) -> bool

Returns true if the collection contains no points.

pub fn is_metadata_only(&self) -> bool

Returns true if this is a metadata-only collection.

Equivalent to is_metadata — kept for backward compatibility with older call sites.

pub fn name(&self) -> String

Returns the collection name.

pub fn execute_query_str( &self, sql: &str, params: &HashMap<String, Value>, ) -> Result<Vec<SearchResult>>

Executes a raw VelesQL string, parsing it before execution.

Errors

Returns an error if parsing or execution fails.

pub fn execute_aggregate( &self, query: &Query, params: &HashMap<String, Value>, ) -> Result<Value>

Executes an aggregation query (GROUP BY / COUNT / SUM / AVG / MIN / MAX).

Errors

Returns an error if the query is invalid or aggregation computation fails.

pub fn diagnostics(&self) -> CollectionDiagnostics

Returns collection diagnostics.

pub fn is_vector(&self) -> bool

Returns true if this collection is the Vector variant.

Examples

use velesdb_core::{AnyCollection, Database, DistanceMetric};

let db = Database::open("./data")?;
db.create_collection("docs", 768, DistanceMetric::Cosine)?;
let any = db.get_any_collection("docs").expect("exists");
assert!(any.is_vector());
assert!(!any.is_graph());

pub fn is_graph(&self) -> bool

Returns true if this collection is the Graph variant.

Examples

use velesdb_core::{Database, GraphSchema};

let db = Database::open("./data")?;
db.create_graph_collection("edges", GraphSchema::schemaless())?;
let any = db.get_any_collection("edges").expect("exists");
assert!(any.is_graph());

pub fn is_metadata(&self) -> bool

Returns true if this collection is the Metadata variant.

Examples

use velesdb_core::Database;

let db = Database::open("./data")?;
db.create_metadata_collection("catalog")?;
let any = db.get_any_collection("catalog").expect("exists");
assert!(any.is_metadata());

pub fn as_vector(&self) -> Option<&VectorCollection>

Returns a shared reference to the inner VectorCollection if this is the Vector variant, or None otherwise.

Examples

use velesdb_core::{Database, DistanceMetric};

let db = Database::open("./data")?;
db.create_collection("docs", 768, DistanceMetric::Cosine)?;
let any = db.get_any_collection("docs").expect("exists");
if let Some(v) = any.as_vector() {
    let _ = v.config().dimension;
}

pub fn as_vector_mut(&mut self) -> Option<&mut VectorCollection>

Returns an exclusive reference to the inner VectorCollection if this is the Vector variant, or None otherwise.

pub fn as_graph(&self) -> Option<&GraphCollection>

Returns a shared reference to the inner GraphCollection if this is the Graph variant, or None otherwise.

Examples

use velesdb_core::{Database, GraphSchema};

let db = Database::open("./data")?;
db.create_graph_collection("edges", GraphSchema::schemaless())?;
let any = db.get_any_collection("edges").expect("exists");
if let Some(g) = any.as_graph() {
    let _ = g.edge_count();
}

pub fn as_graph_mut(&mut self) -> Option<&mut GraphCollection>

Returns an exclusive reference to the inner GraphCollection if this is the Graph variant, or None otherwise.

pub fn as_metadata(&self) -> Option<&MetadataCollection>

Returns a shared reference to the inner MetadataCollection if this is the Metadata variant, or None otherwise.

Examples

use velesdb_core::Database;

let db = Database::open("./data")?;
db.create_metadata_collection("catalog")?;
let any = db.get_any_collection("catalog").expect("exists");
if let Some(m) = any.as_metadata() {
    let _ = m.is_empty();
}

pub fn as_metadata_mut(&mut self) -> Option<&mut MetadataCollection>

Returns an exclusive reference to the inner MetadataCollection if this is the Metadata variant, or None otherwise.

pub fn into_vector(self) -> Result<VectorCollection, Self>

Consumes self and returns the inner VectorCollection if this is the Vector variant.

On the wrong variant, returns Err(self) so callers can recover ownership — mirroring the std Result / TryFrom idiom.

Errors

Returns the original AnyCollection unchanged when the variant is Graph or Metadata.

Examples

use velesdb_core::{Database, DistanceMetric};

let db = Database::open("./data")?;
db.create_collection("docs", 768, DistanceMetric::Cosine)?;
let any = db.get_any_collection("docs").expect("exists");
match any.into_vector() {
    Ok(v) => { let _ = v.config().dimension; }
    Err(original) => {
        // wrong variant; `original` still valid
        assert!(!original.is_vector());
    }
}

pub fn into_graph(self) -> Result<GraphCollection, Self>

Consumes self and returns the inner GraphCollection if this is the Graph variant.

On the wrong variant, returns Err(self) so callers can recover ownership.

Errors

Returns the original AnyCollection unchanged when the variant is Vector or Metadata.

Examples

use velesdb_core::{Database, GraphSchema};

let db = Database::open("./data")?;
db.create_graph_collection("edges", GraphSchema::schemaless())?;
let any = db.get_any_collection("edges").expect("exists");
match any.into_graph() {
    Ok(graph) => { let _ = graph.edge_count(); }
    Err(_wrong_variant) => unreachable!("edges is a graph collection"),
}

pub fn into_metadata(self) -> Result<MetadataCollection, Self>

Consumes self and returns the inner MetadataCollection if this is the Metadata variant.

On the wrong variant, returns Err(self) so callers can recover ownership.

Errors

Returns the original AnyCollection unchanged when the variant is Vector or Graph.

Examples

use velesdb_core::Database;

let db = Database::open("./data")?;
db.create_metadata_collection("catalog")?;
let any = db.get_any_collection("catalog").expect("exists");
match any.into_metadata() {
    Ok(meta) => assert!(meta.is_empty()),
    Err(_wrong_variant) => unreachable!("catalog is a metadata collection"),
}

pub unsafe fn into_vector_unchecked(self) -> VectorCollection

Consumes self and returns a VectorCollection regardless of the underlying variant, re-wrapping the shared inner state.

For the Vector variant this is a straightforward move. For the Graph and Metadata variants this re-wraps the shared Arc<Collection> in the VectorCollection newtype without changing the underlying runtime type — downstream code that invokes vector-specific methods on the result (for example search, upsert, config().dimension > 0) may therefore return empty results or misleading state.

This method exists to support the Python / Mobile / Tauri SDK bindings that expose a single Collection type to users and only invoke the shared surface (config, flush, diagnostics, point_count, execute_query_str) on the result.

Safety

Calling vector-specific methods on a VectorCollection obtained from a Graph or Metadata variant is not memory-unsafe, but the result is logically unsound: the underlying storage does not hold a homogeneous vector index, and the returned search results are either empty or reflect internal state that was not intended for public consumption.

Callers must either:

• branch on is_vector first and only invoke vector-specific methods on the Vector variant, or
• restrict themselves to the methods that all three collection kinds share (config, flush, diagnostics, name, point_count, execute_query_str).

Prefer the safe into_vector (variant-checked, returns Result) when the caller can branch. A proper type-safe refactor that eliminates this method entirely is tracked under the post-seed EPIC documented in docs/ARCHITECTURE.md (finding F2.2 of the pre-seed audit).

Violation of invariants

The unsafe marker flags the caller contract (only invoke the shared surface on non-Vector variants) even though violating it does not cause undefined behaviour.

Trait Implementations

impl Clone for AnyCollection

fn clone(&self) -> AnyCollection

Returns a duplicate of the value.

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

Performs copy-assignment from source.