Pith. sign in

REVIEW 3 major objections 6 minor 43 references

Efficient Join Processing Over Incomplete Data Streams (Technical Report)

T0 review · 3 major / 6 minor · reviewed 2026-08-14 · deepseek-v4-flash

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

Pith's one-line read The paper claims that joining incomplete data streams is efficiently solvable by doing differential-dependency imputation and join processing at the same time, using an epsilon-grid synopsis and two pruning rules, with F1 above 92% on…

desk verdict Real problem, correct lemmas, plausible speedups—but the F1 claim rests on an untested repository-representativeness assumption. read the letter →

arxiv 1908.08654 v1 pith:MNLN7YD5 submitted 2019-08-23 cs.DB

Weilong Ren , Xiang Lian , Kambiz Ghazinour This is my paper · ORCID
classification cs.DB
keywords joinoverincompletedatastreamsdifferentialdependencyimputationstreampossibleworldsslidingwindowepsilon-gridsynopsisprobabilistic
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

Two data streams may carry objects with missing attributes, and joining them means deciding which pairs are similar even though some values are unknown. The paper defines this as the Join-iDS problem, with similarity measured by Euclidean distance under a probabilistic threshold. Its central claim is that missing values can be imputed and the join computed at the same time, without first materializing complete streams, and that this simultaneous style is both accurate and fast. Using differential dependency rules and a static complete repository for imputation, an epsilon-grid synopsis for candidate pairs, and two pruning rules, the reported method keeps F1 scores above 92% on real data and runs about two orders of magnitude faster than the two-phase baselines DD+ASP and DD+epsilon-grid. The contribution is the demonstration that incompleteness need not be a separate preprocessing burden for stream joins.

What carries the argument

The load-bearing mechanism is the epsilon-grid synopsis combined with DD-based imputation indexes and two pruning lemmas. A differential dependency (DD) is a rule that if two objects are within distance constraints on determinant attributes, their dependent attributes must also be close; it supplies the imputation by treating complete objects in repository $R$ that satisfy the constraint as evidence, with empirical fractions as existence probabilities. The epsilon-grid partitions the normalized data space into cells of side length $\epsilon$, and each cell holds queues of imputed objects from the two streams, so candidate pairs are found by intersecting cells rather than scanning windows. Object-level pruning drops a pair when the minimum distance between their current bounding boxes exceeds $\epsilon$; sample-level pruning drops a pair when the probability mass of instances inside two sub-boxes is large enough that the joint probability cannot reach the threshold $\alpha$. The imputation indexes are variants of R*-trees over repository $R$, with histograms on the dependent attribute, so that imputation of missing values and traversal of candidate cells happen in one pass.

What would settle it

Run the same Join-iDS experiment twice: once with repository $R$ taken from the same dataset as the streams, as in the paper, and once with $R$ drawn from a different distribution, such as weather data used to impute stock data or data from a different time period. If F1 drops substantially or the returned join pairs change materially, the imputation evidence from $R$ is not transferable, and the effectiveness claim does not generalize. A simpler direct check is to construct a case where many repository objects satisfy the DD constraint on determinant attributes but have widely different dependent values; then imputed probabilities become near-uniform and join probabilities become threshold-sensitive, which would expose the imputation step's fragility.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is that Join-iDS can be reduced from a possible-worlds probability computation to an object-level sum over instance pairs, and that this sum can be evaluated lazily during imputation. The join probability $\Pr_{\mathrm{Join\hbox{-}iDS}}(o_x^p, o_y^p)$ is rewritten as a sum over instances $o_{xl}.p \cdot o_{y\varrho}.p \cdot \chi(\mathrm{dist}(o_{xl}, o_{y\varrho}) \leq \epsilon)$, avoiding exponential possible-world enumeration. Then an epsilon-grid partitions the data space into side-length-$\epsilon$ cells, each with queues of imputed objects from the two streams; the algorithm imputes a new object's bounding box via R*-tree-based indexes over the repository, prunes cells and objects whose minimum distance exceeds $\epsilon$, and only fully materializes instances for surviving candidates. The empirical core is that this fused pipeline reaches F1 above 92% on Intel, Gas, Weather, and Stock data and above 96% on synthetic uniform, correlated, and anti-correlated data, while taking wall-clock time on the order of $10^{-3}$ seconds per timestamp, about two orders of magnitude less than the impute-then-join baselines.

