Pith. sign in

REVIEW 3 major objections 5 minor 33 references

Computing the Non-Dominated Flexible Skyline in Vertically Distributed Datasets with No Random Access

T0 review · 3 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read This paper introduces an algorithm that computes the non-dominated flexible skyline when only sorted access is available, and proves it correct and instance-optimal among no-random-access algorithms.

desk verdict First NRA algorithm for NDk is a sensible extension of the classical threshold pattern, but the unbounded R+ domain leaves wb/bb undefined and breaks the early-exit claim; fixable, but must be addressed. read the letter →

arxiv 2412.15468 v1 pith:XZ3AI7M3 submitted 2024-12-20 cs.DB

Davide Martinenghi This is my paper · ORCID
classification cs.DB
keywords non-dominatedflexibleskylinetop-kquerynorandomaccessverticallydistributeddatamiddlewarescenarioinstanceoptimality
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

This paper asks whether the non-k-dominated flexible skyline (NDk), a hybrid of top-k and skyline queries, can be computed when data is vertically distributed across ranked lists and only sorted access is available. It answers yes: the proposed two-phase algorithm reads the lists from top to bottom, first collecting candidates until k seen tuples F-dominate the threshold point, then shrinking the buffer until only tuples F-dominated by fewer than k others remain. The paper proves the algorithm correct and shows it is instance optimal over all correct no-random-access, no-wild-guess algorithms, with an optimality ratio equal to the number of ranked lists. This matters because random access may be impossible or too costly in privacy-sensitive, streamed, or externally hosted datasets, where the classical NRA top-k approach already applies but no NRA method existed for flexible skylines.

What carries the argument

The load-bearing device is the threshold point τ, the tuple formed by the last score read on each ranked list: because lists are sorted, no unseen tuple can beat τ on any attribute. Alongside τ the algorithm maintains, for every partially seen tuple, a worst bound and a best bound built from the best or worst possible completion of its unseen attributes. The growing phase stops when k tuples' worst bounds F-dominate τ; the shrinking phase repeatedly removes tuples F-dominated by k others and keeps digging deeper only when at least k surviving tuples could still F-dominate a candidate. F-dominance testing itself is treated as a black box.

What would settle it

Fix d=2 and a known NDk instance, run Algorithm 1 and any candidate correct no-random-access, no-wild-guess algorithm, and compare their depths per list: if a competitor ever reads on the shorter list less than half of Algorithm 1's reads there while remaining correct, Theorem 3's optimality ratio d=2 is violated.

Watch

Extended reading notes

Core claim

The central claim is that Algorithm 1 computes NDk(r;F) exactly in the middleware scenario when random access is unavailable, and that among all correct algorithms that only use sorted access and never guess unseen tuples it is instance optimal for the sum-of-depths cost measure, with optimality ratio d, the number of ranked lists (Theorems 2 and 3). The algorithm's stopping rule is that once k seen tuples F-dominate the threshold point—the virtual tuple of last-seen values on every list—no unseen tuple can enter the result, so the shrinking phase only needs to eliminate F-dominated candidates already in the buffer.

Load-bearing premise

The load-bearing premise is that every attribute has a known finite upper bound, so the worst possible completion of a partially seen tuple is a finite tuple usable in F-dominance comparisons; the paper defines attribute domains as unbounded non-negative reals and never states this requirement.

Editorial extensions

