Function loadSubset

packages/powersync-db-collection/src/powersync.ts:524–590

(
          options?: LoadSubsetOptions,
        )

        const activeWhereExpressions: Array<LoadSubsetOptions['where']> = []

        const loadSubset = async (
          options?: LoadSubsetOptions,
        ): Promise<void> => {
          if (options) {
            activeWhereExpressions.push(options.where)
            onUnloadSubset = await restConfig.onLoadSubset?.(options)
          }

          if (activeWhereExpressions.length === 0) {
            await database.writeLock(async (ctx) => {
              await flushDiffRecordsWithContext(ctx)
              await disposeTracking?.({ context: ctx })
            })
            return
          }

          const combinedWhere =
            activeWhereExpressions.length === 1
              ? activeWhereExpressions[0]
              : or(
                  activeWhereExpressions[0],
                  activeWhereExpressions[1],
                  ...activeWhereExpressions.slice(2),
                )

          const compiledNewData = compileSQLite(
            { where: combinedWhere },
            { jsonColumn: 'NEW.data' },
          )

          const compiledOldData = compileSQLite(
            { where: combinedWhere },
            { jsonColumn: 'OLD.data' },
          )

          const compiledView = compileSQLite({ where: combinedWhere })

          const newDataWhenClause = toInlinedWhereClause(compiledNewData)
          const oldDataWhenClause = toInlinedWhereClause(compiledOldData)
          const viewWhereClause = toInlinedWhereClause(compiledView)

          await database.writeLock(async (ctx) => {
            await flushDiffRecordsWithContext(ctx)
            await disposeTracking?.({ context: ctx })

            disposeTracking = await createDiffTrigger({
              setupContext: ctx,
              when: {
                [DiffTriggerOperation.INSERT]: newDataWhenClause,
                [DiffTriggerOperation.UPDATE]: `(${newDataWhenClause}) OR (${oldDataWhenClause})`,
                [DiffTriggerOperation.DELETE]: oldDataWhenClause,
              },
              writeType: (rowId: string) =>
                collection.has(rowId) ? `update` : `insert`,
              batchQuery: (
                lockContext: LockContext,
                batchSize: number,
                cursor: number,