Load-bearing premise

The load-bearing assumption is that the static complete reference data used to fill in missing values resembles the live streams: if the reference is stale or from a different source, the filled-in values and the join results built on them are unreliable.

Editorial extensions

If this is right

  • Stream joins over incomplete data can be maintained incrementally: each new object is imputed, tested against candidate cells, and inserted into the epsilon-grid, so expired objects are evicted without re-running the whole join.
  • On the reported data sets, per-timestamp cost stays in the low milliseconds even with sliding windows of 10,000 objects, making the approach usable for online monitoring rather than offline analysis.
  • The pruning rules eliminate about 93% of object pairs on real data and about 92% of pairs on synthetic data before exact probability computation, so runtime is tied to surviving candidates rather than window size squared.
  • Because the F1 scores of the two-phase baselines are identical to Join-iDS, the paper's efficiency gain comes from fusing imputation with join, not from a different imputation model.
  • The framework extends to more than two streams by adding one queue per stream in each epsilon-grid cell, so the same mechanism covers multi-stream join monitoring.

Reading between the lines

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

  • If the repository $R$ is not representative of the stream, say collected from a different network, season, or domain, the imputed probabilities become unreliable; the paper does not test this mismatch, and a robustness study with distribution drift would be the natural follow-up.
  • Because F1 is measured against ground truth generated by randomly hiding attributes of complete records, the evaluation measures recovery of a known answer; a field test with naturally missing data, where no ground truth exists, is still needed.
  • The same fused imputation-and-candidate-generation pattern could be applied to other join predicates, such as set similarity or trajectory distance, by changing the distance function inside the epsilon-grid cells.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 6 minor

Summary. The paper formalizes the Join-iDS problem: continuously joining objects from two incomplete data streams under sliding-window semantics, where objects may have missing attributes and the result is a set of pairs whose Euclidean distance is within threshold epsilon with probability at least alpha. The proposed solution performs DD-based imputation and join processing simultaneously. It builds an imputation lattice over discovered DD rules, constructs cost-model-based indexes (R*-tree variants with histograms) over a static repository R, maintains an epsilon-grid synopsis over the stream windows, and applies two pruning rules (object-level and sample-level). The authors prove the pruning lemmas, reduce the possible-world probability computation to an object-level sum (Eq. 3), and evaluate on four real and three synthetic datasets against two two-phase baselines, reporting F1 scores above 92% (real) and 96% (synthetic) and about two orders of magnitude wall-clock speedup.

Significance. If the effectiveness and efficiency claims hold, Join-iDS is a well-motivated and practical problem, and the 'impute-and-join at the same time' architecture is a sensible contribution. The paper's core algorithmic machinery is concrete: the possible-world reduction in Eq. (3) is valid under the stated per-object mutual-exclusion and cross-object independence assumptions, Lemma 4.1 and Lemma 4.2 are correctly argued in the appendix, and the grid/index design is a reasonable engineering approach. The work also has the virtue of being evaluated on multiple real datasets with an explicit ground-truth construction. However, the external validity of the effectiveness claim is limited by the repository-representativeness assumption and by an experimental design that splits R from the same data as the streams, which is the central weakness that a revision must address.

