Papers
Topics
Authors
Recent
Search
2000 character limit reached

TEngineDB-V: An OLAP-Native Vector Search System for Large-$k$ Workloads at Tencent

Published 1 Aug 2026 in cs.DB | (2608.00650v1)

Abstract: Vector search systems are essential infrastructure for modern data-driven applications. Large-$k$ analytical vector search, which retrieves $k=103$--$105$ results for analytics (e.g., aggregation, filtering, joins), is increasingly important for emerging workloads, including LLM data management and advertising analysis at Tencent. Existing systems remain inadequate: specialized vector databases often cap $k$ (e.g., $k \leq 104$) to satisfy tail-latency constraints and offer limited analytical support, while OLAP systems typically embed per-segment vector indexes as black boxes, causing severe read/compute amplification and preventing native query optimization. This paper presents TEngineDB-V, an OLAP-native vector search system for large-$k$ workloads. TEngineDB-V makes vector search a first-class analytical primitive in Tencent's OLAP engine through a global segment-decoupled index materialized as relational tables, eliminating scatter-gather execution, reducing amplification, and enabling native storage optimizations. It decomposes IVFPQ-based search into relational operators, integrates OLAP optimizations, and introduces DPPQ, which combines direction-aware quantization with hierarchical residual refinement to improve recall while preserving relational efficiency. TEngineDB-V further incorporates index-aware query rewriting and a distributed-aware cost model for efficient distributed execution. Experiments show that TEngineDB-V achieves up to a $145\times$ speedup over competitive systems such as StarRocks, and up to a $52\times$ improvement in 10-billion-scale production deployments.

Summary

  • The paper introduces an OLAP-native vector search system that re-architects large-k workloads by decoupling vector indexing from data segmentation.
  • It presents novel indexing and quantization techniques, including DPPQ, to boost recall and reduce latency, achieving significant speedups over conventional systems.
  • Empirical results demonstrate robust scalability and practical performance gains for billion-scale datasets, validated through production deployments at Tencent.

TEngineDB-V: OLAP-Native Vector Search for Large-kk Workloads

Motivation and Problem Statement

TEngineDB-V addresses the system bottlenecks inherent in supporting large-kk (k=103k = 10^310510^5) vector search workloads within OLAP infrastructures, as observed in emerging use cases at Tencent (e.g., LLM data curation, advertising analytics, multimodal data analytics). Existing vector systems are largely optimized for latency-critical small-kk retrieval; they typically couple vector indexes per segment and treat these as black boxes within OLAP systems, leading to severe read/compute amplification and preventing native query optimization. The challenge is thus to re-architect vector search as a first-class analytical primitive, natively integrated into OLAP processing pipelines, while maintaining scalability and efficiency at billion-scale.

Architectural Innovations

TEngineDB-V implements a novel OLAP-native design rooted in two principles: segment-decoupled global indexing and table-centric index materialization.

A global, segment-decoupled IVFPQ-based index is built across the entire dataset, with centroids, codebooks, and PQ codes expressed as sharded, columnar relational tables. This eliminates the scatter–gather execution and N×kN \times k result amplification seen in segment-coupled systems, unlocking direct access to only relevant shards during query processing. All index structures participate in native storage optimizations—columnar compression, multi-tier block caching (memory/SSD/remote), and parallel I/O—allowing for high throughput even under high cardinality requests. Figure 1

Figure 1: System architecture of TEngineDB-V highlighting control, computation, and storage layers.

Compared to traditional segment-coupled paradigms, the architectural separation between data and global index allows efficient cache management, fine-grained access, and robust support for both analytical and vector workloads. Figure 2

Figure 2: Comparison between segment-coupled and segment-decoupled storage architectures.

TEngineDB-V exposes a declarative SQL interface for data, index, and hybrid analytical/vector workloads. Index refresh is handled asynchronously and atomically at the global level, ensuring OLAP consistency guarantees suitable for analytical queries.

Relational Execution Paradigm

TEngineDB-V decomposes IVFPQ vector search into relational operators, mapped over the global index tables. This enables:

  • IVF Prune: SCAN–PROJECT–TopK–JOIN to select and access relevant clusters.
  • LUT Compute: Scan the codebook, compute per-query LUTs, and aggregate to minimize memory footprint.
  • Distance Estimate: Cross-join LUTs and candidate vectors, with fused operator implementations utilizing columnar FastScan and SIMD parallelization. Figure 3

    Figure 3: Relational execution pipeline for decomposed IVFPQ search.

Such composability allows seamless fusion with analytical operations (filters, joins, and aggregates), benefits from vectorized execution and caching, and enables late materialization, all within the standard OLAP processing engine.

Enhanced Quantization: DPPQ

To address the recall limitations of standard PQ-based ANN at large kk, TEngineDB-V introduces DPPQ (Direction-aware Progressive PQ):

  • Direction-aware quantization: Prioritizes angular preservation via explicit decomposition of each subvector into a norm and a unit direction, encoding directions using PQ and reconstructing using cosine law.
  • Hierarchical residual refinement: Multi-epoch refinement recursively quantizes residuals to iteratively reduce error at each layer.