If this is right

  • A correct and instance-optimal NRA method now exists for NDk, so applications with only sorted access can run flexible-skyline-style preference queries without random access.
  • The optimality ratio d confirms that any correct no-random-access, no-wild-guess competitor can save at most a factor of d in sorted-access depth; no such algorithm can be asymptotically better.
  • For uniformly distributed data the experiments show early exit at a depth that grows sublinearly with dataset size, so the algorithm is practical in that regime.
  • Batching sorted accesses (parameter µ) trades a small depth increase for a large reduction in F-dominance tests, giving a tunable cost balance.
  • The algorithm inherits the known curse of dimensionality: with anticorrelated data or higher dimensions, NRA-type early exit degrades toward a full scan, limiting the operator's no-random-access usefulness to low-dimensional, non-anticorrelated settings.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Implicit in the proofs but never stated: the early-exit guarantee presupposes a known finite upper bound on each attribute, so that the worst possible completion of a partially seen tuple is a finite tuple; over unbounded R+ domains the growing-phase stopping condition may never fire before a full scan.
  • A natural extension the author does not explore is adaptive batching, where the check frequency µ is chosen during execution on the basis of observed dominance density, potentially preserving more of the depth advantage while keeping F-dominance tests low.
  • The same two-phase threshold argument should transfer to other flexible-skyline variants such as POk, which the paper names as future work, and likely to any operator whose output can be characterized by F-dominance by k tuples.
  • The depth-optimality result is about sorted accesses, not about F-dominance tests; total time may still be dominated by the quadratic shrinking phase, so the practical bottleneck is test count rather than I/O.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 5 minor

Summary. The paper studies the non-k-dominated flexible skyline (NDk) in vertically distributed ("middleware") datasets where only sorted access is available. It proposes Algorithm 1 with a growing phase that accumulates candidate tuples until k seen tuples have worst-case completions F-dominating the threshold point, followed by a shrinking phase that removes tuples F-dominated by k others and decides whether further sorted accesses are needed. The paper claims Theorem 2 (correctness) and Theorem 3 (instance optimality with ratio d over all no-wild-guess, no-random-access algorithms), and reports experiments on synthetic and real (NBA) data varying size, dimensionality, k, constraint spread, and batch size.

Significance. If the central claims were fully established, this would be a valuable contribution: it is, to the author's knowledge, the first NRA-style algorithm for the NDk operator, and it cleanly separates the F-dominance test as a black box from the access strategy, reusing prior results [8,9,10]. The experimental study is broad and honestly reports adverse cases (ANT distributions, high d, full-spread constraints) where early exit collapses. The instance-optimality target is the right notion for this setting. However, the formal development currently leaves three load-bearing gaps—the unbounded-domain treatment of worst completions, the unspecified shrinking-phase removal/output-completeness rule, and the unproved bound on shrinking-phase depth in Theorem 3—so the claimed correctness and optimality are not yet established.

major comments (3)
  1. [Section 2; Algorithm 1, Lines 7 and 15] Section 2 fixes attribute domains as R+ with no upper bound, but Algorithm 1 relies on wb(t) and bb(t) for partially seen tuples, which the text defines only as "the best or worst still possible" completion of unseen attributes. Over R+ the worst possible completion of an unseen attribute is unbounded; if it is represented as infinity, then Line 7's test wb(t) ≺F τ is never true for finite τ and Line 15's test bb(t) ⊀F wb(s) is always false (since every finite bb dominates an infinite wb), so the growing phase never stops early and the shrinking phase treats every partial tuple as possibly dominated, i.e., the claimed early exit degenerates to a full scan. The paper needs an explicit bounded-domain or known-maximum-per-attribute assumption and a formal definition of wb and bb; this is load-bearing for Theorems 2 and 3 and for the experimental early-exit results.
  2. [Algorithm 1, Lines 10-21; Theorem 2] The shrinking phase is underspecified for partial tuples. Line 11 says "remove from B tuples F-dominated by other k tuples" but does not say how F-dominance is decided when the dominating or dominated tuples are only partially seen; if removal is based on optimistic completions it can remove a tuple that is not actually dominated, and if it is based only on fully seen tuples the proof must say so. Moreover, the algorithm can stop deepening while a tuple s in B is still partial (the Line 17 condition can fail even when s has unseen attributes, e.g., with k=1 and all other tuples provably non-dominators), so `return B` at Line 21 can output tuples whose attribute values are unknown, and no random access is available to complete them. A precise removal rule and a final completion phase are needed before Theorem 2 can be considered proved.
  3. [Theorem 3 proof] The instance-optimality proof only bounds the growing phase. It shows that Algorithm 1's growing phase stops by the time it reaches depth δ = max_i δ_i on all lists, and then concludes sumDepths(Algorithm 1,I) ≤ δ·d. But sumDepths is defined over all accesses until the solution is returned, and the shrinking phase (Lines 10-20) may perform additional sorted accesses—indeed the experiments in Section 4 measure a separate shrinking-phase depth that is sometimes larger than the growing-phase depth (e.g., Figure 8a). The proof gives no bound on these extra accesses, so Theorem 3's claimed optimality ratio d for total cost is not established. The proof also silently treats the virtual threshold tuple τA as if correctness of A on the actual instance implies that τA is F-dominated by k seen result tuples; this needs the standard adversarial-instance argument and a justification that those k result tuples are fully seen.
