tursodatabase/turso · error · anyhow::Error

need at least one query per connection

Error message

need at least one query per connection

What it means

The FTS latency benchmark harness refuses to start when the caller supplies an empty list of sessions or fewer queries than there are connections. Each connection must run at least one query for the per-connection worker split to make sense, so `measure` fails fast with this message instead of producing meaningless results.

Solutions

1. Pass at least one session/connection to `measure`.
2. Ensure `queries >= sessions.len()` by scaling the query count to the connection count.
3. Validate connection and query counts at CLI parse time before invoking `measure`.

Example fix

// before
measure(vec![], 1, &execute)?;
// after
measure(vec![conn1, conn2], 2, &execute)?; // queries (2) >= connections (2)

assert!(!sessions.is_empty(), "measure requires at least one session");
assert!(queries >= sessions.len(), "queries ({queries}) must be >= connections ({})", sessions.len());

When it happens

Trigger: Calling `perf/fts/src/latency.rs::measure` with `sessions: Vec<S>` empty, or with `queries < sessions.len()` (e.g. 1 query across 4 connections).

Common situations: Passing a CLI-derived `--connections` value with an incorrectly computed query count, or an empty session vector after filtering failed connections before the call.

Understand the failure class

Background: "Must be a positive integer", "Invalid value", "Unsupported": the invalid-argument-value error family, when a library rejects the value you pass — this error's family across 35 libraries.

Related errors

• connections must be positive
• connections must be positive
• database was busy
• documents must be positive
• first-query runs require one query per connection; use warm…

AI-assisted analysis of tursodatabase/turso@8d4a589f8d (2026-09-20). Data as JSON: /api/errors/fcee7b496611e0ea. Report an issue: GitHub.

Appendix: source

Thrown at perf/fts/src/latency.rs:16

use std::sync::Barrier;
use std::time::Instant;

use anyhow::{Result, ensure};
use memory_benchmark::fts::RunResult;
use tokio::runtime::Runtime;

use crate::Measurement;

pub fn measure<S: Send>(
    sessions: Vec<S>,
    queries: usize,
    execute: impl Fn(&mut S, &Runtime) -> Result<RunResult> + Sync,
) -> Result<Measurement> {
    let connections = sessions.len();
    ensure!(
        connections > 0 && queries >= connections,
        "need at least one query per connection"
    );
    let workers = sessions
        .into_iter()
        .map(|session| {
            Ok((
                session,
                tokio::runtime::Builder::new_current_thread()
                    .enable_all()
                    .build()?,
            ))
        })
        .collect::<Result<Vec<_>>>()?;
    let barrier = Barrier::new(connections + 1);
    std::thread::scope(|scope| {
        let handles: Vec<_> = workers
            .into_iter()

View on GitHub (pinned to 8d4a589f8d)