This design improves large-kk recall without incurring high cost from raw vector refinement. Figure 4

Figure 4: Recall-bit budget tradeoffs for PQ, RaBitQ, and DPPQ across datasets.

With equivalent bit budgets, DPPQ consistently outperforms both PQ and RaBitQ on recall at target kk, with minimal incremental storage overhead.

Distributed and Cost-Based Query Optimization

TEngineDB-V extends the Cascades optimizer to be index- and distribution-aware. For hybrid queries (FANNS), the optimizer enumerates eight candidate plans determined by the axes of predicate pushdown (pre- vs post-filter), join order (build/probe side), and data exchange (broadcast/shuffle). A weighted cost model jointly estimates CPU, memory, and network costs. Adaptive tuning of candidate pool sizes (KannK_{ann}) and join/build placement ensures plan selection reflects workload selectivity and cluster resource constraints. Figure 5

Figure 5: Alternative distributed execution plans for filtered ANN queries (FANNS).

Figure 6

Figure 6: Latency of eight execution plans and the cost-based plan for FANNS under varying selectivity.

This mechanism guarantees that no single execution plan is universally adopted; instead, the optimizer dynamically selects the most efficient plan per query and data characteristics, particularly critical as large-kk0 queries shift network and memory bottlenecks.

Numerical Results

Experiments on datasets spanning 1M to 10B vectors demonstrate strong scalability and numerical advantage:

  • Latency–recall trade-off: For kk1, TEngineDB-V achieves 332 ms (Wikipedia, 0.86 recall), representing a kk2–kk3 speedup versus baselines (Milvus, StarRocks, PGVector, DiskANN).
  • Scalability with kk4: As kk5 increases to kk6, TEngineDB-V outpaces all competitors, unaffected by the severe I/O and merge amplification that cripple segment-coupled or graph-based approaches.
  • FANNS: Under both low- and high-selectivity filtering, cost-based planning yields kk7–kk8 improved latency at given recall.
  • Production-scale deployment: For Tencent-Image (10 billion entries), at kk9, TEngineDB-V achieves a k=103k = 10^30–k=103k = 10^31 latency reduction for recall 0.88–0.8, with stable operation in clusters spanning 100TB and <5s query latency. Figure 7

    Figure 7: QPS comparison of mainstream vector indexes as a function of k=103k = 10^32.

    Figure 8

    Figure 8: Latency–recall trade-off for ANN workloads across representative vector search systems.

    Figure 9

    Figure 9: Latency scaling as k=103k = 10^33 increases across candidate systems.

    Figure 10

    Figure 10: FANNS latency–recall performance under different selectivities.

    Figure 11

    Figure 11: Production performance results at 10-billion scale in Tencent deployments.

Theoretical and Practical Implications

TEngineDB-V's architecture demonstrates that decoupling vector index organization from physical data layout—combined with relational expression of vector operations—enables OLAP-grade scalability for vector analytics. The composability of vector search with analytical processing permits unified optimization, paving the way for hybrid, similarity-driven, and multi-modal workloads at internet-scale. The DPPQ quantization scheme provides a practical balance between relational executability and state-of-the-art recall at constrained bit budgets.

Practically, the work suggests that future large-scale multi-modal analytics engines should move away from legacy segment-coupled and black-box index paradigms, towards native integration with analytical execution and storage. This is further supported by the observed trends: increasing complexity in similarity search (joins, aggregations) and growing demand for unified analytical and vector pipelines in modern enterprise data settings.

Conclusion

TEngineDB-V establishes a new execution and storage paradigm for large-k=103k = 10^34 vector search, treating vector similarity as a first-class analytical computation. The system’s architectural decisions—global segment-decoupled indexing, table-centric materialization, OLAP-native execution, and distributed cost-based optimization—enable robust, scalable, and efficient support for billion-scale workloads. Strong empirical and production results substantiate the claims of up to k=103k = 10^35 speedup over competitive systems and sustainable operation at 10-billion vector scale. The design principles and methods introduced in TEngineDB-V are likely to inform future developments in OLAP- and cloud-native vector data management architectures, especially in use cases combining structured and unstructured analytics at scale.

Whiteboard

Explain it Like I'm 14

TEngineDB‑V: Making “Find Similar Things” Fast When You Need A Lot of Results

What this paper is about

This paper explains how Tencent built a new database feature, called TEngineDB‑V, that can quickly find many items that are similar to something you care about. Think of looking up “the 100,000 images most like this picture” or “the 50,000 ads most similar to this user’s interests.” That’s called large‑k vector search, where k is the number of results you want. The system is designed to work inside a data warehouse (an OLAP system) so the results can be immediately analyzed, filtered, joined, and counted with regular SQL.

What questions the paper tries to answer

