Struct CreateIndexParams 

pub struct CreateIndexParams {
    pub directory_path: PathBuf,
    pub vector_size: usize,
    pub shard_size: usize,
    pub batch_write_interval_ms: u64,
    pub wal_segment_size: usize,
    pub bloom_filter_size: usize,
    pub default_slop_factor: u32,
}

Parameters for creating a new Shardex index

This struct contains all the configuration parameters needed to create a new index, derived from the ShardexConfig structure but focused specifically on the creation operation.

Fields

directory_path: PathBuf

Directory path where the index will be stored

vector_size: usize

Size of embedding vectors in dimensions

shard_size: usize

Maximum number of entries per shard

batch_write_interval_ms: u64

Interval between batch writes in milliseconds

wal_segment_size: usize

Size of each WAL segment in bytes

bloom_filter_size: usize

Size of bloom filters in bits

default_slop_factor: u32

Default slop factor for search operations

Implementations

impl CreateIndexParams

pub fn builder() -> CreateIndexParamsBuilder

Create a new parameter builder

pub fn high_performance(directory: PathBuf) -> Self

Create high-performance configuration parameters

Creates a configuration optimized for high throughput and performance with larger vectors and shard sizes suitable for production workloads.

Arguments

• directory - Directory path where the index will be stored

Example

use shardex::api::parameters::CreateIndexParams;
use std::path::PathBuf;

let params = CreateIndexParams::high_performance(PathBuf::from("./high_perf_index"));
assert_eq!(params.vector_size, 256);
assert_eq!(params.shard_size, 15000);

pub fn memory_optimized(directory: PathBuf) -> Self

Create memory-optimized configuration parameters

Creates a configuration optimized for memory usage with smaller vectors and shard sizes suitable for resource-constrained environments.

Arguments

• directory - Directory path where the index will be stored

Example

use shardex::api::parameters::CreateIndexParams;
use std::path::PathBuf;

let params = CreateIndexParams::memory_optimized(PathBuf::from("./memory_opt_index"));
assert_eq!(params.vector_size, 128);
assert_eq!(params.shard_size, 5000);

pub fn from_shardex_config(config: ShardexConfig) -> Self

Create parameters from a ShardexConfig

Converts a ShardexConfig into CreateIndexParams, allowing configurations to be used with the ApiThing pattern.

Arguments

• config - The ShardexConfig to convert

Example

use shardex::api::parameters::CreateIndexParams;
use shardex::ShardexConfig;

let config = ShardexConfig::new()
    .directory_path("./config_index")
    .vector_size(512)
    .shard_size(25000);

let params = CreateIndexParams::from_shardex_config(config);
assert_eq!(params.vector_size, 512);
assert_eq!(params.shard_size, 25000);

pub fn validate(&self) -> Result<(), ShardexError>

Validate the create index parameters

Performs comprehensive validation of all parameters to ensure they are within valid ranges and compatible with each other.

Errors

Returns ShardexError::Config if any parameter is invalid.

Trait Implementations

impl ApiOperation<ShardexContext, CreateIndexParams> for CreateIndex

type Output = ()

The type returned by a successful operation execution.

type Error = ShardexError

The error type returned when an operation fails.

fn execute( context: &mut ShardexContext, parameters: &CreateIndexParams, ) -> Result<Self::Output, Self::Error>

Execute the API operation with the given context and properties.

impl Clone for CreateIndexParams

fn clone(&self) -> CreateIndexParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CreateIndexParams

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

Formats the value using the given formatter.

impl From<ShardexConfig> for CreateIndexParams

fn from(config: ShardexConfig) -> Self

Converts to this type from the input type.