Pith. sign in

REVIEW 3 major objections 4 minor 39 references

This paper shows that FSST's greedy encoding and symbol selection are suboptimal, and that replacing them with a dynamic-programming encoder plus improved table construction raises average compression factors by 7.3% over FSST and 17.0% ove

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

OptFSST lifts FSST's average compression factor by 7.3% and FSST12's by 17.0% across 92 string columns using DP encoding, triple counting, and pruning; it also proves the symbol-table selection problem is NP-hard when the alphabet is part of the input.

T0 review reviewed 2026-08-02 challenge →

load-bearing objection The core result — DP-based encoding plus count3 and pruning gives 7.3%/17% average compression-factor gains on FSST/FSST12 — is plausible and honestly evaluated; the main blemish is the under-specified benchmark-filtering rule, which needs pinning down before those averages are reproducible. the 3 major comments →

arxiv 2607.11271 v2 pith:Y3MHW7JQ submitted 2026-07-13 cs.DB

OptFSST: Optimized FSST String Compression

Hedi Chehaidar , Mihail Stoian , Moritz Stargalla , Andreas Kipf This is my paper
classification cs.DB
keywords FSSTstring compressiondynamic programmingsymbol tablerandom accesscolumnar storageNP-hardnesscompression factor
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

FSST compresses database strings by replacing frequent byte sequences with one-byte codes in a static symbol table, but its greedy longest-match encoding and greedy symbol selection leave compression on the table. This paper introduces OptFSST, which computes the optimal encoding for a given symbol table using a dynamic-programming recurrence, and improves symbol-table construction with a triple-frequency counter and a pruning step. It also proves that finding an optimal symbol table is NP-hard when the alphabet is part of the input, justifying heuristic table construction. On 92 real-world string columns, OptFSST improves average compression factors by 7.3% over FSST and 17.0% over FSST12 while preserving fine-grained random access, and OptFSST12 decompresses 1.2x faster on average. The cost is a 2-4x slowdown in compression and table-construction time, which the paper argues is worthwhile because compression is paid once while decompression is on the query path.

Core claim

For a fixed symbol table T, the minimum compressed size of a string s satisfies the recurrence dp[i] = min(2 + dp[i+1], 1 + min_{s[i:j] in T} dp[j]), and OptFSST computes it with a trie walk, storing dp_choice to emit the optimal segmentation. This replaces FSST's greedy longest-match encoder. For table construction, OptFSST adds count3 triple counting to expose longer recurring symbols earlier and prunes overlapping candidates' counts so redundant symbols do not waste limited table entries. The paper proves that STS_l, selecting a dictionary of length-at-most-l symbols minimizing total encoded cost, is NP-hard for every fixed l >= 2 when the alphabet is part of the input, motivating these h

What carries the argument

The central mechanism is the DP recurrence with a trie-backed lookup: from each input position the encoder either escapes one byte (cost 2) or emits a table symbol matching the prefix (cost 1), choosing the minimum suffix cost. Because candidate symbols are stored in a trie, the DP enumerates only actually matching symbols up to the maximum symbol length, and the dp_choice array turns the cost table into an encoding. Supporting mechanisms are the third frequency counter count3, which packs three 9-bit codes into a 32-bit hash key to discover triples of consecutive emitted symbols, and pruning, which subtracts a selected concatenated symbol's count from its component symbols and pairs before

Load-bearing premise

The headline averages depend on a filtering rule that removes columns where dictionary encoding beats FSST, and the exact rule is not disclosed; if that selection were different, the improvement numbers could change materially.

What would settle it