In simple terms, the paper asks:

  • How can we return a very large number of similar items (thousands to hundreds of thousands) quickly and reliably?
  • How can we plug this “find‑similar” step directly into a database so it plays nicely with filters, joins, and analytics?
  • How can we avoid common slowdowns, like reading too much data, merging tons of partial results, or doing wasteful extra work?
  • Can we improve accuracy (getting truly similar items) without doing a slow “double‑check” step on huge amounts of raw data?

How the system works (with everyday analogies)

Here are the main ideas, explained with simple analogies:

  • A vector is like a digital fingerprint of an item (an image, a sentence, a user). Similar items have fingerprints that point in similar directions.
  • Large‑k means you’re not asking for the top 10 matches—you might be asking for the top 10,000 or even 100,000. That changes what makes a system fast.

To make this efficient, the authors do three big things:

  1. A single global “catalog” instead of searching every room
  • Old way (segment‑coupled + scatter–gather): Imagine a bookstore split into 2,000 rooms. To find the top 100,000 similar books, you ask every room for 100,000 and then merge them all—resulting in way too much hauling and sorting.
  • New way (segment‑decoupled global index): Build one global catalog that tells you exactly which shelves to check. You go straight to the right places and avoid asking every room. This slashes reading, computing, and network traffic.
  1. Store the index as normal tables and run the search like SQL
  • Instead of hiding the index in special binary files, they store it in regular database tables:
    • A table of “clusters” (coarse groups of similar fingerprints).
    • A table of “codebooks” (small building blocks used to approximate fingerprints).
    • A table of “compressed fingerprints” (compact codes for each item).
  • Then the search itself is broken into normal SQL‑style steps (scan, join, filter, top‑K), so the database can use all its usual tricks: column compression, caching, vectorized compute, and parallel processing. It’s like turning a magic black‑box tool into Lego blocks the database already knows how to optimize.
  1. Better compression that preserves “direction” (DPPQ)
  • Basic compression (called IVFPQ) speeds things up by storing short codes instead of full fingerprints, but it can lose accuracy—especially when you need a lot of matches—so systems often do a slow “refinement” step to recheck raw data.
  • The authors introduce DPPQ, which focuses on keeping the direction of the fingerprint right (direction matters most for similarity) and then adds details in layers (like sketching an outline first and refining with shading). This “direction‑aware” and “residual refinement” approach gives more accurate scores without loading tons of full fingerprints, keeping it fast and database‑friendly.

Behind the scenes:

  • They build the global index using Spark (a system for large‑scale data processing) and refresh it in the background so online queries never pause.
  • They use a smart planner (a cost model) that weighs CPU, memory, and network to choose the best way to run each query across many machines.

What they found and why it matters

The paper reports strong speedups:

  • Up to 145× faster than competitive systems like StarRocks in tests with large‑k queries.
  • Up to 52× faster in Tencent’s real‑world deployments at 10‑billion‑item scale.
  • In production, a cluster of 30+ machines managing about 100 TB and 10 billion image fingerprints can answer top‑100,000 searches in under 5 seconds.

Why this is important:

  • New AI and analytics tasks often need big result sets, not just the top 10. For example:
    • Building training sets for image or LLMs by pulling 10,000–100,000 similar items.
    • Advertising analytics that start with a huge pool of candidates and then filter and re‑rank.
  • TEngineDB‑V keeps this practical by integrating search directly with analytics, cutting wasteful work, and improving accuracy without slow rechecks.

What this means going forward

  • For AI teams: It becomes much easier to assemble large, high‑quality datasets and analyze them with regular SQL, speeding up model development and evaluation.
  • For analytics platforms: Vector search becomes a first‑class database feature, so you can mix “find similar” with filters, joins, and aggregations efficiently at scale.
  • For system design: Treating vector indexes as tables and search as SQL‑like operators unlocks the full power of OLAP engines—better caching, compression, parallelism, and smarter query planning.

In short, TEngineDB‑V shows how to make “find a lot of similar things” both fast and accurate inside a data warehouse, which is exactly what many modern AI and analytics applications need.

Knowledge Gaps

Unresolved knowledge gaps, limitations, and open questions