minor comments (5)
  1. [Section 3, first paragraph] "shrinking phrase" should be "shrinking phase".
  2. [Algorithm 1, Line 6] "for t in seen tuples" should be "for t in B" (or "seen tuples" should be defined), otherwise the iteration is ambiguous after tuples are removed in the shrinking phase.
  3. [Figure 5 caption] "Output siez" should be "Output size".
  4. [Section 4 headings] The headings "V arying" should be "Varying" (e.g., "Varying the dataset size N").
  5. [Section 3] The symbols wb(t) and bb(t) should be defined formally in the preliminaries or at the start of Section 3, with an explicit statement of what "worst still possible" means when the domain is unbounded; the current prose definition is insufficient for the pseudocode.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: the NRA computation of NDk is derived directly from the definitions, and F-dominance testing is delegated as an external black box rather than being fitted or reused as the target result.

full rationale

The paper's central claims are Theorem 2, stating that Algorithm 1 correctly computes NDk, and Theorem 3, stating instance optimality over no-random-access, no-wild-guess algorithms. Both proofs are self-contained: Theorem 2 reasons from the threshold point tau and the definition of F-dominance in Definition 3, while Theorem 3 compares any correct algorithm's halting depth with the depth needed for k seen tuples to F-dominate the threshold, using only the no-wild-guess assumption and monotonicity. No parameter is fitted to data, and no quantity called a prediction is derived from an input that already contains it. The algorithm does invoke the author's earlier work [8,9,10] for testing F-dominance, but explicitly as a black box: the paper states 'our focus here is not on efficiently checking F-dominance, which is used in Algorithm 1 as a black box.' This is legitimate modular reuse, not self-referential derivation, because the correctness of the access pattern does not reduce to the oracle's output being the NDk result. The only notable weakness is a modeling gap, not circularity: attributes are declared to range over unbounded R+, while the worst-bound comparisons used in Lines 7 and 15 require a finite upper bound per attribute for the 'worst still possible' completion to be a finite tuple; without such a bound, the early-exit conditions would not fire as described. That issue concerns the validity of the formal model, not an equivalence between inputs and outputs, so it does not raise the circularity score.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The algorithm relies on standard NRA assumptions about sorted lists and monotone scoring, plus an unstated finite-domain assumption for worst bounds. It also delegates F-dominance testing to prior work. No free parameters are fitted, and no new theoretical entities are introduced.