major comments (3)
  1. [Section 2.2 and Section 6.1] The imputation confidence model rests on the assumption that the static repository R has the same conditional distribution as the stream data (Section 2.2: 'we assume that a static data repository R ... is available for imputing missing attributes from data streams'). The experiments, however, construct iDS1, iDS2, and R by splitting the same dataset (Section 6.1), so the assumption is satisfied by construction. There is no experiment with a stale, temporally shifted, or distributionally mismatched R, and no discussion of how concept drift would affect val.p and the probabilities in Eq. (3). The claimed F1 >= 92% is therefore only demonstrated in a favorable setting, not in the stream scenarios (e.g., network intrusion or sensor monitoring) where R is necessarily historical and the stream may drift. The authors should either add robustness experiments with mismatched R or explicitly scope the effectiveness claim to the setting where R is representative.
  2. [Section 2.2 / Definition 2.4 and Eq. (3)] Equation (3) and Definition 2.4 implicitly assume that the missing attributes of an object are independent, because the instance probability oil.p is defined as the product of per-attribute confidences val.p. This assumption is load-bearing for the join probability computation, yet the paper never states it as an assumption, nor does it validate it. The synthetic data include correlated and anti-correlated distributions (Table 4), but the experiments do not vary the dependency structure among missing attributes or compare against a model that preserves attribute correlations. The authors should state the independence assumption explicitly and provide experiments with dependent missingness to show the sensitivity of the reported F1 values.
  3. [Section 6.3 and Section 6.4] The experimental evaluation reports only point values without error bars or variance, and the F1 comparison is effectively absent: the baselines are stated to have the same F1 as Join-iDS because they share the same DD imputation step (Section 6.3). Consequently, the paper does not demonstrate that the DD-based imputation method itself is more effective than alternative imputation approaches (e.g., mean/regression imputation, editing rules, or other rule-based methods). The central effectiveness claim would be much stronger with standard deviations over multiple runs and at least one additional imputation baseline for F1 comparison.
minor comments (6)
  1. [Abstract and Introduction] The abstract and Introduction use 'deferential dependency' where the established term is 'differential dependency'; please correct the spelling throughout.
  2. [Section 6.1 (Competitor)] The sentence 'which which first impute incomplete objects via DDs' contains a duplicated 'which'; please fix.
  3. [Section 6.2] In the pruning-power discussion, '6/23%-6.63%' appears to be a typo for '6.23%-6.63%'; please correct.
  4. [Definition 2.3] The notation 'Aj < X' in Definition 2.3 is unclear; it should be stated explicitly that Aj is an attribute not in X (e.g., 'Aj notin X').
  5. [Appendix C] The selection of sub-MBRs sx and sy in Appendix C is heuristic and greedy; the paper should note explicitly that the choice only affects pruning power, not the correctness of Lemma 4.2.
  6. [Section 5.2 (Complexity Analysis)] The complexity bound O(|op_x| * |op_y| * |cl| * |cl.qy|) is given without accounting for index construction, grid maintenance, or lattice traversal; please clarify which components are included in the reported wall-clock time.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: the derivation is self-contained and the efficiency/effectiveness claims rest on external groundtruth, not on the defined probabilities.

full rationale

The paper defines Join-iDS probability directly (Eq. 3) from imputation confidences, which are empirical fractions in repository R; this is a problem definition rather than a predicted quantity. Effectiveness is evaluated against groundtruth join pairs obtained from the original complete data (Section 6.3), not against the imputation confidences themselves, so the F1 numbers are not forced by the definition. DD rules are discovered from the held-out repository R using external prior work [32], and no parameters are fitted to the hidden missing values or to the groundtruth. The pruning lemmas follow from the distance/probability definitions and are validated by execution-time comparisons. The paper honestly discloses that DD+ASP and DD+epsilon-grid achieve the same F1 score because they share the same DD imputation module; this means the F1 result validates the imputation module rather than the join algorithm, but this is a scope disclosure, not a circular derivation. The only self-citations are [20,21] (Lian/Chen), used as background and as one baseline implementation; they are not load-bearing for the central claim. The repository-representativeness concern is an external-validity limitation: R is split from the same datasets in Section 6.1, so concept drift or a mismatched R would undermine the claimed F1, but this is not an internal circularity.

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