The following list captures what remains missing, uncertain, or unexplored, framed to be concrete and actionable for follow-up research.

  • Incremental/global index maintenance: No mechanism for online or incremental IVFPQ/IVFDPPQ updates; explore delta indexes, per-CID incremental clustering/quantization, and online codebook adaptation to reduce rebuild cost and staleness.
  • Freshness and consistency: The eventual-consistency rebuild model can surface deleted/late-arriving records; quantify user-visible inconsistency, and design snapshot-consistent execution across base and index tables (e.g., versioned indexes, dual-read with compensation).
  • Update-heavy workloads: The system targets slow-changing analytics; characterize performance and correctness under higher update rates and evaluate designs for near-real-time ingestion.
  • Cost of rebuilds at scale: Spark-based global rebuilds are assumed feasible; provide build-time, I/O, and cost models at 10B+ scale, and study scheduling/TTL policies that co-optimize freshness, cost, and availability.
  • Sharding by cluster ID (CID) skew: Popular clusters may become hot; measure load imbalance and develop adaptive re-sharding, CID splitting/merging, and hotspot-aware scheduling.
  • FANNS selectivity estimation: Lacks a demonstrated method to estimate per-predicate selectivity within CIDs; build multi-dimensional stats (e.g., histograms per CID) to drive probe-count and join-order decisions.
  • Probe-count auto-tuning: No adaptive selection of Nprobe as a function of k, predicate selectivity, and data skew; design runtime controllers to meet recall/latency SLOs.
  • Distributed cost model validation: The CPU/memory/network cost model is not empirically validated for accuracy; quantify misprediction rates and add feedback-driven re-optimization/adaptive sampling.
  • Plan-space coverage for hybrids: Query rewriting considers limited alternatives (pre/post filtering, join direction/type); extend to top-k pushdown through joins, approximate join variants, and group-wise top-k.
  • Tail latency and multi-tenancy: Absence of tail-percentile and interference studies; design admission control, resource isolation, and cache partitioning for multi-tenant large-k workloads.
  • Failure handling mid-query: Unclear recovery semantics for spilled/fused operators and cross-node broadcasts; formalize exactly-once/at-least-once guarantees and implement partial-result re-execution.
  • Memory pressure at very large k: The fused operator and cross-join of LUTs may stress memory as k→100K+; investigate chunked/out-of-core distance evaluation and bounded-memory top-k structures.
  • Recall guarantees for DPPQ: No theoretical error/recall bounds are provided; derive approximation guarantees and sensitivity to embedding distributions, dimensions, and metric choice.
  • DPPQ parameter tuning: Guidance is missing for m, codebook sizes, number of epochs L/E, and bit budgets; develop autotuners that balance recall, storage, and CPU across datasets.
  • Storage overhead of DPPQ: Storing per-subspace magnitudes ρ(j) and multi-epoch residuals increases index size; quantify overhead and evaluate quantized/compressed ρ(j) representations.
  • Metric generality: DPPQ is derived with L2 and cosine via law of cosines; assess support/accuracy for inner-product (MIPS) and other metrics, and unify metric-specific LUT formulations.
  • Necessity of raw-vector refinement: The system avoids post-refinement, but corner cases may need it; define fallback criteria and efficient, selective refinement that preserves relational execution.
  • Interaction with OPQ/RaBitQ and other quantizers: Only DPPQ/IVFPQ are explored; assess how OPQ, IVFADC, RaBitQ, or learned quantizers can be decomposed into relational operators and their trade-offs.
  • Graph or hybrid indexes for large-k: Graphs are dismissed for large-k, but hybrid coarse (graph/IVF) plus relational fine stage might help; systematically evaluate hybrid designs under large-k.
  • Caching strategy efficacy: Fine-grained memory/SSD caches are proposed; quantify hit rates, cache contention under concurrency, and devise vector-aware cache admission/eviction policies.
  • Columnar compression impacts: Index columns (PQ codes, magnitudes) use generic encodings; benchmark alternative encodings (e.g., bitpacking for codes, delta + quantization for ρ) on I/O and CPU.
  • Snapshot-accurate late materialization: Deleted IDs returned by the index are filtered at join time, potentially shrinking results; specify mechanisms to still return exactly k results without extra probes.
  • Query concurrency and LUT broadcasts: Repeated LUT broadcasts across many concurrent queries may saturate network; study per-node LUT caching, multicast, or operator colocation strategies.
  • Heterogeneous hardware: No evaluation with GPUs/DPUs or AVX-512/AMX; explore operator fusion on GPUs, LUT construction offload, and end-to-end CPU–GPU pipelines for large-k.
  • Sparse/binary embeddings: The design assumes dense floats; assess support and performance for sparse vectors, binary codes, or mixed-precision embeddings.
  • Extreme k regimes: Behavior near very large fractions of the dataset (k→n) or very small k is not analyzed; define regime-aware plans that gracefully cross over between ANN and scan.
  • Robustness to data drift: Embedding distributions evolve; develop drift detectors and partial retraining strategies (e.g., per-CID codebook refresh) that avoid full rebuilds.
  • Statistics collection and maintenance: The optimizer needs CID distributions and predicate stats over index tables; specify stats collection frequency, overhead, and impact on plan quality.
  • Security and privacy: No discussion of encryption at rest/in flight, access control for index tables, or privacy-preserving vector search; design secure storage/execution for regulated data.
  • Reproducibility and benchmarks: Claims cite up to 145×/52× improvements without full benchmark details; release workloads, datasets (or surrogates), and configs to validate results externally.
  • Generality across modalities: Deployed on images; evaluate text, audio, video, and cross-modal embeddings with varying dimensionalities and norms.
  • Integration with downstream analytics: Large-k is motivated by analytics (aggregations/joins), but end-to-end pipelines and pushdown opportunities (e.g., approximate aggregates over similarity sets) are not characterized.
  • Operational automation: Missing SRE tooling for auto-scaling, elastic rebalancing of CID shards, and safe rollouts/rollbacks of index versions under traffic.