Run OptFSST and FSST on a large unfiltered set of string columns, including dictionary-friendly columns, with identical training settings for both, and compute the mean compression-factor improvement; if the mean falls below a few percent or many columns regress, the claimed 7.3%/17.0% averages are an artifact of the benchmark filter. A second check: hold the symbol table fixed and compare DP encoding to greedy longest-match encoding on every string; if DP never improves on greedy, the central recurrence is not carrying the gain.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • Systems that already store FSST-compressed columns can adopt OptFSST without changing the decompression format or the random-access property, because the compressed representation is unchanged.
  • Gains in compression factor translate directly into smaller memory footprints and lower memory-bandwidth pressure per scan, which matters when analytical workloads are cache- and bandwidth-bound.
  • OptFSST12's 1.2x decompression-speed gain means queries reading compressed string columns can get faster, not just smaller.
  • The NP-hardness result for STS_l implies no polynomial-time optimal table construction exists for variable alphabet size, so the heuristic components are necessary rather than incidental.
  • The per-column variation (89% of columns improve for OptFSST, 95% for OptFSST12) indicates the method helps most columns while a minority stay near parity or regress, so users should expect workload-dependent gains.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Combining OptFSST with prefix-extraction layout schemes could compound the two sources of redundancy (cross-string prefixes and intra-string symbols); the paper notes the schemes are complementary but does not measure the combination.
  • The DP encoder is branch-heavy and parallelizable per string; the paper's hint about DPX-style instructions suggests a GPU implementation could substantially cut the reported compression-time cost, but this is untested.
  • The fixed-alphabet polynomial result in Appendix B points to a pragmatic test: on low-cardinality alphabets, a near-optimal table search may be feasible and could outperform the heuristics on those columns.
  • The benchmark filters out dictionary-encodable columns, so the 7.3%/17.0% averages describe the gain on columns where FSST is the right tool; on an unfiltered fleet of string columns the headline averages would likely be lower.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper presents OptFSST and OptFSST12, modifications of the FSST and FSST12 string compressors. OptFSST replaces FSST's greedy longest-match encoder with a dynamic program that finds the minimum-cost segmentation of each string for a fixed symbol table, using cost 1 for a symbol and cost 2 for an escaped byte (Section 3.1). It also adds a third frequency counter for triples of emitted symbols during table construction and a pruning rule that corrects stale gains of overlapping candidates (Sections 3.2 and 3.3). The paper proves that the underlying symbol-table selection problem STS_l is NP-hard for every fixed l>=2 when the alphabet is part of the input (Section 4, Appendix A). The evaluation on 92 real-world string columns reports average compression-factor improvements of 7.3% over FSST and 17.0% over FSST12, with a 3-4x compression-time slowdown, preserved decompression speed for OptFSST, and 1.2x better decompression speed for OptFSST12.

Significance. The DP-based encoding is a principled and clean improvement over greedy encoding for a fixed symbol table, and the NP-hardness proof in Appendix A is a solid justification for the heuristic table construction; I verified the reduction's main accounting and found no flaw. The evaluation is unusually honest for this area: it ablates each component separately, discloses tested-and-abandoned variants, and explains the OptFSST12 0.39x outlier. If the empirical claims survive a well-specified benchmark population, this is a useful incremental contribution for systems that use FSST-style random-access string compression. The main risk is not algorithmic but methodological: the headline averages depend on a benchmark-selection rule that is not operationalized in the manuscript.

major comments (3)
  1. [Section 5.1] The headline averages (7.3% and 17.0% in Section 5.2) are computed over a set of 92 columns whose selection is not reproducible. Section 5.1 states only that columns 'compressed better using dictionary encoding are filtered out' and that columns with fewer than 1000 strings are dropped. This leaves the central exclusion rule undefined: which dictionary encoder, compared by compression factor or size, with what threshold, and applied to what units? The per-dataset counts (23+22+31+13+3=92) exactly sum to the final total, making it unclear whether any columns were excluded and from which corpora. I request the exact selection rule, the number of excluded columns per source, the full column list in the artifact, and a sensitivity analysis around the dictionary-encoding filter. Without this, the average improvements and the 82/92 and 87/92 column counts are not independently verifiable.
  2. [Sections 3.1 and 5.2] The compression-factor metric is not defined, and the role of the symbol-table size is ambiguous. The DP recurrence in Section 3.1 minimizes only the encoded payload (1 byte per symbol, 2 per escaped byte). However, the Section 5.4 discussion of the OptFSST12 min 0.39x result says the 4096-entry symbol table's 'serialization alone exceeds twice the input size and dominates the reported compression factor', implying the reported compression factor includes the serialized symbol table. If so, the DP objective is not the reported objective, and a heuristic table construction can outweigh the DP gain on small columns. Please state the exact formula for compression factor, specify whether symbol-table bytes are included for all codecs, and report table sizes for baseline and OptFSST variants. This is needed to interpret the headline improvements and the outlier.
  3. [Section 5.2] The pruning component is retained even though its aggregate effect is reported as neutral ('no noticeable effect' on the mean) and the ablation shows it can hurt in a minority of columns. This is a defensible design choice given the majority-of-columns benefit, but the paper should quantify the distribution rather than only report the mean and best cases: e.g., how often does pruning degrade the compression factor and by how much? Since pruning is one of the three named contributions, a fuller characterization would strengthen the claim that it is a useful correction rather than a heuristic kept on the basis of the majority count.