The central claim depends on the representativeness of the static repository R, the correctness of the discovered DD rules, and an independence assumption among imputed attributes. The method introduces no new physical or conceptual entities beyond data structures (epsilon-grid, imputation lattice, R*-tree indexes), which are not counted as invented entities.

free parameters (4)
  • DD distance thresholds epsilon_Ay = not reported (detected from repository R)
    Each DD rule X -> Aj uses distance constraints [0, epsilon_Ay] on each attribute; these thresholds control which repository objects are used for imputation and are discovered offline from R by the method of [32]. Their values are not listed in the paper.
  • Histogram bucket count lambda = not reported
    Each R*-tree node stores a histogram over the dependent attribute divided into lambda buckets; the value of lambda is never specified.
  • Cluster size bounds m and M = not reported
    Objects in R are clustered into groups of size within [m, M] before R*-tree insertion; the cost model selects clusters but m and M are not reported.
  • Sub-MBR expansion threshold = 1
    In Appendix C, the heuristic adds the next bucket while Delta(Sx.I)/Delta(beta_x) < 1; the constant 1 is chosen by hand.
assumptions (5)
  • domain assumption A static complete repository R is available and representative of the stream distribution.
    Section 2.2 states 'we assume that a static data repository R (containing complete objects without missing attributes) is available for imputing missing attributes from data streams.' The experiments split each data set so R contains complete objects from the same distribution; no evaluation with a mismatched repository is provided.
  • domain assumption DD rules and their distance thresholds are correctly discovered and remain valid over time.
    The paper relies on DD rules detected offline by the method of [32] (Section 6.1) and assumes they apply to streaming objects; concept drift or invalid rules would break imputation quality.
  • ad hoc to paper Instances within an imputed object are mutually exclusive and their probabilities sum to 1; imputed attributes are independent.
    Definition 2.4 states each imputed object contains mutually exclusive instances with probabilities summing to 1, and computes instance probability as the product of per-attribute confidences. The independence of missing attributes is assumed without justification.
  • domain assumption Objects in different streams are independent, so the joint probability of instances is the product of their marginal probabilities.
    Equation (3) reduces the possible-world sum to a product of instance probabilities; this standard assumption in probabilistic databases is not stated explicitly.
  • standard math The fractal dimension cost model accurately estimates the number of qualifying repository objects.
    Appendix B.1 uses the fractal-dimension-based estimator from Belussi and Faloutsos [4] to predict cnt(DD); this is an approximate estimator, not an exact count.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Efficient Join Processing Over Incomplete Data Streams (Technical Report)." pith.science (2026). https://pith.science/paper/MNLN7YD5

@misc{pith2026190808654,
  author       = {Pith},
  title        = {Pith review of: Efficient Join Processing Over Incomplete Data Streams (Technical Report)},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/MNLN7YD5}},
  note         = {Machine review of arXiv:1908.08654}
}
read the original abstract

For decades, the join operator over fast data streams has always drawn much attention from the database community, due to its wide spectrum of real-world applications, such as online clustering, intrusion detection, sensor data monitoring, and so on. Existing works usually assume that the underlying streams to be joined are complete (without any missing values). However, this assumption may not always hold, since objects from streams may contain some missing attributes, due to various reasons such as packet losses, network congestion/failure, and so on. In this paper, we formalize an important problem, namely join over incomplete data streams (Join-iDS), which retrieves joining object pairs from incomplete data streams with high confidences. We tackle the Join-iDS problem in the style of "data imputation and query processing at the same time". To enable this style, we design an effective and efficient cost-model-based imputation method via deferential dependency (DD), devise effective pruning strategies to reduce the Join-iDS search space, and propose efficient algorithms via our proposed cost-model-based data synopsis/indexes. Extensive experiments have been conducted to verify the efficiency and effectiveness of our proposed Join-iDS approach on both real and synthetic data sets.

Figures

Figures reproduced from arXiv: 1908.08654 by the authors.