Practical Applications

Below is an overview of practical applications grounded in the paper’s core innovations—an OLAP-native, segment-decoupled global index materialized as tables; decomposition of IVFPQ into relational operators; the DPPQ quantization method; and index-aware distributed optimization—together with Tencent’s reported production outcomes (e.g., <5s for top-100K over ~10B vectors).

Immediate Applications

These can be deployed with today’s OLAP infrastructure, standard embedding models, and batch (asynchronous) index refresh.

  • LLM training-set retrieval and curation at scale
    • Sectors: AI/LLM, media, research labs
    • Tools/Products/Workflows: Build a global IVFDPPQ index over embeddings (e.g., CLIP, text encoders) as relational tables; run SQL hybrid queries to retrieve 10K–100K neighbors for prompt-specific dataset assembly; apply joins, aggregation, and bias/duplication checks inline; schedule daily Spark-based index rebuilds
    • Assumptions/Dependencies: Asynchronous, eventual-consistency acceptable; quality embeddings exist; OLAP cluster + remote storage; large-k latency budget (seconds)
  • Advertising analytics: creative similarity, broad candidate recall, cohort analysis
    • Sectors: AdTech/MarTech
    • Tools/Products/Workflows: Use hybrid FANNS (vector + structured predicates) to recall 2K–100K similar creatives/users; join with campaign metadata for segmentation, lift studies, A/B diagnostics; leverage late materialization and broadcast/shuffle join choices via the distributed CBO
    • Assumptions/Dependencies: Embedding quality for users/ads; compliance and access control; sustained network and SSD/memory caching
  • Offline recommendation candidate generation and evaluation
    • Sectors: E-commerce, streaming, social
    • Tools/Products/Workflows: Large-k neighbor recall per user/item for training and batch scoring; run vector-join pipelines to build training triples; aggregate item similarities for catalog structuring
    • Assumptions/Dependencies: Batch-oriented SLAs; embeddings tuned to business signals; index refresh cadence fits data drift
  • Large-scale near-duplicate detection and catalog hygiene
    • Sectors: Media libraries, e-commerce product catalogs, UGC platforms
    • Tools/Products/Workflows: Periodic jobs retrieving large neighborhoods; group-by over vector IDs to identify duplicate/near-duplicate clusters; SQL-based triage policies (e.g., by source, time)
    • Assumptions/Dependencies: Vector quality for perceptual similarity; storage for neighbor lists; tolerant to eventual consistency
  • Content moderation triage by similarity neighborhoods
    • Sectors: Trust & Safety, social platforms
    • Tools/Products/Workflows: Pull 10K+ nearest neighbors for a flagged asset; apply rule-based filters (region, time) and joins with enforcement logs; build reviewer queues
    • Assumptions/Dependencies: Legal/compliance review; embedding models robust to adversarial content
  • Enterprise semantic search analytics and vector-based joins
    • Sectors: Software, knowledge management, support operations
    • Tools/Products/Workflows: SQL-driven “semantic joins” between document corpora, FAQs, tickets; vector search as a first-class operator enables cost-based decisions (pre/post-filtering, join direction); late materialization reduces payload I/O
    • Assumptions/Dependencies: Consistent embedding dimensions and distance metric; entity IDs aligned for joins
  • Financial risk and fraud analytics via neighborhood exploration
    • Sectors: Finance, fintech, payments
    • Tools/Products/Workflows: Retrieve large-k neighborhoods of transaction embeddings for ring detection; perform vector-augmented cohort stats; join with KYC and geospatial attributes
    • Assumptions/Dependencies: Secure deployment; well-calibrated embeddings; explainability requirements for policy audits
  • Healthcare research: imaging cohort selection and retrospective studies
    • Sectors: Healthcare research, medical imaging
    • Tools/Products/Workflows: Offline cohorts via similarity to exemplars (e.g., pathology patterns); apply strict structured filters (modality, date, IRB constraints); compute distributional summaries
    • Assumptions/Dependencies: PHI governance; batch SLAs; embeddings from validated medical models
  • Media retrieval and creative search workbenches
    • Sectors: Media/entertainment, design, game studios
    • Tools/Products/Workflows: Creative workbench to fetch 10K–100K nearest assets by style/content; inline aggregation (e.g., by author, time) to explore distributions
    • Assumptions/Dependencies: Good multimodal embeddings; storage and caching sized for bursty exploration
  • Developer-facing Vector OLAP service (internal platform or product)
    • Sectors: Data platforms, cloud providers, enterprise IT
    • Tools/Products/Workflows: Offer a SQL dialect with CREATE GLOBAL INDEX USING VECTOR; provide SLAs for large-k analytics; expose cost-based plan introspection; integrate index-aware rewriting and table-centric caching
    • Assumptions/Dependencies: Ops maturity to run multi-tier cache and Spark-based index builds; user education for hybrid query patterns
  • Cost and energy savings by shifting from graph indexes to IVFDPPQ for analytical workloads
    • Sectors: Infra/Ops across industries
    • Tools/Products/Workflows: Migrate large-k analytics from per-segment HNSW to segment-decoupled table-based IVFDPPQ; exploit operator fusion, FastScan, and runtime filters; measure QPS/latency and footprint
    • Assumptions/Dependencies: Workloads are large-k and analytical; acceptance of approximate search with DPPQ; ability to rebuild global index

