Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

Joined-filter window hangs in `drainNoInputContinuations` when a boundary-tie load answers synchronously

Abierto Apto para principiantes
  • ¿Algo no está bien?
#2,241 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 1 día

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
2/5
Tiempo estimado
1-3 horas
Aptitud para principiantes
78/100
Tipo de issue
Error
Claridad
Bien especificado
Estado de actividad
Activo
Stack tecnológico
typescript
Área
backend, databases, testing-qa

Línea de trabajo

Empieza por drainNoInputContinuations y runContinuation en el código de continuación de consultas; después, revisa la compuerta del filtro unido que reanuda el trabajo en etapas una vez que terminan las cargas unidas. Añade una prueba de regresión basada en tests/query/joined-filter-sync-tie.test.ts para una carga de tie síncrona y una carga unida asíncrona. El objetivo se cumple cuando la ventana termina con las 5 filas y la prueba pasa.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

On 0.15.2, an ordered, limited window with one LEFT join and a filter on the joined side never settles under this sequence:

  1. The source answers a page asynchronously, but its boundary-tie load (no limit) synchronously with true, from rows it already holds.
  2. The joined side answers asynchronously.

drainNoInputContinuations consumes the staged more continuation. runContinuation sees hasPendingJoinedWork() and re-stages the same continuation. Nothing has changed (no graph input, nothing pending), so the while condition still holds and the loop spins synchronously. The joined load can never settle, and the page hangs at 100% CPU.

Repro (plain collections, no custom options): a 30-row items collection left-joined to owners, where(eq(owner.active, true)), orderBy(rank desc), limit(5). items.loadSubset resolves pages after setTimeout and answers limit-less tie loads synchronously. owners.loadSubset resolves after setTimeout. The test below hangs on 0.15.2.

Fix: stop draining when a consumed continuation re-stages itself. The joined work's settlement already resumes it through the joined-filter gate.

const continuation = this.stagedContinuation
this.consumeStagedContinuation()
if (this.stagedContinuation === continuation) break

With it, the repro settles with the full 5-row window, and the full @tanstack/db suite passes. Happy to open a PR.

Repro test (tests/query/joined-filter-sync-tie.test.ts) 
import { expect, it } from 'vitest'
import { createCollection } from '../../src/collection/index.js'
import { BTreeIndex } from '../../src/index.js'
import { createLiveQueryCollection } from '../../src/query/live-query-collection.js'
import { eq } from '../../src/query/builder/functions.js'
import { compileSingleRowExpression } from '../../src/query/compiler/evaluators.js'
import type { LoadSubsetOptions } from '../../src/types.js'

type Item = { id: string; rank: number; ownerId: string }
type Owner = { id: string; active: boolean }

it(`settles a joined-filter window whose tie load answers synchronously`, async () => {
  const items: Array<Item> = Array.from({ length: 30 }, (_, n) => ({
    id: `i${String(n).padStart(2, `0`)}`,
    rank: 100 - n,
    ownerId: `o${n}`,
  }))
  const owners: Array<Owner> = items.map((item, n) => ({
    id: item.ownerId,
    active: n % 3 !== 0,
  }))
  const delivered = new Set<string>()
  const itemCollection = createCollection<Item>({
    id: `loop-items`,
    getKey: (row) => row.id,
    syncMode: `on-demand`,
    startSync: true,
    autoIndex: `eager`,
    defaultIndexType: BTreeIndex,
    sync: {
      sync: ({ begin, write, commit, markReady }) => {
        markReady()
        return {
          loadSubset: (options: LoadSubsetOptions) => {
            const where = options.where
              ? compileSingleRowExpression(options.where)
              : undefined
            const from = options.cursor
              ? compileSingleRowExpression(options.cursor.whereFrom)
              : undefined
            const offset = from ? 0 : (options.offset ?? 0)
            const rows = items
              .filter((row) => (where ? where(row) === true : true))
              .filter((row) => (from ? from(row) === true : true))
              .sort((a, b) => b.rank - a.rank)
              .slice(
                offset,
                options.limit === undefined
                  ? undefined
                  : offset + options.limit,
              )
            const answer = () => {
              begin()
              for (const row of rows) {
                if (delivered.has(row.id)) continue
                delivered.add(row.id)
                write({ type: `insert`, value: { ...row } })
              }
              return commit()
            }
            // A page goes over the wire; its boundary ties are rows it holds.
            if (options.limit === undefined) return answer()
            return new Promise<void>((resolve) =>
              setTimeout(() => {
                const receipt = answer()
                void (receipt === true ? resolve() : receipt.then(resolve))
              }, 1),
            )
          },
        }
      },
    },
  })
  const ownerCollection = createCollection<Owner>({
    id: `loop-owners`,
    getKey: (row) => row.id,
    syncMode: `on-demand`,
    startSync: true,
    autoIndex: `eager`,
    defaultIndexType: BTreeIndex,
    sync: {
      sync: ({ begin, write, commit, markReady }) => {
        markReady()
        return {
          loadSubset: (options: LoadSubsetOptions) =>
            new Promise<void>((resolve) =>
              setTimeout(() => {
                const where = options.where
                  ? compileSingleRowExpression(options.where)
                  : undefined
                begin()
                for (const row of owners)
                  if (!where || where(row) === true)
                    write({ type: `insert`, value: { ...row } })
                const receipt = commit()
                void (receipt === true ? resolve() : receipt.then(resolve))
              }, 1),
            ),
        }
      },
    },
  })
  const live = createLiveQueryCollection({
    query: (q) =>
      q
        .from({ item: itemCollection })
        .leftJoin({ owner: ownerCollection }, ({ item, owner }) =>
          eq(item.ownerId, owner.id),
        )
        .where(({ owner }) => eq(owner.active, true))
        .orderBy(({ item }) => item.rank, `desc`)
        .limit(5)
        .select(({ item }) => ({ id: item.id })),
  })
  await live.preload()
  await new Promise((resolve) => setTimeout(resolve, 30))
  expect(live.size).toBe(5)
  await live.cleanup()
})
Lenguaje dominante
TypeScript
Estrellas
4k
Forks
277
Merge medio
18 h 7 min
PR fusionados (30 d)
228

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de TanStack/db

Todos los issues de TanStack/db

Issues similares

Más issues de TypeScript

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.