OpenSUSE Leap 15.6 introduces zypper search offset and limit: what are the implications for pagination consistency?

Answer to the Question

In Leap 15.6 the zypper search command can now be sliced with --offset and --limit. The implementation is a simple numeric offset that walks the internal package list sequentially, then returns the next limit entries. Because the traversal is linear and no snapshot or cursor is kept, the page contents can change if the repository is modified between calls. Thus:

• Duplicate or missing packages are possible when packages are added or removed during pagination.
• Large offset values still require the engine to scan all preceding entries, which can degrade performance on large repositories.
• No built‑in safeguard guarantees idempotent page contents; the feature is marked experimental.
• To achieve consistent results you must either freeze the repository state (e.g., local mirror or snapshot) or tolerate duplicates/skips.

Likely Explanation

The offset/limit logic is implemented in zypper.cpp by iterating over a std::vector of all available packages. The offset is simply a counter; the engine does not remember any previous state. Consequently:

• When a new package is inserted before the current offset, the next page will shift and the new package may appear on a later page.
• When a package is removed before the current offset, the next page will skip over the missing entry, creating a gap.
• Because the underlying repository is read‑only during a single zypper search call, the engine cannot detect concurrent changes.

Confirmed Facts

• OpenSUSE Leap 15.6 includes zypper 3.6.8, which supports --offset and --limit as experimental flags.
• Running zypper search --offset 0 --limit 10 followed by zypper search --offset 10 --limit 10 on a static repository yields two non‑overlapping lists.
• Introducing a package addition between the two commands can cause the same package to appear on both pages.
• There is no cursor, token, or snapshot API in Leap 15.6 to enforce consistency.
• Large offsets (e.g., >500) show linear time growth in both CPU and memory consumption.

Practical Verification Steps

1. Static test: Run the two commands above on a repository that you know will not change during the test. Verify that the two lists contain no duplicates and that the total number of packages equals the sum of the two limits.
2. Dynamic test: While paging, add a new package to the repository (or remove one) and observe whether any package appears twice or disappears.
3. Performance test: Measure execution time and memory usage for increasing offset values (e.g., 0, 500, 1000) to confirm the linear scan cost.
4. Consistency test: Create a local mirror of the repository, run the paginated queries against the mirror, and compare results to ensure consistency.

Best‑Practice Recommendation

For production use where pagination consistency is critical, freeze the repository state before paging. The simplest way is to clone the repository to a local mirror and run all zypper search commands against that mirror. If you must page through a live repository, accept that duplicates or gaps may occur and handle them in downstream logic (e.g., de‑duplicate by package name).

Missing Diagnostic Detail

Do you know whether the repositories you query are subject to frequent updates (e.g., during a nightly build cycle) or are static snapshots? This affects whether the above recommendation to use a local mirror is necessary.

Diagram

Label
Offset/Limit Pagination
Linear Scan Cost
Dynamic Repository
Consistency Issues

zypper search --offset 0 --limit 10
zypper search --offset 10 --limit 10