Long-Term Applications

These benefit from further research in incremental updates, federated operation, learned optimization, or vendor ecosystem adoption.

  • Near-real-time global index maintenance and streaming refresh
    • Sectors: All data-intensive platforms
    • Tools/Products/Workflows: Log-structured, incremental global index updates; streaming Spark/Flink pipelines; background shadow index with micro-swaps
    • Assumptions/Dependencies: New algorithms for consistent, low-latency global updates; write amplification control
  • Federated and privacy-preserving large-k analytics
    • Sectors: Healthcare, finance, public sector
    • Tools/Products/Workflows: Cross-silo vector search with secure enclaves or MPC; encrypted LUT computations; audit trails from table-materialized indexes
    • Assumptions/Dependencies: Practical crypto for approximate distance; acceptable accuracy–overhead trade-offs; regulatory alignment
  • Standardization of OLAP-native vector search in cloud warehouses
    • Sectors: Cloud data platforms (Snowflake, BigQuery, Redshift, etc.)
    • Tools/Products/Workflows: Native table-backed vector indexes, cost-aware planners, and SQL primitives for vector joins and large-k retrieval; marketplace connectors for embeddings
    • Assumptions/Dependencies: Vendor adoption; query optimizer exposure to index internals; shared statistics formats
  • Learned cost models and self-tuning query rewriting for hybrid workloads
    • Sectors: Data platforms, enterprise analytics
    • Tools/Products/Workflows: ML-driven CBO leveraging telemetry to predict CPU/memory/network costs; automated toggling of pre/post-filtering, probe counts, and join strategies
    • Assumptions/Dependencies: Robust feedback loops; drift-aware model training; guardrails for worst-case behavior
  • Multimodal DPPQ variants and new distance regimes
    • Sectors: Vision, audio, geospatial, bioinformatics
    • Tools/Products/Workflows: DPPQ extensions for cosine/IP and domain-specific metrics; adaptive per-subspace bit allocation; residual learning with light-weight codebooks
    • Assumptions/Dependencies: Training pipelines for codebooks per modality; benchmarking across tasks
  • Cross-warehouse, cross-region semantic joins and analytics
    • Sectors: Global retail, logistics, advertising
    • Tools/Products/Workflows: Table-centric indexes replicated across regions; WAN-aware CBO; partial result federation for large-k merges
    • Assumptions/Dependencies: Network-aware scheduling; governance and data residency controls
  • RAG and synthetic data generation with very large retrieval sets
    • Sectors: AI/LLM apps, enterprise knowledge management
    • Tools/Products/Workflows: Retrieve 50K–200K candidate passages/images for distillation, synthetic augmentation, or linting; pipeline orchestration integrated with Vector OLAP
    • Assumptions/Dependencies: LLM context constraints mitigated by chunking and re-ranking; cost budgets for oversized retrieval
  • Edge-aware hierarchical vector caches
    • Sectors: Retail, robotics, IoT analytics
    • Tools/Products/Workflows: Push top clusters and codebooks to edge nodes; perform local IVF prune + partial DPPQ; aggregate to central OLAP for large-k consolidation
    • Assumptions/Dependencies: Model–data drift management; constrained memory/compute at the edge
  • Data governance, auditability, and policy frameworks for vector analytics
    • Sectors: Public sector, regulated industries
    • Tools/Products/Workflows: Policy that indexes be table-materialized for lineage and access control; auditable SQL plans for vector queries; energy-efficiency reporting when replacing graph indexes
    • Assumptions/Dependencies: Standards and certification; integration with existing catalog/lineage tools
  • End-to-end vector ETL in SQL (embedding creation, versioning, and lifecycle)
    • Sectors: Enterprise data engineering
    • Tools/Products/Workflows: Managed UDF/UDAFs for embedding generation; versioned global indexes; “time-travel” vector analytics
    • Assumptions/Dependencies: Secure, scalable model inference in-warehouse; metadata/versioning conventions

Notes on feasibility and dependencies across applications:

  • Embedding quality and stability dominate recall and business utility; domain-tuned models are often necessary.
  • The paper’s asynchronous global index rebuild implies eventual consistency; real-time or high-churn OLTP use cases require further R&D.
  • DPPQ assumes PQ-friendly metrics (L2/IP) and benefits from late materialization and operator fusion; performance relies on SIMD and columnar execution.
  • Accurate cost modeling depends on reliable statistics (cluster/cardinality distributions) and network/CPU telemetry.
  • Governance, privacy, and explainability must be addressed when using vector similarity in regulated settings.

