Struct Collection 

pub struct Collection { /* private fields */ }

A collection of documents in the database.

Collections are analogous to tables in relational databases and store JSON documents. They provide methods for inserting, querying, updating, and deleting documents.

Example

use luckdb::{Client, Document};
use serde_json::json;

let mut client = Client::new("mongodb://localhost");
let db = client.db("mydb");
let coll = db.collection("users");

// Insert a document
let user = json!({"name": "Alice", "email": "alice@example.com"});
coll.insert(user).unwrap();

Implementations

impl Collection

pub fn new(name: String) -> Self

Creates a new empty collection with the given name.

Arguments

• name - The name of the new collection.

pub fn insert(&mut self, doc: Document) -> Result<DocId>

Inserts a single document into the collection, auto-generating an _id field if not present.

Arguments

• doc - The document to insert. Must be a JSON object.

Returns

The ID of the inserted document.

Errors

Returns an error if the document is not a JSON object.

pub fn insert_many(&mut self, docs: Vec<Document>) -> Result<Vec<DocId>>

Inserts multiple documents into the collection, auto-generating _id fields for each.

Arguments

• docs - A list of documents to insert. Each must be a JSON object.

Returns

A list of IDs of the inserted documents.

Errors

Returns an error if any document is not a JSON object.

pub fn find( &self, query: Query, options: Option<FindOptions>, ) -> Result<Vec<(DocId, Document)>>

Finds all documents matching the given query.

Arguments

• query - The query to filter documents.
• options - Optional parameters for sorting, pagination, and projection.

Returns

A list of tuples containing document IDs and the matching documents.

pub fn find_one( &self, query: Query, options: Option<FindOptions>, ) -> Result<(DocId, Document)>

Finds the first document matching the given query.

Arguments

• query - The query to filter documents.
• options - Optional parameters for sorting and projection.

Returns

A tuple containing the document ID and the matching document.

Errors

Returns DbError::NotFound if no document matches the query.

pub fn find_one_and_update( &mut self, query: Query, update: UpdateDocument, options: Option<FindOneAndUpdateOptions>, ) -> Result<Option<(DocId, Document)>>

Finds a document, updates it, and returns the document (either before or after the update).

Arguments

• query - The query to filter documents.
• update - The update operations to apply.
• options - Optional parameters including upsert behavior and which document version to return.

Returns

The document before or after the update, depending on options.

pub fn find_one_and_replace( &mut self, query: Query, replacement: Document, options: Option<FindOneAndReplaceOptions>, ) -> Result<Option<(DocId, Document)>>

pub fn find_one_and_delete( &mut self, query: Query, options: Option<FindOneAndDeleteOptions>, ) -> Result<Option<(DocId, Document)>>

pub fn update_one( &mut self, query: Query, update: UpdateDocument, upsert: bool, ) -> Result<usize>

Updates the first document matching the query.

Arguments

• query - The query to filter documents.
• update - The update operations to apply.
• upsert - If true, creates a new document if no match is found.

Returns

The number of documents updated (either 0 or 1).

pub fn update_many( &mut self, query: Query, update: UpdateDocument, ) -> Result<usize>

Updates all documents matching the query.

Arguments

• query - The query to filter documents.
• update - The update operations to apply.

Returns

The number of documents updated.

pub fn replace_one( &mut self, query: Query, replacement: Document, upsert: bool, ) -> Result<usize>

pub fn delete_one(&mut self, query: Query) -> Result<usize>

Deletes the first document matching the query.

Arguments

• query - The query to filter documents.

Returns

The number of documents deleted (either 0 or 1).

pub fn delete_many(&mut self, query: Query) -> Result<usize>

Deletes all documents matching the query.

Arguments

• query - The query to filter documents.

Returns

The number of documents deleted.

pub fn count_documents(&self, query: Query) -> Result<usize>

Counts the number of documents matching the query.

Arguments

• query - The query to filter documents.

Returns

The number of matching documents.

pub fn estimated_document_count(&self) -> Result<usize>

Returns the estimated count of documents in the collection.

Returns

The total number of documents in the collection.

pub fn create_index(&mut self, index: Index) -> Result<()>

Creates an index on the collection.

Arguments

• index - The index definition containing field, type, uniqueness, and other properties.

Errors

Returns an error if an index with the same name already exists or if there’s a problem creating the index.

pub fn drop_index(&mut self, name: &str) -> Result<()>

Drops an existing index from the collection.

Arguments

• name - The name of the index to drop.

pub fn list_indexes(&self) -> Result<Vec<Index>>

Lists all indexes created on the collection.

Returns

A list of index definitions.

pub fn drop_indexes(&mut self) -> Result<()>

Drops all indexes from the collection.

pub fn stats(&self) -> Result<CollectionStats>

pub fn aggregate( &self, pipeline: Vec<AggregationStage>, ) -> Result<Vec<Document>>

pub fn distinct(&self, field: &str, query: Option<Query>) -> Result<Vec<Value>>

pub fn count(&self) -> usize

impl Collection

pub fn bulk_write( &mut self, operations: Vec<BulkWriteOperation>, options: Option<BulkWriteOptions>, ) -> Result<BulkWriteResult>

Trait Implementations

impl Clone for Collection

fn clone(&self) -> Collection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Collection

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Collection

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Collection> for PersistentCollection

fn from(collection: Collection) -> Self

Converts to this type from the input type.

impl From<PersistentCollection> for Collection

fn from(persistent: PersistentCollection) -> Self

Converts to this type from the input type.

impl Serialize for Collection

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.