minor comments (4)
  1. [Section 2] The citation 'GPU-aware FSST adaptation [5?]' contains an unresolved question mark and should be corrected to a proper reference.
  2. [Section 3.1] The tie-breaking rule 'prefer longer symbols on equal DP cost' is presented as improving compression factors. Because all ties have the same output cost for the final encoding, the effect must come from the training loop's frequency counts; this should be stated explicitly so readers do not infer that the tie-break improves the DP optimum.
  3. [Section 5.1] The paper does not state which FSST/FSST12 version or parameter settings (sample size, number of generations, candidate budget) are used for the baseline. Please add the exact version and default parameters, or state that the released defaults are used.
  4. [Section 5.3] Table 1 reports end-to-end slowdowns, but the text in Section 5.3 gives only average compression speeds. It would be useful to report the median as well, since the violin plots show skewed distributions.

Circularity Check

0 steps flagged

No circularity found: DP optimality is a direct exact algorithm, NP-hardness proof is self-contained, and evaluation uses independent baselines.

full rationale

The paper's central claims are not circular. The DP recurrence in §3.1, dp[i] = min(2 + dp[i+1], 1 + min_{s[i:j] in T} dp[j]), is an exact optimal-substructure formulation under the FSST cost model (one byte per symbol, two bytes per escaped character); it is not a fitted parameter or a renamed prediction. The NP-hardness result in §4/Appendix A is proved by a self-contained reduction from Maximum Vertex Coverage on bipartite graphs, citing an external source [6], and the proof's forward and reverse directions are arithmetically checked. Symbol-table heuristics (third frequency counter, pruning) are presented as engineering improvements with ablations, not as predictions derived from the benchmark data. The evaluation compares against the independent cwida/fsst baseline and FSST12, and the ablation study isolates each contribution. No load-bearing self-citation exists: the present authors' prior work appears only as general background (e.g., [30]) and not as justification for core claims. The benchmark filtering rule in §5.1 ('Columns that are compressed better using dictionary encoding are filtered out') is under-specified and could affect reproducibility of the headline averages, but this is a sample-selection/measurement concern, not circularity in the sense of a result reducing to its inputs by construction. The disclosed outlier (OptFSST12 min 0.39, §5.4) is an honest limitation and does not indicate circularity.

Axiom & Free-Parameter Ledger

3 free parameters · 3 axioms · 0 invented entities

The empirical claims rest on two inherited design anchors (FSST's format/cost model and FSST's gain heuristic) and one discretionary population choice (the column filter). No numbers appear to be fit to the 92-column benchmark to produce the claimed averages; the only tuned variant (adaptive DP threshold) was tested, found neutral, and dropped (§3.1). The NP-hardness theorem contributes a new result but pulls as an axiom the NP-hardness of bipartite maximum vertex coverage.

free parameters (3)
  • DP tie-break: prefer longest symbol on equal cost = 'longest wins' via '<=' at Listing 1, line 29
    Chosen because 'Experiments showed that preferring longer symbols... yields better overall compression factors' (§3.1). A hand-tuned policy; it does not change cost optimality but changes frequency signals during table construction.
  • Candidate gain heuristic = gain = length x observed frequency
    Inherited from FSST (§3.2) and used to rank count1/count2/count3 candidates; a modeling choice not fitted against the benchmark set.
  • Training sample size / generation count = not stated
    Table construction repeatedly compresses 'a sample' (§3.1, §3.2); sample size and number of generations come from the FSST baseline and are never given, leaving a hidden knob for replication and influencing which symbols are found.
