What causes "query session not found: %s" in t8y2/dbx?

Re-run the original query to get a fresh query session ID when paging state is gone.

query session not found: %s

Error message

query session not found: %s

What it means

server.fetchQueryPage looks up a paged query's state in s.querySessions by sessionID. If no paging state exists (never started, already exhausted/closed, or a different server instance), it returns 'query session not found: %s'.

Source

Thrown at agents/drivers/iotdb/query.go:202

		Truncated:       page.truncated,
		HasMore:         page.hasMore,
	}
	if page.hasMore {
		s.nextSessionID++
		sessionID := fmt.Sprintf("iotdb-go-%d", s.nextSessionID)
		s.querySessions[sessionID] = page.state
		result.SessionID = &sessionID
	} else {
		_ = dataset.Close()
	}
	return result, nil
}

func (s *server) fetchQueryPage(sessionID string, requestedPageSize int) (queryPageResult, error) {
	started := time.Now()
	queryState := s.querySessions[sessionID]
	if queryState == nil {
		return queryPageResult{}, fmt.Errorf("query session not found: %s", sessionID)
	}
	pageSize := requestedPageSize
	if pageSize <= 0 {
		pageSize = defaultPageSize
	}
	page, err := runCancelable(s, 0, queryState.client, func(ctx context.Context) (queryPageRead, error) {
		rows, hasMore, truncated, err := s.readQuerySessionPage(ctx, queryState, pageSize)
		return queryPageRead{state: queryState, rows: rows, hasMore: hasMore, truncated: truncated}, err
	})
	if err != nil {
		_ = s.closeQuerySession(sessionID)
		return queryPageResult{}, err
	}
	result := queryPageResult{
		Columns:         queryState.columns,
		ColumnTypes:     queryState.columnTypes,
		Rows:            page.rows,
		ExecutionTimeMS: time.Since(started).Milliseconds(),

View on GitHub (pinned to c0390bff16)

Solutions

Re-run the original query to get a fresh query session ID when paging state is gone.
Stop paging once a page reports no more results instead of calling fetchQueryPage again.
Route all page requests for a query session to the same server instance (sticky sessions).
Track query-session liveness client-side; never reuse IDs across queries.

Example fix

// before
page, err := s.fetchQueryPage(oldSessionID, size) // after last page
// after
if queryExhausted {
    return endOfResults
}
page, err := s.fetchQueryPage(activeSessionID, size)

Defensive patterns

Strategy: try-catch

Type guard

func isQuerySessionNotFound(err error) bool {
    return err != nil && strings.HasPrefix(err.Error(), "query session not found: ")
}

Try / catch

page, err := s.fetchQueryPage(sessionID, size)
if isQuerySessionNotFound(err) {
    // restart the original query to obtain a fresh paging session
    sessionID, err = s.executeQuery(originalSQL)
    if err != nil {
        return err
    }
    page, err = s.fetchQueryPage(sessionID, size)
}

Prevention

Stop paging as soon as a page reports no further results.
Keep all page requests on the same server instance (sticky routing).
Re-issue the query rather than reusing IDs after restarts or timeouts.
Never reuse a query session ID across different queries.

When it happens

Trigger: Calling fetchQueryPage with an ID from a finished query, after the query session was closed or reaped, or on a server instance other than the one that started the query (restart, non-sticky load balancer).

Common situations: Continuing to page after consuming the last page; long gaps between pages while the in-memory paging state disappears; multiple replicas without session affinity.

Related errors

AI-assisted analysis of t8y2/dbx@c0390bff16 (2026-09-05). Data as JSON: /api/errors/3fc427c472973bc4. Report an issue: GitHub.