assumptions (4)
  • domain assumption Tuple attribute values range over R+ and scoring functions are monotone; lower values are preferred without loss of generality.
    Defined in Section 2 Preliminaries; the NRA bounds and F-dominance rely on monotonicity and the cost-minimization convention.
  • domain assumption Vertically distributed lists r_i are sorted ascending on attribute A_i, and sorted access reads them one row at a time from the top.
    Section 2 describes the middleware scenario; the threshold argument that unseen tuples are bounded by the last seen values depends on this ordering.
  • domain assumption F-dominance testing for arbitrary sets of monotone scoring functions is available as a correct black box from the author's prior work [8,9,10].
    Section 3 explicitly states F-dominance checking is out of scope and used as a black box; the central algorithm inherits correctness of those tests.
  • ad hoc to paper A finite upper bound per attribute is known so that the worst possible completion of a partially seen tuple is a finite tuple in R+.
    Not stated in the paper. The stopping condition at Line 7 requires wb(t) to F-dominate the threshold; with unbounded R+ the worst bound is infinite, making early exit impossible unless tuples are fully seen on all lists. The experiments implicitly rely on known data maxima.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Computing the Non-Dominated Flexible Skyline in Vertically Distributed Datasets with No Random Access." pith.science (2026). https://pith.science/paper/XZ3AI7M3

@misc{pith2026241215468,
  author       = {Pith},
  title        = {Pith review of: Computing the Non-Dominated Flexible Skyline in Vertically Distributed Datasets with No Random Access},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XZ3AI7M3}},
  note         = {Machine review of arXiv:2412.15468}
}
read the original abstract

In today's data-driven world, algorithms operating with vertically distributed datasets are crucial due to the increasing prevalence of large-scale, decentralized data storage. These algorithms enhance data privacy by processing data locally, reducing the need for data transfer and minimizing exposure to breaches. They also improve scalability, as they can handle vast amounts of data spread across multiple locations without requiring centralized access. Top-k queries have been studied extensively under this lens, and are particularly suitable in applications involving healthcare, finance, and IoT, where data is often sensitive and distributed across various sources. Classical top-k algorithms are based on the availability of two kinds of access to sources: sorted access, i.e., a sequential scan in the internal sort order, one tuple at a time, of the dataset; random access, which provides all the information available at a data source for a tuple whose id is known. However, in scenarios where data retrieval costs are high or data is streamed in real-time or, simply, data are from external sources that only offer sorted access, random access may become impractical or impossible, due to latency issues or data access constraints. Fortunately, a long tradition of algorithms designed for the "no random access" (NRA) scenario exists for classical top-k queries. Yet, these do not cover the recent advances in ranking queries, proposing hybridizations of top-k queries (which are preference-aware and control the output size) and skyline queries (which are preference-agnostic and have uncontrolled output size). The non-dominated flexible skyline (ND) is one such proposal. We introduce an algorithm for computing ND in the NRA scenario, prove its correctness and optimality within its class, and provide an experimental evaluation covering a wide range of cases, with both synthetic and real datasets.

Figures

Figures reproduced from arXiv: 2412.15468 by the authors.