axioms (3)
  • standard math Maximum vertex coverage on bipartite graphs is NP-hard [6].
    Reduction seed for Theorem 1 (Appendix A); the paper cites Apollonio and Simeone for this.
  • domain assumption FSST format abstraction: a dictionary phrase costs 1 output byte, an escaped literal costs 2; symbols have length <= l (8 or 12); table size bounded by 255/4095.
    Problem 1 and the §3.1 recurrence restate these as the cost model; DP optimality holds only within this model.
  • domain assumption Benchmark columns are representative of FSST's deployment population after exclusions.
    §5.1 and §5.4; the 'compressed better using dictionary encoding' filter is discretionary and its details are unpublished.

reviewed 2026-08-02 · how reviews work

0 comments
Cite this review

Pith. "Pith review of OptFSST: Optimized FSST String Compression." pith.science (2026). https://pith.science/paper/Y3MHW7JQ

@misc{pith2026260711271,
  author       = {Pith},
  title        = {Pith review of: OptFSST: Optimized FSST String Compression},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/Y3MHW7JQ}},
  note         = {Machine review of arXiv:2607.11271}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Strings account for a substantial fraction of data in modern analytical systems, making lightweight compression with fast random access an important building block for efficient query processing. Fast Static Symbol Table (FSST) addresses this need by replacing frequent byte sequences with compact codes while preserving independent decompression of individual strings. However, FSST's compression effectiveness is limited by its greedy symbol selection and greedy encoding strategy, leaving encoding gains on the table. We present OptFSST, an optimized FSST variant that improves its compression factors while preserving its static-symbol-table design and random-access decompression. OptFSST optimally encodes the text using dynamic programming given a symbol table. Additionally, we show that a generalized version of the symbol-table selection problem is NP-hard when the alphabet is part of the input, motivating heuristic table construction for field-level compressors. Hence, we add in OptFSST (i) an additional frequency counter that accelerates the discovery of longer symbols and (ii) a pruning strategy that removes redundant and conflicting symbol candidates during table construction. We also extend the same techniques to FSST12, yielding OptFSST12. Our evaluation on 92 real-world string datasets shows that OptFSST improves the compression factors of FSST and FSST12 by up to 47.7% and 91.5%, with an average improvement of 7.3% and 17.0%, respectively, while retaining the fine-grained random-access properties. Notably, OptFSST12 improves FSST12's decompression speed by $1.2\times$ on average.

Figures

Figures reproduced from arXiv: 2607.11271 by Andreas Kipf, Hedi Chehaidar, Mihail Stoian, Moritz Stargalla.