Figure 1
Figure 1. The join operator over incomplete data streams for monitor￾ing network intrusion [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 3
Figure 3. Illustration of a 2D ϵ-grid over incomplete data streams. LEMMA 4.1. (Object-Level Pruning) Given two incomplete objects, ox and oy , from sliding windows W1t ∈ iDS1 and W2t ∈ iDS2, respectively, if mindist(o p x , o p y ) > ϵ holds, then object pair (ox , oy ) can be safely pruned. PROOF. Please refer to Appendix A.1. □ [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 4
Figure 4. Imputation Index over repository R given a DD AB → C (UC = AB). Aj). Each cell, cl, is associated with two queues, cl.qx and cl.qy , which sequentially store imputed objects o p x ∈ W1t and o p y ∈ W2t , respectively, that intersect with this cell cl. Each imputed object o p x (or o p y ) contains information as follows: (1) a set of currently accessed MBR nodes, MBRs, in the R∗ -tree over data repository R for impu… view at source ↗
Figures from the paper (5 more)
Figure 5
Figure 5. Figure 5: Pruning power evaluation over real/synthetic data sets. from each of these 4 real data sets: temperature, humidity, light, and voltage from Intel; temperature, humidity, and resistance of sensors 7 and 8 from Gas; Vancouver, Portland, San Francisco, and Seattle from W …
Figure 8
Figure 8. Figure 8: The performance vs. probabilistic threshold α. 0.1 0.2 0.3 0.4 0.5 2 2.5 3 3.5 wall clock time (sec) 10-3 Intel Gas Weather Stock (a) real data 0.1 0.2 0.3 0.4 0.5 2 2.5 3 3.5 4 wall clock time (sec) 10-3 uniform correlated anti-correlated (b) synthetic data [PITH_FUL…
Figure 7
Figure 7. Figure 7: The performance vs. real/synthetic data sets. 6.2 Effectiveness of Sky-iDS Pruning Methods [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]
Figure 10
Figure 10. Figure 10: The performance vs. dimensionality d. 92% and 96%, resp.) for different ϵ values, which verifies the effec￾tiveness of our imputation and Join-iDS approaches. Note that, the two baseline methods DD + ASP and DD + ϵ-дrid have same F1 score as our Join-iDS approach, sin…
Figure 11
Figure 11. Figure 11: The performance vs. No., |Wt |, of objects in W1t (or W2t ). The Join-iDS Performance vs. Probabilistic Threshold α [PITH_FULL_IMAGE:figures/full_fig_p009_11.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

43 extracted references · 43 canonical work pages

  1. [1]

    An inte- gration framework for sensor networks and data stream management systems

    Daniel J Abadi, Wolfgang Lindner, Samuel Madden, and Jörg Schuler. An inte- gration framework for sensor networks and data stream management systems. In Proceedings of the Thirtieth international conference on Very large data bases- Volume 30, pages 1361–1364. VLDB Endowment, 2004

    work page 2004

  2. [2]

    Efficient approximation of correlated sums on data streams

    Rohit Ananthakrishna, Abhinandan Das, Johannes Gehrke, Flip Korn, Shanmu- gavelayutham Muthukrishnan, and Divesh Srivastava. Efficient approximation of correlated sums on data streams. IEEE Transactions on Knowledge and Data Engineering, 15(3):569–572, 2003

    work page 2003

  3. [3]

    The r*-tree: an efficient and robust access method for points and rectangles

    Norbert Beckmann, Hans-Peter Kriegel, Ralf Schneider, and Bernhard Seeger. The r*-tree: an efficient and robust access method for points and rectangles. In Acm Sigmod Record, volume 19, pages 322–331. Acm, 1990

    work page 1990

  4. [4]

    Self-spacial join selectivity estimation using fractal concepts

    Alberto Belussi and Christos Faloutsos. Self-spacial join selectivity estimation using fractal concepts. ACM Transactions on Information Systems (TOIS), 16(2): 161–201, 1998

    work page 1998

  5. [5]

    Epsilon grid order: An algorithm for the similarity join on massive high- dimensional data

    Christian Böhm, Bernhard Braunmüller, Florian Krebs, and Hans-Peter Kriegel. Epsilon grid order: An algorithm for the similarity join on massive high- dimensional data. In ACM SIGMOD Record, volume 30, pages 379–388. ACM, 2001

    work page 2001

  6. [6]

    Efficiently process- ing continuous k-nn queries on data streams

    Christian Bohm, Beng Chin Ooi, Claudia Plant, and Ying Yan. Efficiently process- ing continuous k-nn queries on data streams. In 2007 IEEE 23rd International Conference on Data Engineering, pages 156–165. IEEE, 2007

    work page 2007

  7. [7]

    The skyline operator

    Stephan Borzsony, Donald Kossmann, and Konrad Stocker. The skyline operator. In Proceedings 17th international conference on data engineering, pages 421–430. IEEE, 2001

    work page 2001

  8. [8]

    Apache flink: Stream and batch processing in a single engine

    Paris Carbone, Asterios Katsifodimos, Stephan Ewen, V olker Markl, Seif Haridi, and Kostas Tzoumas. Apache flink: Stream and batch processing in a single engine. Bulletin of the IEEE Computer Society Technical Committee on Data Engineering, 36(4), 2015

    work page 2015

Show all 43 references
  1. [9]

    Efficient query evaluation on probabilistic databases

    Nilesh Dalvi and Dan Suciu. Efficient query evaluation on probabilistic databases. The VLDB Journalâ ˘A ˇTThe International Journal on Very Large Data Bases, 16 (4):523–544, 2007

    2007

  2. [10]

    Approximate join pro- cessing over data streams

    Abhinandan Das, Johannes Gehrke, and Mirek Riedewald. Approximate join pro- cessing over data streams. InProceedings of the 2003 ACM SIGMOD international conference on Management of data, pages 40–51. ACM, 2003

    2003

  3. [11]

    A study on nsl-kdd dataset for intrusion detection system based on classification algorithms

    L Dhanabal and SP Shantharajah. A study on nsl-kdd dataset for intrusion detection system based on classification algorithms. International Journal of Advanced Research in Computer and Communication Engineering, 4(6):446–452, 2015

    2015

  4. [12]

    The X-tree: An index structure for high-dimensional data

    Berchtold et al. The X-tree: An index structure for high-dimensional data. In VLDB, 1996

    1996

  5. [13]

    Towards certain fixes with editing rules and master data

    Wenfei Fan, Jianzhong Li, Shuai Ma, Nan Tang, and Wenyuan Yu. Towards certain fixes with editing rules and master data. Proceedings of the VLDB Endowment, 3 (1-2):173–184, 2010

    2010

  6. [14]

    Net-fli: on-the-fly compression, archiving and indexing of streaming network traffic

    Francesco Fusco, Marc Ph Stoecklin, and Michail Vlachos. Net-fli: on-the-fly compression, archiving and indexing of streaming network traffic. Proceedings of the VLDB Endowment, 3(1-2):1382–1393, 2010

    2010

  7. [15]

    Sjoin: A semantic join operator to integrate heterogeneous rdf graphs

    Mikhail Galkin, Diego Collarana, Ignacio Traverso-Ribón, Maria-Esther Vidal, and Sören Auer. Sjoin: A semantic join operator to integrate heterogeneous rdf graphs. In International Conference on Database and Expert Systems Applications, pages 206–221. Springer, 2017

    2017

  8. [16]

    Explicit information for category-orthogonal object properties increases along the ventral stream

    Ha Hong, Daniel LK Yamins, Najib J Majaj, and James J DiCarlo. Explicit information for category-orthogonal object properties increases along the ventral stream. Nature neuroscience, 19(4):613, 2016

    2016

  9. [17]

    Discovering geographical topics in the twitter stream

    Liangjie Hong, Amr Ahmed, Siva Gurumurthy, Alexander J Smola, and Kostas Tsioutsiouliklis. Discovering geographical topics in the twitter stream. In Pro- ceedings of the 21st international conference on World Wide Web, pages 769–778. ACM, 2012

    2012

  10. [18]

    Fully online clustering of evolving data streams into arbitrarily shaped clusters

    Richard Hyde, Plamen Angelov, and Angus Robert MacKenzie. Fully online clustering of evolving data streams into arbitrarily shaped clusters. Information Sciences, 382:96–114, 2017

    2017

  11. [19]

    Efficient similarity join and search on multi-attribute data

    Guoliang Li, Jian He, Dong Deng, and Jian Li. Efficient similarity join and search on multi-attribute data. In Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data, pages 1137–1151. ACM, 2015

    2015

  12. [20]

    Efficient similarity join over multiple stream time series

    Xiang Lian and Lei Chen. Efficient similarity join over multiple stream time series. IEEE transactions on knowledge and data engineering, 21(11):1544–1558, 2009

    2009

  13. [21]

    Similarity join processing on uncertain data streams

    Xiang Lian and Lei Chen. Similarity join processing on uncertain data streams. IEEE Transactions on Knowledge and Data Engineering , 23(11):1718–1734, 2010

    2010

  14. [22]

    Scalable distributed stream join processing

    Qian Lin, Beng Chin Ooi, Zhengkui Wang, and Cui Yu. Scalable distributed stream join processing. In Proceedings of the 2015 ACM SIGMOD International Conference on Management of Data, pages 811–825. ACM, 2015

    2015

  15. [23]

    A novel approach for high- dimensional vector similarity join query

    Youzhong Ma, Shijie Jia, and Yongxin Zhang. A novel approach for high- dimensional vector similarity join query. Concurrency and Computation: Practice and Experience, 29(5):e3952, 2017

    2017

  16. [24]

    Eracer: a database approach for statistical inference and data cleaning

    Chris Mayfield, Jennifer Neville, and Sunil Prabhakar. Eracer: a database approach for statistical inference and data cleaning. In Proceedings of the 2010 ACM SIGMOD International Conference on Management of data, pages 75–86. ACM, 2010

    2010

  17. [25]

    Join processing in relational databases

    Priti Mishra and Margaret H Eich. Join processing in relational databases. ACM Computing Surveys (CSUR), 24(1):63–113, 1992

    1992

  18. [26]

    Continuous moni- toring of top-k queries over sliding windows

    Kyriakos Mouratidis, Spiridon Bakiras, and Dimitris Papadias. Continuous moni- toring of top-k queries over sliding windows. In Proceedings of the 2006 ACM SIGMOD international conference on Management of data, pages 635–646. ACM, 2006

    2006

  19. [27]

    Complete event trend detection in high-rate event streams

    Olga Poppe, Chuan Lei, Salah Ahmed, and Elke A Rundensteiner. Complete event trend detection in high-rate event streams. In Proceedings of the 2017 ACM International Conference on Management of Data, pages 109–124. ACM, 2017

    2017

  20. [28]

    Combining quantitative and logical data cleaning

    Nataliya Prokoshyna, Jaroslaw Szlichta, Fei Chiang, Renée J Miller, and Divesh Srivastava. Combining quantitative and logical data cleaning. Proceedings of the VLDB Endowment, 9(4):300–311, 2015

    2015

  21. [29]

    Multiple imputation of missing values

    Patrick Royston. Multiple imputation of missing values. The Stata Journal, 4(3): 227–241, 2004

    2004

  22. [30]

    Wadjet: Finding outliers in multiple multi-dimensional heterogeneous data streams

    Shiblee Sadik, Le Gruenwald, and Eleazar Leal. Wadjet: Finding outliers in multiple multi-dimensional heterogeneous data streams. In 2018 IEEE 34th International Conference on Data Engineering (ICDE), pages 1232–1235. IEEE, 2018

    2018

  23. [31]

    Trajectory similarity join in spatial networks

    Shuo Shang, Lisi Chen, Zhewei Wei, Christian S Jensen, Kai Zheng, and Panos Kalnis. Trajectory similarity join in spatial networks. Proceedings of the VLDB Endowment, 10(11):1178–1189, 2017

    2017

  24. [32]

    Differential dependencies: Reasoning and discovery

    Shaoxu Song and Lei Chen. Differential dependencies: Reasoning and discovery. ACM Transactions on Database Systems (TODS), 36(3):16, 2011

    2011

  25. [33]

    Repairing vertex labels under neighborhood constraints

    Shaoxu Song, Hong Cheng, Jeffrey Xu Yu, and Lei Chen. Repairing vertex labels under neighborhood constraints. Proceedings of the VLDB Endowment, 7(11): 987–998, 2014

    2014

  26. [34]

    Enriching data impu- tation with extensive similarity neighbors

    Shaoxu Song, Aoqian Zhang, Lei Chen, and Jianmin Wang. Enriching data impu- tation with extensive similarity neighbors. Proceedings of the VLDB Endowment, 8(11):1286–1297, 2015

    2015

  27. [35]

    Matching heterogeneous events with patterns

    Shaoxu Song, Yu Gao, Chaokun Wang, Xiaochen Zhu, Jianmin Wang, and S Yu Philip. Matching heterogeneous events with patterns. IEEE Transactions on Knowledge and Data Engineering, 29(8):1695–1708, 2017

    2017

  28. [36]

    Graph re- pairing under neighborhood constraints

    Shaoxu Song, Boge Liu, Hong Cheng, Jeffrey Xu Yu, and Lei Chen. Graph re- pairing under neighborhood constraints. The VLDB Journalâ ˘A ˇTThe International Journal on Very Large Data Bases, 26(5):611–635, 2017

    2017

  29. [37]

    Maintaining sliding window skylines on data streams

    Yufei Tao and Dimitris Papadias. Maintaining sliding window skylines on data streams. IEEE Transactions on Knowledge and Data Engineering, 18(3):377–391, 2006

    2006

  30. [38]

    Window-aware load shedding for aggregation queries over data streams

    Nesime Tatbul and Stan Zdonik. Window-aware load shedding for aggregation queries over data streams. In Proceedings of the 32nd international conference on Very large data bases, pages 799–810. VLDB Endowment, 2006

    2006

  31. [39]

    Leveraging set relations in exact set similarity join

    Xubo Wang, Lu Qin, Xuemin Lin, Ying Zhang, and Lijun Chang. Leveraging set relations in exact set similarity join. Proceedings of the VLDB Endowment, 10(9): 925–936, 2017

    2017

  32. [40]

    Continuous imputation of missing values in streams of pattern-determining time series

    Kevin Wellenzohn, Michael Hanspeter Böhlen, Anton Dignös, Johann Gamper, and Hannes Mitterer. Continuous imputation of missing values in streams of pattern-determining time series. 2017

    2017

  33. [41]

    Online clustering for trajectory data stream of moving objects

    Yanwei Yu, Qin Wang, Xiaodong Wang, Huan Wang, Jie He, et al. Online clustering for trajectory data stream of moving objects. Comput. Sci. Inf. Syst., 10 (3):1293–1317, 2013

    2013

  34. [42]

    Zhang, S

    A. Zhang, S. Song, Y . Sun, and J. Wang. Learning individual models for imputation. In ICDE, pages 160–171, 2019

    2019

  35. [43]

    Time series data cleaning: From anomaly detection to anomaly repairing

    Aoqian Zhang, Shaoxu Song, Jianmin Wang, and Philip S Yu. Time series data cleaning: From anomaly detection to anomaly repairing. Proceedings of the VLDB Endowment, 10(10):1046–1057, 2017. Appendix A PROOF FOR PRUNING STRATEGIES A.1 Proof of Lemma 4.1 PROOF. If mindist(op x , ...

    2017

Pith tools

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