Indexes

Every collection in SoliDB automatically has a Primary Index on the _key attribute.

• Unique: The `_key` is guaranteed to be unique within a collection.
• Automatic: Created automatically when the collection is created. Cannot be deleted.
• Fastest Access: Retrieving a document by its `_key` is the most efficient operation (O(1)).

Off by default. Enable per collection with autoIndex: true, or leave it unset and set SOLIDB_AUTO_INDEX=1. An explicit autoIndex: false opts the collection out even when the env var is set.

When a FOR … FILTER var.field == … (or range, not null) would use an index and none exists, SoliDB creates a persistent, non-unique _auto_{field} index, backfills it, and uses it for that query. Nested fields keep dots (_auto_address.city). SORT is not auto-indexed: persistent indexes omit missing fields, so an auto-created sort index would drop documents.

Creating an index is a write, so the caller must hold Write or Admin — a viewer token never persists one, on /cursor, /sql, /explain, a transactional query or the binary protocol alike. A query that carries no principal at all (an internal materialised-view refresh, a queue job, a stream task) does not auto-index either.

• At most 16 _auto_* indexes per collection.
• Existing user (or edge) indexes on the same field are never duplicated, and neither is a composite index that already covers the FILTER.
• _key, _id, _rev, sharded collections, and collections whose names start with _ are skipped.
• Collections above SOLIDB_AUTO_INDEX_MAX_DOCS documents (default 1,000,000; 0 disables the ceiling) are skipped — the backfill runs inside the query that triggered it.
• If no document carries the field, the index is dropped again instead of sitting empty and consuming a slot.
• EXPLAIN does not create indexes; it may set auto_index_candidate when this query would actually create one.

A Hash Index provides constant-time O(1) lookups for exact matches. It is the fastest index type but supports only equality comparisons (`==`).

A Bloom Filter is a space-efficient probabilistic data structure that is used to test whether an element is a member of a set. It may return false positives, but never false negatives.

{
   "type": "bloom",
   "field": "username",
   "unique": true
}

A Cuckoo Filter is an advanced probabilistic data structure that improves upon Bloom filters by supporting item deletion and providing higher space efficiency for low false positive rates.

{
   "type": "cuckoo",
   "field": "user_id",
   "unique": true
}

A Persistent Index is a sorted index stored on disk (using RocksDB/SkipLists) that allows for fast lookups, range queries (`<`, `<=`, `>=`, `>`), and sorting.

A Columnar Index stores data column-by-column rather than row-by-row. This layout is highly optimized for analytical queries (OLAP), aggregations, and scanning large datasets where only a subset of attributes is needed.

{
   "type": "columnar",
   "fields": ["revenue", "category", "region"],
   "subtypes": {
     "revenue": "minmax",
     "category": "bitmap",
     "region": "sorted"
   }
}

A Vector Index enables semantic search by indexing high-dimensional vectors (embeddings). It uses HNSW (Hierarchical Navigable Small World) graphs for fast Approximate Nearest Neighbor (ANN) search.

{
   "type": "vector",
   "field": "embedding",
   "dimension": 1536,
   "metric": "cosine",
   "quantization": "scalar"
}

A Fulltext Index allows for fuzzy search and relevance scoring on text fields. It uses BM25 scoring and n-gram tokenization to find relevant documents even with typos or partial matches.

{
   "type": "fulltext",
   "fields": ["title", "description"],
   "ngram_size": 3
}

A Compound Index spans multiple fields, enabling efficient queries that filter on field combinations. The order of fields matters for prefix-based lookups.

{
  "name": "idx_user_date",
  "type": "persistent",
  "fields": ["user_id", "created_at"],
  "unique": false
}

A Geo Spatial Index accelerates queries involving geographic coordinates (latitude and longitude). It uses an R-Tree structure to efficiently find points within a radius or bounding box.

FOR place IN locations
  FILTER DISTANCE(place.loc[0], place.loc[1], 48.85, 2.35) < 1000
  RETURN place

All SoliDB indexes are implicitly sparse. Documents where the indexed field is null or missing are not added to the index.