Searching Dictionaries

Full-text search lets you find entries by matching against their definitions, not just their headwords. Unlike lookup which requires an exact term match, search uses a Tantivy-powered full-text index.

Creating an index

Before you can search, you need to create a full-text index. This only needs to be done once per dictionary (the index is persisted to disk).

Rust

use odict::{OpenDictionary, index::IndexOptions};

fn main() -> odict::Result<()> {
let file = OpenDictionary::from_path("my-dictionary.odict")?;
let dict = file.contents()?;

    dict.index(IndexOptions::default())?;

    Ok(())

}

Python

from theopendictionary import OpenDictionary

dictionary = await OpenDictionary.load("./my-dictionary.odict")
dictionary.index()

JavaScript

import { OpenDictionary } from "@odict/node";

const dictionary = await OpenDictionary.load("./my-dictionary.odict");
dictionary.index();

Index options

You can configure the indexing behavior.

Rust

use odict::index::IndexOptions;

let options = IndexOptions::default()
    .dir("./my-index")         // Custom index directory
    .overwrite(true)           // Overwrite existing index
    .memory(50_000_000);       // 50MB memory arena per thread

dict.index(options)?;

Python

from theopendictionary import IndexOptions

dictionary.index(IndexOptions(
directory="./my-index", # Custom index directory
overwrite=True, # Overwrite existing index
memory=50_000_000 # 50MB memory arena per thread
))

JavaScript

dictionary.index({
  directory: "./my-index",     // Custom index directory
  overwrite: true,             // Overwrite existing index
  memory: 50_000_000,          // 50MB memory arena per thread
});

Running a search

Once indexed, you can search across all definitions in the dictionary.

Rust

use odict::search::SearchOptions;

let results = dict.search("domesticated mammal", SearchOptions::default())?;

for entry in &results {
println!("{}", entry.term);
}

Python

results = dictionary.search("domesticated mammal")

for entry in results:
    print(entry.term)

JavaScript

const results = dictionary.search("domesticated mammal");

for (const entry of results) {
console.log(entry.term);
}

Search options

Rust

use odict::search::SearchOptions;

let options = SearchOptions::default()
    .dir("./my-index")        // Custom index directory
    .autoindex(true)           // Auto-create index if missing
    .limit(10)                 // Max results to return
    .threshold(50);            // Relevance threshold

let results = dict.search("greeting", options)?;

Python

from theopendictionary import SearchOptions

results = dictionary.search("greeting", SearchOptions(
directory="./my-index", # Custom index directory
autoindex=True, # Auto-create index if missing
limit=10, # Max results to return
threshold=50 # Relevance threshold
))

JavaScript

const results = dictionary.search("greeting", {
  directory: "./my-index",     // Custom index directory
  autoindex: true,             // Auto-create index if missing
  limit: 10,                   // Max results to return
  threshold: 50,               // Relevance threshold
});

Tip

The autoindex option is convenient for one-off scripts — it creates the index on the fly if one doesn’t exist yet. For production use, create the index ahead of time with index() to avoid the startup cost on first search.

Search vs. lookup

	Lookup	Search
Matches against	Entry terms (headwords)	Definition text
Requires index	No	Yes
Speed	O(1) per term	Depends on index size
Use case	You know the exact word	You’re searching by meaning
Supports splitting	Yes	No
Supports follow	Yes	No

In most applications you’ll use both: lookup for direct dictionary access, and search for discovery.