Figure 1
Figure 1. A set of locations ranked by distance to given points of interest. [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Depth (2a), F-dominance tests (2b) and time ((2c)) as size N varies on UNI. 2 3 4 0 5000 10 000 15 000 20 000 25 000 Depth shrinking growing (a) depth 2 3 4 0 2×108 4×108 6×108 8×108 ℱ-dominance tests (b) F-dominance tests 2 3 4 0 100 200 300 400 time (c) Time [PITH_FULL_IMAGE:figures/full_fig_p010_2.png] view at source ↗
Figure 3
Figure 3. Depth (3a), F-dominance tests (3b) and time (3c) as d varies on UNI. quadratic nature of skyline-based operators such as NDk, with the number of tests varying from 387,810 with N = 10K to 308,877,008 with N = 1M. Execution times are essentially related to the number of F-dominance tests, which are the most expensive operation in the process. Figure 2c shows that such times, in seconds, vary from 0.2s with N = 10K to… view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Depth (4a), F-dominance tests (4b) and time (4c) as k varies on UNI. 1 2 5 10 20 50 100 0 20 40 60 80 100 output size (a) Output size 1 2 5 10 20 50 100 0 1000 2000 3000 4000 5000 6000 retained tuples (b) Tuples after growing phase [PITH_FULL_IMAGE:figures/full_fig_p0…
Figure 5
Figure 5. Figure 5: Output siez (5a) and number of tuples retained after the growing [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]
Figure 6
Figure 6. Figure 6: Depth (6a), F-dominance tests (6b) and time (6c) as spread ε varies on UNI. 1 10 100 1000 20 0 500 1000 1500 2000 Depth shrinking growing (a) depth 1 2 5 10 20 0 5.0×107 1.0×108 1.5×108 2.0×108 2.5×108 3.0×108 3.5×108 ℱ-dominance tests (b) F-dominance tests 1 2 5 10 20…
Figure 7
Figure 7. Figure 7: Depth (7a), F-dominance tests (7b) and time (7c) as step size µ varies on UNI. pure k-skyband query (with all possible linear scoring functions, which, as is well known [10], result-wise have the same power as all the monotone scoring functions). Figure 6a shows that, …
Figure 8
Figure 8. Figure 8: Depth (8a), F-dominance tests (8b) and time (8c) as k varies on NBA. accesses may entail a significant speed-up. Additionally, this behavior mimics the case of online services returning results in pages of a given size µ [PITH_FULL_IMAGE:figures/full_fig_p013_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

33 extracted references · 25 canonical work pages

  1. [1]

    The skyline operator

    Stephan B¨ orzs¨ onyi, Donald Kossmann, and Konrad Stocker. The skyline operator. In Proceedings of the 17th International Conference on Data Engineering, April 2-6, 2001, Heidelberg, Germany , pages 421–430, 2001

    work page 2001

  2. [2]

    A framework for crowdsourced mul- timedia processing and querying

    Alessandro Bozzon, Ilio Catallo, Eleonora Ciceri, Piero Fraternali, Davide Martinenghi, and Marco Tagliasacchi. A framework for crowdsourced mul- timedia processing and querying. In Ricardo Baeza-Yates, Stefano Ceri, Piero Fraternali, and Fausto Giunchiglia, editors, Proceedings of the First 15 International Workshop on Crowdsourcing Web Search, Lyon, Fra...

    work page 2012

  3. [3]

    Dynamic query optimization under access limitations and dependencies

    Andrea Cal ` ı, Diego Calvanese, and Davide Martinenghi. Dynamic query optimization under access limitations and dependencies. J. Univers. Com- put. Sci. , 15(1):33–62, 2009

    work page 2009

  4. [4]

    Conjunctive query containment un- der access limitations

    Andrea Cal ` ı and Davide Martinenghi. Conjunctive query containment un- der access limitations. In Qing Li, Stefano Spaccapietra, Eric S. K. Yu, and Antoni Oliv´ e, editors, Conceptual Modeling - ER 2008, 27th Inter- national Conference on Conceptual Modeling, Barcelona, Spain, October 20-24, 2008. Proceedings, volume 5231 of Lecture Notes in Computer Sc...

    2008

  5. [5]

    Querying data under access limita- tions

    Andrea Cal ` ı and Davide Martinenghi. Querying data under access limita- tions. In Gustavo Alonso, Jos´ e A. Blakeley, and Arbee L. P. Chen, edi- tors, Proceedings of the 24th International Conference on Data Engineer- ing, ICDE 2008, April 7-12, 2008, Canc´ un, Mexico , pages 50–59. IEEE Computer Society, 2008

    work page 2008

  6. [6]

    Querying the deep web

    Andrea Cal ` ı and Davide Martinenghi. Querying the deep web. In Ioana Manolescu, Stefano Spaccapietra, Jens Teubner, Masaru Kitsuregawa, Alain L´ eger, Felix Naumann, Anastasia Ailamaki, and Fatma ¨Ozcan, ed- itors, EDBT 2010, 13th International Conference on Extending Database Technology, Lausanne, Switzerland, March 22-26, 2010, Proceedings , vol- ume ...

    work page 2010

  7. [7]

    Skyline with presorting

    Jan Chomicki, Parke Godfrey, Jarek Gryz, and Dongming Liang. Skyline with presorting. In Umeshwar Dayal, Krithi Ramamritham, and T. M. Vijayaraman, editors, Proceedings of the 19th International Conference on Data Engineering, March 5-8, 2003, Bangalore, India, pages 717–719, 2003

    work page 2003

  8. [8]

    Reconciling skyline and ranking queries

    Paolo Ciaccia and Davide Martinenghi. Reconciling skyline and ranking queries. PVLDB, 10(11):1454–1465, 2017

    work page 2017

Show all 33 references
  1. [9]

    F A + TA < FSA: Flexible score aggregation

    Paolo Ciaccia and Davide Martinenghi. F A + TA < FSA: Flexible score aggregation. In Proceedings of the 27th ACM International Conference on Information and Knowledge Management, CIKM 2018, Torino, Italy, October 22-26, 2018 , pages 57–66, 2018

    2018

  2. [10]

    Flexible skylines: Dominance for arbitrary sets of monotone functions

    Paolo Ciaccia and Davide Martinenghi. Flexible skylines: Dominance for arbitrary sets of monotone functions. ACM Trans. Database Syst. , 45(4):18:1–18:45, 2020

    2020

  3. [11]

    Directional Queries: Making Top-k Queries More Effective in Discovering Relevant Results.Proc

    Paolo Ciaccia and Davide Martinenghi. Directional Queries: Making Top-k Queries More Effective in Discovering Relevant Results.Proc. ACM Manag. Data, 2(6), 2024. 16

    2024

  4. [12]

    Optimization strategies for parallel computation of skylines

    Paolo Ciaccia and Davide Martinenghi. Optimization strategies for parallel computation of skylines. CoRR, 2411.14968, 2024

    2024 arXiv

  5. [13]

    Efficient skyline computation in structured peer-to-peer systems

    Bin Cui, Lijiang Chen, Linhao Xu, Hua Lu, Guojie Song, and Quanqing Xu. Efficient skyline computation in structured peer-to-peer systems. IEEE Trans. Knowl. Data Eng. , 21(7):1059–1072, 2009

    2009

  6. [14]

    Combining fuzzy information from multiple systems

    Ronald Fagin. Combining fuzzy information from multiple systems. In PODS, pages 216–226, 1996

    1996

  7. [15]

    Fuzzy queries in multimedia database systems

    Ronald Fagin. Fuzzy queries in multimedia database systems. In Al- berto O. Mendelzon and Jan Paredaens, editors, Proceedings of the Sev- enteenth ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, June 1-3, 1998, Seattle, Washington, USA , pages 1–10, 1998

    1998

  8. [16]

    Optimal aggregation algo- rithms for middleware

    Ronald Fagin, Amnon Lotem, and Moni Naor. Optimal aggregation algo- rithms for middleware. In PODS, 2001

    2001

  9. [17]

    Rfid- data compression for supporting aggregate queries

    Bettina Fazzinga, Sergio Flesca, Filippo Furfaro, and Elio Masciari. Rfid- data compression for supporting aggregate queries. ACM Trans. Database Syst., 38(2):11, 2013

    2013

  10. [18]

    Effi- cient and effective RFID data warehousing

    Bettina Fazzinga, Sergio Flesca, Elio Masciari, and Filippo Furfaro. Effi- cient and effective RFID data warehousing. In Bipin C. Desai, Domenico Sacc` a, and Sergio Greco, editors,International Database Engineering and Applications Symposium (IDEAS 2009), September 16-18, 200...

    2009

  11. [19]

    A draw-and-guess game to segment images

    Luca Galli, Piero Fraternali, Davide Martinenghi, Marco Tagliasacchi, and Jasminko Novak. A draw-and-guess game to segment images. In 2012 International Conference on Privacy, Security, Risk and Trust, PASSAT 2012, and 2012 International Confernece on Social Computing, SocialC...

    2012

  12. [20]

    Ilyas, George Beskales, and Mohamed A

    Ihab F. Ilyas, George Beskales, and Mohamed A. Soliman. A survey of top-k query processing techniques in relational database systems. ACM Comput. Surv. , 40(4), 2008

    2008

  13. [21]

    Nikos Mamoulis, Man Lung Yiu, Kit Hung Cheng, and David W. Cheung. Efficient top-k aggregation of ranked inputs. ACM Trans. Database Syst. , 32(3):19, 2007

    2007

  14. [22]

    Parallelizing the computation of robustness for mea- suring the strength of tuples

    Davide Martinenghi. Parallelizing the computation of robustness for mea- suring the strength of tuples. CoRR, 2412.02274, 2024

    2024 arXiv

  15. [23]

    Proximity rank join

    Davide Martinenghi and Marco Tagliasacchi. Proximity rank join. Proc. VLDB Endow. , 3(1):352–363, 2010. 17

    2010

  16. [24]

    Cost-aware rank join with random and sorted access

    Davide Martinenghi and Marco Tagliasacchi. Cost-aware rank join with random and sorted access. IEEE Trans. Knowl. Data Eng. , 24(12):2143– 2155, 2012

    2012

  17. [25]

    Proximity measures for rank join

    Davide Martinenghi and Marco Tagliasacchi. Proximity measures for rank join. ACM Trans. Database Syst. , 37(1):2:1–2:46, 2012

    2012

  18. [26]

    Trajectory clustering via effective partitioning

    Elio Masciari. Trajectory clustering via effective partitioning. In Troels Andreasen, Ronald R. Yager, Henrik Bulskov, Henning Christiansen, and Henrik Legind Larsen, editors, Flexible Query Answering Systems, 8th In- ternational Conference, FQAS 2009, Roskilde, Denmark, Octob...

    2009

  19. [27]

    Analysing microarray expression data through effective clustering

    Elio Masciari, Giuseppe Massimiliano Mazzeo, and Carlo Zaniolo. Analysing microarray expression data through effective clustering. Inf. Sci., 262:32–45, 2014

    2014

  20. [28]

    Marrying top-k with sky- line queries: Relaxing the preference input while producing output of con- trollable size

    Kyriakos Mouratidis, Keming Li, and Bo Tang. Marrying top-k with sky- line queries: Relaxing the preference input while producing output of con- trollable size. In Guoliang Li, Zhanhuai Li, Stratos Idreos, and Divesh Srivastava, editors, SIGMOD ’21: International Conference on...

    2021

  21. [29]

    Efficient skyline computation in mapreduce

    Kasper Mullesgaard, Jens Laurits Pederseny, Hua Lu, and Yongluan Zhou. Efficient skyline computation in mapreduce. In Sihem Amer-Yahia, Vassilis Christophides, Anastasios Kementsietsidis, Minos N. Garofalakis, Stratos Idreos, and Vincent Leroy, editors, Proceedings of the 17th...

    2014

  22. [30]

    Progressive skyline computation in database systems

    Dimitris Papadias, Yufei Tao, Greg Fu, and Bernhard Seeger. Progressive skyline computation in database systems. TODS, 30(1):41–82, 2005

    2005

  23. [31]

    Evaluating rank joins with optimal cost

    Karl Schnaitter and Neoklis Polyzotis. Evaluating rank joins with optimal cost. In Maurizio Lenzerini and Domenico Lembo, editors, Proceedings of the Twenty-Seventh ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems, PODS 2008, June 9-11, 2008, Vancouver, BC,...

    2008

  24. [32]

    Soliman, Ihab F

    Mohamed A. Soliman, Ihab F. Ilyas, Davide Martinenghi, and Marco Tagliasacchi. Ranking with uncertain scoring functions: semantics and sensitivity measures. In Proceedings of the ACM SIGMOD International Conference on Management of Data, SIGMOD 2011, Athens, Greece, June 12-16...

    2011

  25. [2009]

    Proceedings, volume 5822 of Lecture Notes in Computer Science , pages 358–370, 2009

    2009

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.