Glossary

  • ANNS: Approximate k-nearest neighbor search that returns near-top-k vectors with reduced computation. "Approximate kk-Nearest Neighbor Search (ANNS), which retrieves the top-kk most similar vectors from a large-scale dataset,"
  • Atomic swap: A mechanism to replace artifacts atomically without downtime. "apply the new index through an atomic swap."
  • Bloom filters: Probabilistic data structures for set membership that allow false positives. "auxiliary indexes (ZoneMap, Bloom filters, etc.)"
  • Broadcast join: A distributed join strategy that replicates a small table to all workers. "broadcast join vs.\ shuffle join"
  • Cardinality estimation: Predicting the number of rows produced by an operation. "cardinality estimation (lack visibility into cluster distributions)"
  • Columnar compression: Compression techniques applied per column to reduce I/O. "mature OLAP optimizations, e.g., columnar compression and vectorized execution,"
  • Cost-based optimizer (CBO): An optimizer that chooses plans by estimating and minimizing cost. "performs both rule-based and cost-based optimizations (RBO and CBO)"
  • Curse of dimensionality: Phenomenon where high dimensionality makes exact search computationally prohibitive. "In high-dimensional spaces, exact kkNNS is computationally prohibitive due to the curse of dimensionality~\cite{HNSW}."
  • Direction-aware quantization: Quantization that prioritizes preserving vector directions to improve similarity ranking. "direction-aware quantization (preserves directional fidelity to stabilize similarity ranking)"
  • Disaggregated storage paradigm: Architecture separating compute, control, and storage services. "a cloud-native multi-modal data warehouse adopting a disaggregated storage paradigm"
  • Distributed-aware cost model: Planning model that jointly accounts for CPU, memory, and network costs in distributed settings. "A distributed-aware cost model further evaluates these plans by jointly modeling CPU, memory, and network costs."
  • DPPQ: Directional Progressive Product Quantization improving recall without expensive refinement. "introduces DPPQ, which combines direction-aware quantization with hierarchical residual refinement to improve recall while preserving relational efficiency."
  • Eventual consistency: Model where updates become visible after some delay, not immediately. "TEngineDB-V adopts an eventual consistency model: during the refresh interval, the index may lag behind the base table (e.g., deleted IDs may still appear, and newly inserted vectors are not visible until the next rebuild)."
  • FANNS: Filtered ANNS that applies attribute predicates alongside vector similarity. "Filtered Approximate Nearest Neighbor Search (FANNS) augments ANNS with attribute predicates evaluated alongside vector similarity~\cite{Mesh, liang2024unify, ADBV, SeRF}."
  • FastScan: SIMD-friendly PQ-scoring technique used to accelerate distance computation. "Columnar FastScan, which aligns FastScan with the engine’s columnar layout to maximize SIMD efficiency;"
  • Fine-grained caching: Caching at small data granularity to reduce unnecessary I/O. "fine-grained caching (cache granularity in index file level rather than individual clusters),"
  • Global segment-decoupled index: A single global index spanning all segments, not tied to any specific segment. "a global segment-decoupled index materialized as relational tables"
  • Hash-bucketed sharding: Partitioning where data is assigned to shards via a hash of a key. "Each partition is then hash-bucketed into shards."
  • Hierarchical residual refinement: Multi-stage residual encoding to iteratively reduce quantization error. "hierarchical residual refinement (progressively captures finer-grained directional components to mitigate quantization error)"
  • HNSW: A graph-based ANN index (Hierarchical Navigable Small World) optimized for small-k queries. "Most systems rely on graph-based indexes (e.g., HNSW~\cite{HNSW}) for efficient small-kk retrieval."
  • I/O pruning: Avoiding reads of irrelevant data based on selective access. "I/O pruning (fail to access specific clusters on disk selectively)"
  • Index-aware query rewriting: Rewriting queries to expose index semantics for the optimizer. "we design an index-aware query rewriting module that injects vector index semantics into the relational optimizer and enumerates logically equivalent plans."
  • Inverted File (IVF): A coarse quantization structure partitioning vectors into clusters for probing. "an IVF centroid table, storing cluster identifiers (CIDs) and their centroids for cluster probing, sharded by CID;"
  • Inverted-list scanning: Scanning the candidate vectors within selected IVF lists. "parallelize key operations (e.g., inverted-list scanning, LUT construction, and distance computation)"
  • IVFDPPQ: IVF combined with DPPQ for higher-accuracy distance estimation. "Algorithm~\ref{alg:dppq} describes the construction of IVFDPPQ, consisting of a coarse clustering phase followed by multi-epoch residual encoding."
  • IVFPQ: IVF with Product Quantization for efficient ANN search. "IVFPQ~\cite{pq} is one of the most widely adopted indexing structures for large-scale ANNS."
  • K-means clustering: Algorithm that partitions vectors into k clusters via centroid minimization. "IVFPQ uses kk-means clustering~\cite{K-means} to partition vectors into kk clusters"
  • kNNS: Exact k-nearest neighbor search returning the true top-k neighbors. "Given a dataset X={x1,,xn}RdX = \{\mathbf{x}_1, \dots, \mathbf{x}_n\} \subset \mathbb{R}^d and a query vector qRd\mathbf{q} \in \mathbb{R}^d, kk-nearest neighbor search (kkNNS) returns a subset SkXS_k \subset X"
  • Late materialization: Deferring payload fetch until after vector-ID selection to cut I/O. "Late Materialization, which separates similarity computation from payload retrieval via a join operation;"
  • Law of cosines: Formula used to reconstruct Euclidean distance from norms and dot products. "The Euclidean distance is then reconstructed via the law of cosines by combining the approximated dot product with the precomputed norms of the query and base vectors:"
  • Lookup table (LUT): Precomputed table of subspace distances used to accelerate PQ scoring. "For each subspace, a lookup table (LUT) is constructed by computing the squared distances between qiq_i and all CC centroids."
  • Materialized view: A precomputed view that can be refreshed asynchronously. "A similar approach can also be found in the materialized view refresh mechanisms of open-source OLAP systems like Doris~\cite{doris} and StarRocks~\cite{starrocks}, as well as in commercial products such as Snowflake~\cite{snowflake}."
  • MVCC: Multi-Version Concurrency Control for versioned, immutable ingestion batches. "Within each shard, rowsets represent immutable, atomic ingestion batches tagged with monotonic version numbers for MVCC; each rowset comprises one or more segments."
  • OLAP: Online Analytical Processing systems designed for analytical workloads. "built on the production-grade OLAP system TEngineDB deployed at Tencent."
  • OLAP-native vector search: Vector search integrated as a first-class analytical primitive in an OLAP engine. "This paper presents TEngineDB-V, an OLAP-native vector search system for large-kk workloads."
  • Operator Fusion: Combining operators into one to reduce overhead and leverage SIMD. "Operator Fusion, which merges several operators into a single SIMD-optimized physical operator."
  • Product Quantization (PQ): Technique that quantizes vector subspaces to speed distance computation. "To further accelerate distance computation within each cluster, Product Quantization (PQ) is applied to encode the vectors."
  • PQ codebook: The set of centroids per subspace used to encode vectors under PQ. "a PQ codebook table, maintaining subspace codebooks and not sharded;"
  • QPS: Queries per second; a throughput metric for search systems. "QPS comparison of vector indexes under varying kk."
  • Quantization error: Error introduced by representing vectors with quantized codes. "To reduce quantization error, we develop DPPQ,"
  • RaBitQ: A quantization approach that competes with PQ variants. "RaBitQ~\cite{RaBitQ, RaBitQ2} is another quantization approach with strong empirical performance,"
  • Rule-based optimizer (RBO): An optimizer using transformation rules rather than cost models. "performs both rule-based and cost-based optimizations (RBO and CBO)"
  • Residual quantization: Encoding the residual between the vector and its approximation to refine accuracy. "employs a hierarchical residual quantization scheme that progressively refines the directional component."
  • Run-length encoding (RLE): Compression that stores repeated values as counts. "flexible encoding (dictionary, bit-shuffle, RLE, etc.)"
  • Runtime Filters: Dynamically generated filters to prune data at sources during query execution. "Runtime Filters, which prune irrelevant data at the source to reduce I/O and network traffic;"
  • Scatter--gather execution: Strategy that queries all partitions and merges partial results centrally. "eliminating scatter--gather execution,"
  • Segment-coupled indexing: Per-segment indexes tightly bound to data segments. "We refer to this design as segment-coupled indexing."
  • Segment-decoupled indexing: A globally organized index independent of data segments. "This architecture is termed as segment-decoupled indexing,"
  • SIMD: Single Instruction, Multiple Data parallelism used for vectorized computation. "to maximize SIMD efficiency"
  • Shuffle join: A distributed join strategy that redistributes data across nodes by join keys. "broadcast join vs.\ shuffle join"
  • Tail-latency: High-percentile latency that systems try to keep within bounds. "specialized vector databases often cap kk (e.g., k104k \leq 10^4) to satisfy tail-latency constraints"
  • Table-centric index storage: Storing index structures as relational tables for native engine optimizations. "TEngineDB-V adopts a table-centric index storage design, in which the global index is materialized as relational tables and sharded across segments"
  • Vectorized execution: Processing data in columnar batches to exploit CPU caches and SIMD. "mature OLAP optimizations, e.g., columnar compression and vectorized execution,"

Open Problems

We haven't generated a list of open problems mentioned in this paper yet.

Collections

Sign up for free to add this paper to one or more collections.

Tweets

Sign up for free to view the 5 tweets with 3182 likes about this paper.