Search arXiv⌕ Search
Home/Archive/arXiv

arXiv · 2610.37256

Fast Approximate Line Nearest Neighbor Search

Jiadong Xie·Jeffrey Xu Yu·Yingfan Liu
View original source ↗Read source document ↗Export metadata ↓

Abstract

Approximate nearest neighbor (ANN) search, which retrieves vectors close to a given query vector, is a fundamental operation in vector databases. However, emerging applications, such as selecting source images for photo-based animation and video synthesis, may require matching content while allowing a query-specified aspect contrast, such as an illumination change, to vary; a single query point does not directly express this requirement. In this paper, we study approximate line nearest neighbor (LANN) search, where an infinite query line removes the distance contribution along a specified direction while database records remain points. Prior approaches focus on top-$1$ search only for LANN and can incur high construction costs. Converting LANN into ordinary point ANN search through dimension lifting substantially increases index construction and query costs, while direct search on a proximity graph built for ordinary point ANN search can miss distinct regions close to a line. To address these issues, we propose LinePG, which enhances an existing proximity graph with pair edges to facilitate navigation between separated near-line regions. To find these pair edges efficiently, we first generate region pairs with spatial or graph separation, and near a line. We then score edges between the selected region pairs to guide the point endpoint selections. We conduct extensive performance studies and confirm the accuracy and efficiency of LinePG in comparison with the baseline approaches.

Explore related subjects

cs.DB

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Jiadong Xie, Jeffrey Xu Yu, Yingfan Liu. 2026-10-27. Fast Approximate Line Nearest Neighbor Search. https://arxiv.org/abs/2610.37256

Cite the original work for its findings. Save a collection to share your selection of sources.

KEEP EXPLORING

Related papers

arXiv2026

Synchronized Rebuilds:The Hidden Cost of Concurrent Inserts in Learned Indexes

Nine years after learned indexes were proposed, their advantage on read-mostly data is well established, and a standard benchmark rates their best concurrent version as almost ready for use. Across more than 4000 runs of 13 indexes, we find that each design pays for concurrent inserts in a different way. Gapped-array indexes rebuild their nodes in synchronized bursts, at positions that follow from three constants in the source. Model-placement indexes use three to four times the memory, buffered indexes take two to three times as long. Three of five concurrent learned indexes lost keys or stopped making progress. Standard benchmarks miss both the bursts and the lost keys. The bursts cost far more than in B-trees because each rebuild copies a node a thousand times larger than a page and, under concurrency, blocks every operation that reaches the node. The typical B-tree fix of randomizing node density only spreads the bursts out, while smaller nodes trade them for longer run times at scale. Two standard systems techniques remove them: a buffer that exists only while a node is rebuilt, and background rebuilds. We show that on 400M real keys, these techniques reduce the number of inserts whose latency exceeds 100$μ$s by two orders of magnitude at one thread, and by one at sixteen when spare cores run the background threads, at a third to half the run time of the buffered designs.

cs.DB↗
arXiv2026

Back to the Future: The Evolving Universal Relation Model

Document backed analytics need databases that can be built as queries arrive. Enterprises increasingly ask analytical queries over messy document collections such as contracts, invoices, reports, emails, policies, and tickets, where the relevant structure and facts are often not known in advance. RAG can retrieve and summarize supporting evidence, but it does not by itself produce reusable, joinable, governed database state. Schema first construction offers the opposite strength: once a database is built, it supports joins, aggregation, constraints, indexes, optimization, and transactions. Yet for document analytics, fixing the schema and extracting all possible fields upfront is both expensive and brittle, because later queries and new documents often surface concepts that were not modeled before. We propose the Evolving Universal Relation Model (EUR), a query first model for document backed analytics. Users ask natural language queries as if the document corpus exposed one conceptual relation over application concepts. Internally, the DBMS turns each query into controlled database evolution: it updates the logical schema when new concepts are needed, extracts and integrates the facts required to answer the query, and decides what durable database state should remain for future queries. Thus, in EUR, a query is not only evaluated; it also helps construct the database. Document backed analytics becomes query first universal access plus workload-driven database schema and instance evolution.

cs.DB↗
arXiv2026

VIREL: Route-Local Lattice Residual Compression for Exact and Error-Bounded Floating-Point Time Series

Time-series databases store floating-point columns in independent pages that are written at ingest, rewritten at compaction, and decoded on every scan. Some columns must return the stored IEEE 754 word; others accept a pointwise bound $\varepsilon$. Codecs for both contracts turn each value into an integer on a lattice, but a real page mixes decimal resolutions. Keeping one scale per block charges every coarse step for the finest value: one scale-6 reading in a 1,024-value page cuts Falcon's compression ratio by 36%. We present VIREL, route-local lattice residual compression. A value enters a lattice only after the encoder has replayed the decoder's arithmetic on it. VIREL-Exact replays the decoder's division at each value's least decimal scale, which we prove always succeeds below $2^{51}$, gives every resolution its own lane and history, and places averages on a rational lattice; the same finer value costs it 0.6%. VIREL-EB replays a fused multiply-add on an error lattice, so every admitted value decodes within $\varepsilon$. One integer coder serves both contracts. On 14 canonical streams, VIREL-Exact emits 27.6% fewer bytes than Falcon. Fast beats ALP on ratio and both speeds at once: 7.01$\times$ against 4.19$\times$, 476 against 120 MB/s, and 5.0 against 4.5 GB/s on one core. Upper is the smallest output on all 48 larger streams. Ingest with Fast and compaction with Upper store those streams in Apache TsFile at 48.7% of ALP's bytes. VIREL-EB beats Machete on ratio and both speeds in all 90 dataset-bound cells.

cs.DB↗