nautechsystems/nautilus_trader · error

Unsupported operation: `read` for collection

Error message

Unsupported operation: `read` for collection '{collection}'

What it means

The Redis cache adapter's `read` operation dispatches on the collection name and only supports a fixed set: INDEX, GENERAL, CURRENCIES, INSTRUMENTS, INSTRUMENT_CLOSES, SYNTHETICS, ACTORS, STRATEGIES (string reads), and ACCOUNTS, ORDERS, POSITIONS, SNAPSHOTS (list reads). Any other collection string fails fast with this bail! so unsupported reads never silently return empty data.

Solutions

1. Check the collection name against the supported constants in crates/infrastructure/src/redis/queries.rs (INDEX, GENERAL, CURRENCIES, INSTRUMENTS, INSTRUMENT_CLOSES, SYNTHETICS, ACTORS, STRATEGIES, ACCOUNTS, ORDERS, POSITIONS, SNAPSHOTS) and fix the typo/wrong name
2. If you need a genuinely new collection, extend the match in RedisCache::read to route it to read_string or read_list
3. Confirm the nautilus version matches the one that wrote the cache data; upgrade the adapter if the collection only exists in a newer version

Example fix

// before
cache.read("Orders", &key).await?; // wrong casing/collection
// after
cache.read(ORDERS, &key).await?;   // use the supported collection constant

const SUPPORTED: &[&str] = &[INDEX, GENERAL, CURRENCIES, INSTRUMENTS, INSTRUMENT_CLOSES, SYNTHETICS, ACTORS, STRATEGIES, ACCOUNTS, ORDERS, POSITIONS, SNAPSHOTS];
fn is_supported_collection(c: &str) -> bool { SUPPORTED.contains(&c) }
if !is_supported_collection(collection) { return Err(anyhow!("collection {collection} not supported by redis cache read")); }

fn is_supported_collection(c: &str) -> bool { SUPPORTED.contains(&c) }

When it happens

Trigger: Calling CacheConfig/RedisCache read with a collection key that is not one of the supported constants — typically a typo'd collection name, a collection added in a newer nautilus version but read through an older adapter, or a custom collection passed to the generic read API.

Common situations: Hand-editing a cache database namespace or snapshot tooling that enumerates collections; mixing trader cache data written by a different nautilus version that introduced a new collection; scripting against Redis directly with a wrong key suffix.

Understand the failure class

Background: UnsupportedOperationException and "is not supported" errors: when a library deliberately refuses a call — this error's family across 30 libraries.

Related errors

• Index unknown ' ' on read
• Unsupported index operation: remove from
• Unsupported operation: `delete` for collection
• Unsupported operation: `replace_list` for collection
• Unsupported operation: `update` for collection

AI-assisted analysis of nautechsystems/nautilus_trader@18893faf8b (2026-09-08). Data as JSON: /api/errors/7773367f4c5bb1e2. Report an issue: GitHub.

Appendix: source

Thrown at crates/infrastructure/src/redis/queries.rs:251

    /// # Errors
    ///
    /// Returns an error if the underlying Redis read operation fails or if the collection is unsupported.
    pub async fn read(
        con: &ConnectionManager,
        trader_key: &str,
        key: &str,
    ) -> anyhow::Result<Vec<Bytes>> {
        let collection = Self::get_collection_key(key)?;
        let full_key = format!("{trader_key}{REDIS_DELIMITER}{key}");

        let mut con = con.clone();

        match collection {
            INDEX => Self::read_index(&mut con, &full_key).await,
            GENERAL | CURRENCIES | INSTRUMENTS | INSTRUMENT_CLOSES | SYNTHETICS | ACTORS
            | STRATEGIES => Self::read_string(&mut con, &full_key).await,
            ACCOUNTS | ORDERS | POSITIONS | SNAPSHOTS => Self::read_list(&mut con, &full_key).await,
            _ => anyhow::bail!("Unsupported operation: `read` for collection '{collection}'"),
        }
    }

    /// Loads all cache data (currencies, instruments, synthetics, accounts, orders, positions) for `trader_key`.
    ///
    /// # Errors
    ///
    /// Returns an error if loading any of the individual caches fails or combining data fails.
    pub async fn load_all(
        con: &ConnectionManager,
        encoding: SerializationEncoding,
        trader_key: &str,
    ) -> anyhow::Result<CacheMap> {
        let (currencies, instruments, instrument_closes, synthetics, accounts, orders, positions) =
            tokio::try_join!(
                Self::load_currencies(con, trader_key, encoding),
                Self::load_instruments(con, trader_key, encoding),
                Self::load_instrument_closes(con, trader_key, encoding),

View on GitHub (pinned to 18893faf8b)