Figure 1
Figure 1. Figure 1: Example where FSST’s greedy longest-match encod￾ing is suboptimal. OptFSST yields the optimal compressed size given the symbol table. enterprise applications. Studies of production analytical workloads and classic column-store systems show that strings can represent a substantial part of stored data and can dominate memory con￾sumption in compressed columnar layouts [1, 9, 30]. Consequently, effective stri… view at source ↗
Figure 2
Figure 2. Figure 2: Dynamic-programming-based encoding example. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Example of symbol selection without pruning. The [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Compression-factor improvement over the corresponding baseline. The dashed red line marks parity with [PITH_FULL_IMAGE:figures/full_fig_p007_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Runtime comparison. Compression speed measures only final corpus compression after the symbol table has been [PITH_FULL_IMAGE:figures/full_fig_p008_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Speedup of corpus compression after the trie tra [PITH_FULL_IMAGE:figures/full_fig_p009_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: In the reduction, each graph edge (𝑢, 𝑣) becomes the string gadget 𝑥𝑢𝑧 (ℓ−1)𝑦𝑣 . If 𝑢 ∈ 𝑈 , we add the length-ℓ string 𝑥𝑢𝑧 (ℓ−1) to the dictionary 𝐷 (and similarly 𝑣 ∈ 𝑈 ⇔ 𝑧 (ℓ−1)𝑦𝑣 ∈ 𝐷), which lowers the encoding cost of the edge gadget from 3 to 2. Proof. Let (T, 𝐾, 𝐵) be an instance over an alphabet Σ, where both ℓ and 𝑛 := |Σ| are fixed. Let 𝑆 := Ðℓ 𝑖=1 Σ 𝑖 be the set of all strings over Σ of length at… view at source ↗

Review history (2 revisions) →

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

39 extracted references · 4 canonical work pages · 1 internal anchor

  1. [1]

    Abadi, Samuel Madden, and Nabil Hachem

    Daniel J. Abadi, Samuel Madden, and Nabil Hachem. 2008. Column-stores vs. row-stores: how different are they really?. InProceedings of the ACM SIGMOD International Conference on Management of Data, SIGMOD 2008, Vancouver, BC, Canada, June 10-12, 2008, Jason Tsong-Li Wang (Ed.). ACM, 967–980. https: //doi.org/10.1145/1376616.1376712

    arXiv 2008

  2. [2]

    Azim Afroozeh and Peter Boncz. 2025. The FastLanes File Format.Proc. VLDB Endow.18, 11 (2025), 4629–4643. https://doi.org/10.14778/3749646.3749718

    arXiv 2025

  3. [3]

    Azim Afroozeh, Lotte Felius, and Peter Boncz. 2024. Accelerating GPU Data Processing using FastLanes Compression. In20th International Workshop on Data Management on New Hardware (DaMoN). ACM. https://doi.org/10.1145/3662010. 3663450

    work page doi:10.1145/3662010 2024

  4. [4]

    2025.FSST+: Enhancing String Compression Through Common Prefix Extraction

    Yan Lanna Alexandre. 2025.FSST+: Enhancing String Compression Through Common Prefix Extraction. Master’s thesis. Vrije Universiteit Amsterdam and Universiteit van Amsterdam, Amsterdam, The Netherlands

    2025

  5. [5]

    Peter Hofstee

    Tim Anema, Joost Hoozemans, Zaid Al-Ars, and H. Peter Hofstee. 2025. High Throughput GPU-Accelerated FSST String Compression. In16th International Workshop on Accelerating Analytics and Data Management Systems Using Modern Processor and Storage Architectures (ADMS)

    2025

  6. [6]

    Nicola Apollonio and Bruno Simeone. 2014. The maximum vertex coverage problem on bipartite graphs.Discret. Appl. Math.165 (2014), 37–48. https: //doi.org/10.1016/J.DAM.2013.05.015

    work page doi:10.1016/j.dam.2013.05.015 2014

  7. [7]

    Peter Boncz. 2020. cwida/fsst. https://github.com/cwida/fsst. Original release: 2020-03-03. Accessed: 2026-01-10

    2020

  8. [8]

    Peter Boncz, Thomas Neumann, and Viktor Leis. 2020. FSST: Fast Random Access String Compression.Proc. VLDB Endow.13, 11 (2020), 2649–2661. http: //www.vldb.org/pvldb/vol13/p2649-boncz.pdf

    2020

  9. [9]

    Boncz and Martin L

    Peter A. Boncz and Martin L. Kersten. 1995. Monet: An Impressionist Sketch of an Advanced Database System. InProceedings of the IEEE BIWIT Workshop. San Sebastian, Spain, 240–251

    1995

  10. [10]

    Tijmen Bruineman. 2025. [Compression] Introduce DICT_FSST Compression Method. https://github.com/duckdb/duckdb/pull/15637. Accessed: 2026-01-23

    2025

  11. [11]

    ClickHouse. 2022. ClickBench. https://github.com/ClickHouse/ClickBench. Original release: 2022-07-11. Accessed: 2026-01-23

    2022

  12. [12]

    Yann Collet. 2011. LZ4. https://github.com/lz4/lz4. Original release: 2011-03-25. Accessed: 2026-01-10

    2011

  13. [13]

    dtim-upc. 2021. NextiaJD. https://github.com/dtim-upc/NextiaJD. Original release: 2021-05-17. Accessed: 2026-01-23

    2021

  14. [14]

    Facebook. 2015. Zstandard. https://github.com/facebook/zstd. Original release: 2015-01-24. Accessed: 2026-01-10

    2015

  15. [15]

    Francesco Gargiulo and Rossano Venturini. 2025. OnPair: Short Strings Com- pression for Fast Random Access.CoRRabs/2508.02280 (2025). https://doi.org/ 10.48550/ARXIV.2508.02280 arXiv:2508.02280

    work page internal anchor Pith review Pith/arXiv arXiv doi:10.48550/arxiv.2508.02280 2025

  16. [16]

    Bogdan Ghita, Peter Boncz, and Duarte Tomé. 2019. Public BI Benchmark – Part

    2019

  17. [17]

    Accessed: 2026-01-23

    https://zenodo.org/records/6277287. Accessed: 2026-01-23

    arXiv 2026

  18. [18]

    Google. 2011. snappy. https://github.com/google/snappy. Original release: 2011-03-07. Accessed: 2026-05-13

    2011

  19. [19]

    Paul Groß, Daniel ten Wolde, and Peter Boncz. 2019. Adaptive Factorization Using Linear-Chained Hash Tables. (2019)

    2019

  20. [20]

    Nakandala, Dalitso Banda, Rathijit Sen, Karla Saur, Kwanghyun Park, Carlo Curino, Jesús Camacho-Rodríguez, Konstantinos Karana- sos, and Matteo Interlandi

    Dong He, Supun C. Nakandala, Dalitso Banda, Rathijit Sen, Karla Saur, Kwanghyun Park, Carlo Curino, Jesús Camacho-Rodríguez, Konstantinos Karana- sos, and Matteo Interlandi. 2022. Query Processing on Tensor Computa- tion Runtimes.Proceedings of the VLDB Endowment15, 11 (2022), 2811–2825. https://doi.org/10.14778/3551793.3551833

    arXiv 2022

  21. [21]

    Sven Hepkema, Azim Afroozeh, Charlotte Felius, Peter Boncz, and Stefan Mane- gold. 2025. G-ALP: Rethinking Light-weight Encodings for GPUs. In21st In- ternational Workshop on Data Management on New Hardware (DaMoN). ACM. https://doi.org/10.1145/3736227.3736242

    arXiv 2025

  22. [22]

    Holloway, Vijayshankar Raman, Garret Swart, and David J

    Allison L. Holloway, Vijayshankar Raman, Garret Swart, and David J. DeWitt

  23. [23]

    Violeta Kastreva, Philip Whittington, Dennis Komm, and Tiago Pimentel. 2026. Tokenisation over Bounded Alphabets is Hard. InThe Fourteenth International Conference on Learning Representations. https://openreview.net/forum?id= Xhf9YqwlM4

    2026

  24. [24]

    Matteo Interlandi, Nicolas Bruno, Brandon Haynes, Carlo Curino, Rathijit Sen, Yinan Li, et al. 2026. CoddSpeed: Hardware Accelerated Query Processing in Microsoft Fabric. InCompanion of the International Conference on Management of Data. ACM, 359–372. https://doi.org/10.1145/3788853.3803077

    arXiv 2026

  25. [25]

    Harald Lang, Tobias Mühlbauer, Florian Funke, Peter Boncz, Thomas Neumann, and Alfons Kemper. 2016. Data Blocks: Hybrid OLTP and OLAP on Compressed 10 Storage using both Vectorization and Compilation. InProceedings of the 2016 International Conference on Management of Data, SIGMOD Conference 2016, San Francisco, CA, USA, June 26 - July 01, 2016, Fatma Özc...

    arXiv 2016

  26. [26]

    Maximilian Kuschewski, David Sauerwein, Adnan Alhomssi, and Viktor Leis

  27. [27]

    2024.NVIDIA Blackwell Architecture Technical Brief

    NVIDIA Corporation. 2024.NVIDIA Blackwell Architecture Technical Brief. https: //resources.nvidia.com/l/en-us-blackwell-architecture

    2024

  28. [28]

    Wesley Pace, Chen She, Lei Xu, et al. 2025. Lance: Efficient Random Access in Columnar Storage through Adaptive Structural Encodings.CoRRabs/2504.15247 (2025). https://doi.org/10.48550/arXiv.2504.15247 arXiv:2504.15247

    Pith/arXiv arXiv doi:10.48550/arxiv.2504.15247 2025

  29. [29]

    Jigao Luo, Qi Chen, and Carsten Binnig. 2026. Do GPUs Really Need New Tabular File Formats?. In22nd International Workshop on Data Management on New Hardware (DaMoN). ACM. https://doi.org/10.1145/3789237.3809125

    arXiv 2026

  30. [30]

    Alexander van Renen, Dominik Horn, Pascal Pfeil, Kapil Vaidya, Wenjian Dong, Murali Narayanaswamy, Zhengchun Liu, Gaurav Saxena, Andreas Kipf, and Tim Kraska. 2024. Why TPC Is Not Enough: An Analysis of the Amazon Redshift Fleet.Proc. VLDB Endow.17, 11 (2024), 3694–3706. https://doi.org/10.14778/ 3681954.3682031

    arXiv 2024

  31. [31]

    Vortex Team. 2026. vortex-data/vortex: An Extensible, State-of-the-Art Columnar File Format. https://github.com/vortex-data/vortex. Accessed: 2026-02-12

    2026

  32. [32]

    Attaluri, Ronald Barber, Naresh Chainani, David Kalmuk, Vincent KulandaiSamy, Jens Leenstra, Sam Lightstone, Shaorong Liu, Guy M

    Vijayshankar Raman, Gopi K. Attaluri, Ronald Barber, Naresh Chainani, David Kalmuk, Vincent KulandaiSamy, Jens Leenstra, Sam Lightstone, Shaorong Liu, Guy M. Lohman, Tim Malkemus, René Müller, Ippokratis Pandis, Berni Schiefer, David Sharpe, Richard Sidle, Adam J. Storm, and Liping Zhang. 2013. DB2 with BLU Acceleration: So Much More than Just a Column St...

    arXiv 2013

  33. [33]

    Bowen Wu, Wei Cui, Carlo Curino, Matteo Interlandi, and Rathijit Sen. 2025. Terabyte-Scale Analytics in the Blink of an Eye.Proc. VLDB Endow.19, 2 (2025), 141–155. https://www.vldb.org/pvldb/vol19/p141-sen.pdf

    2025

  34. [34]

    Patel, Andrew Pavlo, and Huanchen Zhang

    Xinyu Zeng, Ruijun Meng, Martin Prammer, Wes McKinney, Jignesh M. Patel, Andrew Pavlo, and Huanchen Zhang. 2025. F3: The Open-Source Data File Format for the Future.Proc. ACM Manag. Data3, 4 (2025), 245:1–245:27. https: //doi.org/10.1145/3749163

    work page doi:10.1145/3749163 2025

  35. [35]

    Philip Whittington, Gregor Bachmann, and Tiago Pimentel. 2026. Tokenisation is NP-Complete. InTokenization Workshop. https://openreview.net/forum?id= zGMXftuVZz

    2026

  36. [36]

    Marcin Zukowski, Sándor Héman, Niels Nes, and Peter Boncz. 2006. Super- Scalar RAM-CPU Cache Compression. InProceedings of the 22nd International Conference on Data Engineering, ICDE 2006, 3-8 April 2006, Atlanta, GA, USA, Ling Liu, Andreas Reuter, Kyu-Young Whang, and Jianjun Zhang (Eds.). IEEE Computer Society, 59. https://doi.org/10.1109/ICDE.2006.150 ...

    doi:10.1109/icde.2006.150 2006

  37. [38]

    Jacob Ziv and Abraham Lempel. 1977. A universal algorithm for sequential data compression.IEEE Trans. Inf. Theory23, 3 (1977), 337–343. https://doi.org/10. 1109/TIT.1977.1055714

    arXiv 1977

  38. [2007]

    InProceedings of the ACM SIGMOD International Conference on Management of Data, Beijing, China, June 12-14, 2007, Chee Yong Chan, Beng Chin Ooi, and Aoying Zhou (Eds.)

    How to barter bits for chronons: compression and bandwidth trade offs for database scans. InProceedings of the ACM SIGMOD International Conference on Management of Data, Beijing, China, June 12-14, 2007, Chee Yong Chan, Beng Chin Ooi, and Aoying Zhou (Eds.). ACM, 389–400. https://doi.org/10.1145/1247480. 1247525

    doi:10.1145/1247480 2007

  39. [2023]

    ACM Manag

    BtrBlocks: Efficient Columnar Compression for Data Lakes.Proc. ACM Manag. Data1, 2 (2023), 118:1–118:26. https://doi.org/10.1145/3589263

    doi:10.1145/3589263 2023

This paper was first reviewed by deepseek-v4-flash on August 2, 2026.