Pith. sign in

REVIEW 4 major objections 5 minor 42 references

CONCERTO: Complex Query Execution Mechanism-Aware Learned Cost Estimation

T0 review · 4 major / 5 minor · reviewed 2026-08-12 · deepseek-v4-flash

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

Pith's one-line read CONCERTO predicts OLAP query latency more accurately than existing learned methods by decoupling operator cost, resource-competition calibration, and latency aggregation.

desk verdict A solid, well-ablated multi-stage QPP for dynamic parallel DAG pipelines, but the headline accuracy gain is modest and the central claim depends on an unverified probe-completeness assumption. read the letter →

arxiv 2412.00749 v2 pith:44R5JSFL submitted 2024-12-01 cs.DB cs.AI

Kaixin Zhang , Hongzhi Wang , Kunkai Gu , Ziqi Li , Chunyu Zhao , Yingze Li , Yu Yan This is my paper · ORCID
classification cs.DBcs.AI
keywords queryperformancepredictionlearnedcostestimationAI4DBgraphattentionnetworktemporalconvolutionalparallelexecutiondynamicpipelineOLAP
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

The paper claims that query performance prediction on modern OLAP databases—where operators are vectorized, pipelines run in parallel, and the execution plan is dynamically rewritten at runtime—fails when done with tree-shaped, static-plan models, and that a multi-stage method aware of these mechanisms does better. To show this, CONCERTO first predicts each physical operator's standalone resource cost, then calibrates those costs for parallel resource contention using a graph attention network over a data-flow tree, and finally aggregates the calibrated costs into a total latency prediction with a temporal convolutional network. The design is backed by a Runtime Tracker that collects chunk-level execution paths, including dynamic pipeline modifications, through a probe execution. Experiments on TPC-H and TPC-DS report mean Q-Error of 1.46 and 1.84 respectively, better than the compared learned baselines.

What carries the argument

The central object is the data-flow tree: a tree built by merging the execution paths of data chunks collected during probe execution, so that both pre- and post-modification pipeline states coexist as branches. Around this backbone, the Graph Constructor adds resource-competition edges among operators in the same CPU, memory, or I/O resource class, with an attention mechanism that reweights competition intensity from the tree structure. A Graph Attention Network (GAT), a neural architecture for graph-structured data, then recalibrates each operator's predicted cost vector, and a Temporal Convolutional Network (TCN), a convolution over tree structures, aggregates the recalibrated vectors bottom-up into a query latency prediction. The whole pipeline from graph construction to latency is differentiable, so the calibrator and aggregator are trained jointly on query-level latency.

What would settle it

A direct falsifier is a workload in which pipeline modifications are triggered only after the probe window closes, for example by injecting a cardinality underestimate that the optimizer discovers mid-query. If CONCERTO's mean Q-Error then rises to or above the best baseline's, the probe-driven data-flow tree is not sufficient for general dynamic execution and the accuracy claim only holds for early modifications.

Watch

Extended reading notes

Core claim

CONCERTO's central discovery is that the accuracy bottleneck for learned query cost estimation on high-performance OLAP systems is not operator cost itself but the interaction between concurrent operators in a parallel DAG pipeline, and that this interaction can be modeled separately. The authors demonstrate that decomposing prediction into three differentiable stages—an operator cost predictor, a graph-attention resource-competition calibrator, and a tree-convolution aggregator—yields substantially lower Q-Error than end-to-end tree or graph models such as QPPNet, QueryFormer, GCN, TCN, and RAAL. The data-flow tree, built from probe-phase chunk execution paths, is the key representation: it preserves both the original and dynamically modified pipelines by expanding the time dimension of execution into the spatial tree structure, which is what lets the model see modifications that a static EXPLAIN plan would miss.

Load-bearing premise

Dynamic pipeline changes that materially affect a query's latency all happen early enough for a short probe execution of the first few data chunks to reveal them, so the data-flow tree built from probe paths represents the full execution.

Editorial extensions

If this is right

  • On TPC-H and TPC-DS, CONCERTO reports the lowest mean, median, and tail Q-Error among the compared methods, with the ablation showing the resource attention mechanism contributing the largest accuracy gain.
  • Because prediction is decoupled from operator cost, the method is claimed to generalize across query templates and cope with workload drift, while keeping model size (0.094 MB) and inference time (4.2 ms) smaller than the baselines.
  • The probe-based data-flow tree is claimed to capture cardinality-error-driven dynamic modifications that occur early in execution, which is where the authors argue such pipeline changes concentrate.
  • The design is intended to be portable to other DAG-pipeline OLAP systems such as SparkSQL and DuckDB, since the Runtime Tracker needs only a serial executor or a DOP knob plus access to chunk execution paths.
  • The documented probe overhead (about 155 ms on TPC-DS) is small relative to OLAP query times, making the approach practical for production admission control and resource management.

Reading between the lines

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

  • If the probe assumption holds, the same data-flow-tree representation could serve other dynamic-engine tasks besides QPP, such as plan debugging or feeding an adaptive optimizer with the actual executed paths rather than the planned ones.
  • The robustness experiment shows CONCERTO's mean Q-Error rising from 1.46 to 2.59 under σ=1.5 cardinality noise while QueryFormer stays near 1.6, so CONCERTO's lead depends on early access to accurate cardinality; a system with worse early estimates would likely erode that advantage.
  • Because the attention weights that set competition intensity are learned from the tree structure, a natural test is whether those learned intensities transfer to different hardware configurations (fewer cores, smaller cache); if not, they would need per-hardware re-training.
  • The paper's stated future direction is a cross-DBMS plugin; a concrete extension would be to replace the ClickHouse-specific tracer with a generic profiler hook so that the same three-stage predictor works on SparkSQL and DuckDB without redesign.
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

4 major / 5 minor

Summary. CONCERTO proposes a multi-stage learned query performance prediction (QPP) method aimed at modern OLAP DBMSs with vectorized operators, parallel DAG pipelines, and dynamic pipeline modifications. The system decouples per-operator resource-cost prediction (Stage 1, via lightweight MLPs called OCPs), calibration of parallel-execution resource contention (Stage 2, via a data-flow tree, hand-constructed resource-competition matrices, an attention mechanism, and a GAT), and bottom-up latency aggregation (Stage 3, via a TCN). A Runtime Tracker collects chunk-level execution paths in a probe execution mode and supports serial-executor training data. Experiments on TPC-H and TPC-DS (scale factor 1, implemented on ClickHouse) report mean Q-Errors of 1.46 and 1.84, respectively, improving over adapted baselines, with ablations showing the resource-attention and OCP components contribute. The paper candidly states that the probe phase cannot capture dynamic modifications arising from system-load variations, and the robustness experiment shows large accuracy degradation under strong cardinality perturbations.

Significance. If the claims are substantiated, CONCERTO addresses a genuine gap: most learned QPP methods target static tree-shaped plans, while ClickHouse-style engines use dynamic parallel DAG pipelines. The strengths are the clean decomposition of operator-cost prediction, contention calibration, and latency aggregation; the design of a Runtime Tracker that exposes chunk execution paths; and ablations indicating that the attention-based calibration and OCPs both matter. The reported model size and inference latency are attractive. However, the central accuracy claim is conditional on two yet-unverified premises: that the probe execution phase captures the dynamic modifications relevant to the evaluated workloads, and that the baseline comparisons are fair when all baselines are adapted to CONCERTO's own data-collection format. The robustness result in Table IV also materially qualifies the headline claim.

major comments (4)
  1. [Section V.B and Algorithm 1] The probe execution mode is the sole source of the data-flow tree used at inference, yet the manuscript explicitly concedes that it 'cannot capture all dynamic modifications... particularly those stemming from system load variations' and justifies this by asserting that cardinality-error-driven modifications 'typically occur during the early stages of query execution.' No measurement of modification timing or frequency is reported for TPC-H or TPC-DS. If a join-algorithm switch or sort insertion occurs after the probe, Algorithm 1 constructs a tree containing only the pre-modification paths, so the calibrated cost vectors and TCN aggregation describe a query that was not actually executed. This concern is reinforced by Table IV, where CONCERTO's mean Q-Error degrades sharply from 1.46 to 2.59 as cardinality perturbation increases, exactly the regime in which late modifications would be triggered. Please instrument ClickHouse to log all dynamic modifications and report (i) how often modifications occur in the test workloads, (ii) their timing relative to the probe window, and (iii) sensitivity to the number of probe chunks, or otherwise demonstrate that the evaluated workloads contain no late modifications that affect the predictions.
  2. [Section VI.A and Table II] All baselines are evaluated on data collected by CONCERTO's Runtime Tracker: the paper states 'We used their open-source code and modified it to adapt the data collected by CONCERTO's Runtime Tracker from ClickHouse.' Methods such as QPPNet and QueryFormer are designed for planner plan trees with cardinality estimates, not for chunk-level runtime execution paths; feeding them CONCERTO's feature set can disadvantage them independently of their modeling quality. In addition, MB2 [9], the closest prior two-level decomposed QPP method, is discussed in Related Work but is not included in the comparison. Please add MB2 and either evaluate baselines with their native plan representations or carefully justify and validate the adaptation, for example by ablating input-feature choices on at least one baseline to show that the reported gaps are not artifacts of feature adaptation.
  3. [Table IV and Abstract] The robustness experiment contradicts the unqualified abstract claim that 'CONCERTO achieves higher prediction accuracy than existing methods.' At sigma=1.5, CONCERTO's mean Q-Error is 2.59, whereas QueryFormer achieves 1.61 and RAAL 2.30; the paper itself concludes that 'its robustness remains to be improved under larger cardinality estimation errors.' The abstract and conclusion should be restricted to the unperturbed setting, or the robustness boundary should be characterized and explained. Moreover, the improvements over TCN and QueryFormer on TPC-H are modest (mean Q-Error 1.46 versus 1.60), and no confidence intervals, seed counts, or significance tests are reported for Tables II and IV, so it is difficult to assess whether the differences are stable.
  4. [Section VI.A (workload split)] The workload-split description is internally inconsistent: the paper says 4 held-out TPC-H templates are '23.5%' of the workload, but 4/22 is 18.2%, and the TPC-DS list contains 10 template indices while the text says 9 templates (15.52%). This prevents a reader from reproducing the exact train/test split and should be corrected, with the full list of training and test template indices provided.
minor comments (5)
  1. [Algorithm 1] In the pseudocode, line 19 creates a node for 'child operator' but it should create a node for the current operator; line 2 contains the typo 'spilt' for 'split'.
  2. [Section IV.A] The abbreviation for Operator Cost Predictor is introduced as OCP, but the text later uses 'OPCs' in several places; the abbreviation should be used consistently.
  3. [Section IV.B] The construction of the meta resource-competition matrices Mc, Mm, and Mio is described only qualitatively ('based on both code implementation and the number of their CPU instructions, memory cost, and I/O times'); the exact procedure, normalization, and threshold choices should be specified so the experiment can be reproduced.
  4. [Section VI.C] The performance comparison in Table III reports only model inference time, not end-to-end prediction overhead including the probe execution phase; the authors state the TPC-DS probe overhead is about 155ms, but the corresponding TPC-H figure and its share of total query latency are not reported.
  5. [General] No code or data availability statement is provided; given the substantial system-engineering component (Runtime Tracker, serial executor, ClickHouse modifications), a release or detailed artifact description would significantly improve reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: CONCERTO's three-stage pipeline is trained on independent operator-cost labels and held-out query latencies, with hand-constructed resource-competition matrices and no load-bearing self-citation chain.

full rationale

The paper's derivation chain is self-contained. Stage 1 OCPs are trained on serial-executor operator resource costs collected in full-collection mode, independently of query-level latency labels (Section V.B, 'Data for OCPs'). Stage 2's meta resource-competition matrices are hand-constructed from operator code analysis and relative cost evaluation (Section IV.B), not fitted to the target query latency; the GAT attention mechanism adapts these matrices but is trained together with the TCN on held-out query templates, with test templates explicitly stated as 'will not appear in the training workloads' (Section VI.A). Stage 3's TCN aggregates calibrated cost vectors and is trained with the GAT on normalized ground-truth query latency, which is a standard supervised generalization setup, not a reduction to inputs. The probe execution mode uses a small prefix of actual execution as input features, but this is early-observation-based prediction rather than circularity: the target is full-query latency, the probe covers only 'a few chunks,' and the model must still generalize to unseen remainder execution. The paper's own stated limitation that probe mode 'cannot capture all dynamic modifications occurring throughout the entirety of query execution' is an unverified robustness assumption, not a circular step. I found no self-citation that carries a load-bearing claim, no fitted parameter renamed as a prediction, and no uniqueness theorem imported from the authors' prior work. The comparison against external baselines on shared Runtime Tracker data further supports that the reported accuracy gains have independent content.

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

The central claim rests primarily on two hand-constructed modeling inputs (operator-type resource competition matrices and per-operator feature selection) plus the untested assumption that probe execution captures relevant dynamic pipeline changes. No new physical entities are introduced.

free parameters (3)
  • Meta resource competition matrices Mc, Mm, Mio = not disclosed
    Hand-constructed from code analysis and relative resource cost evaluation (Section IV-B, Figure 2); they define which operator types compete for CPU, memory, and I/O, shaping the input graph and attention weights.
  • Operator feature sets = not enumerated
    The paper selects 'parameters that have the most significant influence on their cost' per operator (Section IV-A) without giving the full list; this manual choice directly affects OCP accuracy.
  • Probe execution chunk count = unspecified
    Probe mode runs 'until the first few result chunks are collected' (Section V.B); the number of chunks determines the data-flow tree richness and tracker overhead, but is not reported.
assumptions (5)
  • domain assumption Serial-executor per-operator costs are a valid proxy for operator cost in parallel execution in the absence of contention.
    OCPs are trained on serial executor data (Section V.B) and GAT later calibrates for contention; this separability is assumed, not validated directly.
  • domain assumption Probe execution captures the dynamic pipeline modifications that matter for predicting query latency.
    Section V.B states that modifications from cardinality-estimation errors occur early and are caught by the probe phase, but this is an assumption about workload behavior.
  • domain assumption Pairwise operator-type resource competition matrices, expanded to the data-flow tree, summarize the relevant contention.
    Section IV-B constructs meta matrices and relies on attention to adjust intensities; pairwise summaries may miss higher-order contention effects.
  • domain assumption ClickHouse's execution mechanisms are representative of high-performance OLAP DBMSs.
    Evaluation is only on ClickHouse (Section VI.A); portability to SparkSQL, Databricks, DuckDB is asserted from Table I but not demonstrated.
  • domain assumption The data-flow tree built from probe chunk paths preserves the information needed for latency prediction.
    Algorithm 1 merges chunk execution paths into a tree, expanding time into space; this assumes no critical timing/overlap information is lost.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CONCERTO: Complex Query Execution Mechanism-Aware Learned Cost Estimation." pith.science (2026). https://pith.science/paper/44R5JSFL

@misc{pith2026241200749,
  author       = {Pith},
  title        = {Pith review of: CONCERTO: Complex Query Execution Mechanism-Aware Learned Cost Estimation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/44R5JSFL}},
  note         = {Machine review of arXiv:2412.00749}
}
read the original abstract

With the growing demand for massive data analysis, many DBMSs have adopted complex underlying query execution mechanisms, including vectorized operators, parallel execution, and dynamic pipeline modifications. However, there remains a lack of targeted Query Performance Prediction (QPP) methods for these complex execution mechanisms and their interactions, as most existing approaches focus on traditional tree-shaped query plans and static serial executors. To address this challenge, this paper proposes CONCERTO, a Complex query executiON meChanism-awaE leaRned cosT estimatiOn method. CONCERTO first establishes independent resource cost models for each physical operator. It then constructs a Directed Acyclic Graph (DAG) consisting of a dataflow tree backbone and resource competition relationships among concurrent operators. After calibrating the cost impact of parallel operator execution using Graph Attention Networks (GATs) with additional attention mechanisms, CONCERTO extracts and aggregates cost vector trees through Temporal Convolutional Networks (TCNs), ultimately achieving effective query performance prediction. Experimental results demonstrate that CONCERTO achieves higher prediction accuracy than existing methods.

Figures

Figures reproduced from arXiv: 2412.00749 by the authors.

Figure 1
Figure 1. Overview of CONCERTO, which shows the process of data collection, training, and prediction. [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Illustration of ClickHouse’s physical operators’ rela [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. Illustration of dynamic modification. The Join operator [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Illustration of the structure of the Runtime Tracker. The Serial Executor in dotted lines needs to be modified from the DBMS’s parallel executor if the DBMS does not provide a serial execution mode like SparkSQL does. As shown in [PITH_FULL_IMAGE:figures/full_fig_p008…
Figure 5
Figure 5. Figure 5: Q-Error distribution comparison. to high-performance OLAP DBMSs, and the resource-aware mechanism is crucial in them. In order to more intuitively compare the error distribution between different methods, we grouped the methods by latency range and plotted the accuracy…
Figure 6
Figure 6. Figure 6: Q-Error distribution grouped by queries’ latency. Box [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 8
Figure 8. Figure 8: Distribution of generated Q-Error with log-scale x-axis. [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]
Figure 9
Figure 9. Figure 9: Robustness Q-Error distribution comparison. [PITH_FULL_IMAGE:figures/full_fig_p012_9.png]
Figure 7
Figure 7. Figure 7: Q-Error with a standard error during training. [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

42 extracted references · 28 canonical work pages

  1. [9]

    & Pavlo, A

    Ma, L., Zhang, W., Jiao, J., Wang, W., Butrovich, M., Lim, W., Menon, P. & Pavlo, A. MB2: Decomposed Behavior Modeling for Self-Driving Database Management Systems. Proceedings Of The 2021 International Conference On Management Of Data . (2021), https://api.semanticscholar.org/CorpusID:235474580

    work page 2021

  2. [1]

    & Kersten, M

    Manegold, S., Boncz, P. & Kersten, M. Generic Database Cost Models for Hierarchical Memory Systems. Sigmod Record. pp. 191-202 (2002,12)

    work page 2002

  3. [2]

    & Blanas, S

    Liu, F. & Blanas, S. Forecasting the cost of processing multi-join queries via hashing for main-memory databases. Proceedings Of The Sixth ACM Symposium On Cloud Computing . pp. 153-166 (2015), https://doi.org/10.1145/2806777.2806944

    work page arXiv 2015

  4. [3]

    & Neumann, T

    Leis, V ., Gubichev, A., Mirchev, A., Boncz, P., Kemper, A. & Neumann, T. How good are query optimizers, really?. Proc. VLDB Endow.. 9, 204- 215 (2015,11), https://doi.org/10.14778/2850583.2850594

    arXiv 2015

  5. [4]

    & Tatbul, N

    Marcus, R., Negi, P., Mao, H., Zhang, C., Alizadeh, M., Kraska, T., Papaemmanouil, O. & Tatbul, N. Neo: a learned query optimizer. Proc. VLDB Endow. . 12, 1705-1718 (2019,7), https://doi.org/10.14778/3342263.3342644

    arXiv 2019

  6. [5]

    & Jordan, M

    Bach, F. & Jordan, M. Kernel Independent Component Analysis. Journal Of Machine Learning Research . 3 pp. 1-48 (2003,3)

    work page 2003

  7. [6]

    & Patterson, D

    Ganapathi, A., Kuno, H., Dayal, U., Wiener, J., Fox, A., Jordan, M. & Patterson, D. Predicting Multiple Metrics for Queries: Bet- ter Decisions Enabled by Machine Learning. 2009 IEEE 25th In- ternational Conference On Data Engineering . pp. 592-603 (2009), https://api.semanticscholar.org/CorpusID:8609713

    work page 2009

  8. [7]

    & Cui, B

    Huang, S., Qin, Y ., Zhang, X., Tu, Y ., Li, Z. & Cui, B. Survey on performance optimization for database systems. Science China Information Sciences . 66 pp. 1-23 (2023), https://api.semanticscholar.org/CorpusID:255760761

    work page 2023

Show all 42 references
  1. [8]

    & Upfal, E

    Akdere, M., Cetintemel, U., Riondato, M. & Upfal, E. Learning-based Query Performance Modeling and Prediction. (2012,4)

    2012

  2. [10]

    & Miao, C

    Zhao, Y ., Cong, G., Shi, J. & Miao, C. QueryFormer: a tree transformer model for query plan representation. Proc. VLDB Endow.. 15, 1658-1670 (2022,4), https://doi.org/10.14778/3529337.3529349

    2022

  3. [11]

    & Papaemmanouil, O

    Marcus, R. & Papaemmanouil, O. Plan-Structured Deep Neural Network Models for Query Performance Prediction. Proc. VLDB Endow. . 12 pp. 1733-1746 (2019), https://api.semanticscholar.org/CorpusID:59553521

    2019

  4. [12]

    & Feng, J

    Zhou, X., Sun, J., Li, G. & Feng, J. Query performance pre- diction for concurrent queries using graph embedding. Proceed- ings Of The VLDB Endowment . 13 pp. 1416 - 1428 (2020), https://api.semanticscholar.org/CorpusID:219557876

    2020

  5. [13]

    Sun, J. & Li, G. An End-to-End Learning-based Cost Estimator. Proc. VLDB Endow. . 13 pp. 307-319 (2019), https://api.semanticscholar.org/CorpusID:174802790

    2019

  6. [14]

    & Naughton, J

    Wu, W., Wu, X., Hacıg ¨um¨us ¸, H. & Naughton, J. Uncertainty Aware Query Execution Time Prediction. ArXiv. abs/1408.6589 (2014), https://api.semanticscholar.org/CorpusID:3121164

    2014 arXiv

  7. [15]

    & Naughton, J

    Wu, W., Chi, Y ., Zhu, S., Tatemura, J., Hacıg ¨um¨us ¸, H. & Naughton, J. Predicting query execution time: Are optimizer cost models really unusable?. 2013 IEEE 29th International Conference On Data Engineering (ICDE) . pp. 1081-1092 (2013), https://api.semanticscholar.org/Co...

    2013

  8. [16]

    & Naughton, J

    Wu, W., Chi, Y ., Hacıg ¨um¨us ¸, H. & Naughton, J. Towards Predicting Query Execution Time for Concurrent and Dynamic Database Workloads. Proc. VLDB Endow. . 6 pp. 925-936 (2013), https://api.semanticscholar.org/CorpusID:7995298

    2013

  9. [17]

    & Peng, Z

    Li, Y ., Wang, L., Wang, S., Sun, Y . & Peng, Z. A Resource-Aware Deep Cost Model for Big Data Query Processing. 2022 IEEE 38th International Conference On Data Engineering (ICDE) . pp. 885-897 (2022), https://api.semanticscholar.org/CorpusID:251293463

    2022

  10. [18]

    & Welling, M

    Kipf, T. & Welling, M. Semi-supervised classification with graph convolutional networks. ArXiv Preprint arXiv:1609.02907 . (2016)

    2016 arXiv

  11. [19]

    Deep Learning using Rectified Lin- ear Units (ReLU)

    Agarap, A. Deep Learning using Rectified Lin- ear Units (ReLU). ArXiv. abs/1803.08375 (2018), https://api.semanticscholar.org/CorpusID:4090379

    2018 arXiv

  12. [20]

    & Milovidov, A

    Schulze, R., Schreiber, T., Yatsishin, I., Dahimene, R. & Milovidov, A. ClickHouse-Lightning Fast Analytics for Everyone

  13. [21]

    & Bengio, Y

    Veli ˇckovi´c, P., Cucurull, G., Casanova, A., Romero, A., Lio, P. & Bengio, Y . Graph attention networks. ArXiv Preprint arXiv:1710.10903 . (2017)

    2017 arXiv

  14. [22]

    & Naughton, J

    Wu, W., Chi, Y ., Zhu, S., Tatemura, J., Hacig ¨um¨us, H. & Naughton, J. Predicting query execution time: Are optimizer cost models really unus- able?. 2013 IEEE 29th International Conference On Data Engineering (ICDE). pp. 1081-1092 (2013)

    2013

  15. [23]

    & Chaudhuri, S

    Li, J., K ¨onig, A., Narasayya, V . & Chaudhuri, S. Robust estimation of resource consumption for sql queries using statistical techniques. ArXiv Preprint arXiv:1208.0278. (2012)

    2012 arXiv

  16. [24]

    & Binnig, C

    Hilprecht, B. & Binnig, C. Zero-shot cost models for out-of-the-box learned cost prediction. ArXiv Preprint arXiv:2201.00561 . (2022)

    2022 arXiv

  17. [25]

    & Tatemura, J

    Chi, Y ., Moon, H., Hacig ¨um¨us ¸, H. & Tatemura, J. SLA-tree: a framework for efficiently supporting SLA-based decisions in cloud computing. Proceedings Of The 14th International Con- ference On Extending Database Technology . pp. 129-140 (2011), https://doi.org/10.1145/1951...

    2011

  18. [26]

    & Aboulnaga, A

    Tozer, S., Brecht, T. & Aboulnaga, A. Q-Cop: Avoiding bad query mixes to minimize client timeouts under heavy loads. 2010 IEEE 26th International Conference On Data Engineering (ICDE 2010) . pp. 397- 408 (2010)

    2010

  19. [27]

    & DeWitt, D

    Taft, R., Lang, W., Duggan, J., Elmore, A., Stonebraker, M. & DeWitt, D. STeP: Scalable Tenant Placement for Manag- ing Database-as-a-Service Deployments. Proceedings Of The Sev- enth ACM Symposium On Cloud Computing . pp. 388-400 (2016), https://doi.org/10.1145/2987550.2987575

    2016

  20. [28]

    & Peng, Y

    Lan, H., Bao, Z. & Peng, Y . A Survey on Advancing the DBMS Query Optimizer: Cardinality Estimation, Cost Model, and Plan Enu- meration. Data Science And Engineering . 6 pp. 86 - 101 (2021), https://api.semanticscholar.org/CorpusID:230523630

    2021

  21. [29]

    & Polosukhin, I

    Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A., Kaiser, Ł. & Polosukhin, I. Attention is all you need. Proceedings Of The 31st International Conference On Neural Information Processing Systems. pp. 6000-6010 (2017)

    2017

  22. [30]

    & Jin, Z

    Mou, L., Li, G., Zhang, L., Wang, T. & Jin, Z. Convolutional neural networks over tree structures for programming language processing. Proceedings Of The Thirtieth AAAI Conference On Artificial Intelligence . pp. 1287-1293 (2016)

    2016

  23. [31]

    & Nes, N

    Boncz, P., Zukowski, M. & Nes, N. MonetDB/X100: Hyper-Pipelining Query Execution. Conference On Innovative Data Systems Research . (2005), https://api.semanticscholar.org/CorpusID:1379707

    2005

  24. [32]

    & M ¨uhleisen, H

    Raasveldt, M. & M ¨uhleisen, H. DuckDB: an Embeddable Analytical Database. Proceedings Of The 2019 International Conference On Management Of Data . pp. 1981-1984 (2019), https://doi.org/10.1145/3299869.3320212

    2019

  25. [33]

    & Rowe, L

    Stonebraker, M. & Rowe, L. The design of POSTGRES. Proceedings Of The 1986 ACM SIGMOD International Conference On Management Of Data. pp. 340-355 (1986), https://doi.org/10.1145/16894.16888

    1986

  26. [34]

    & Zdonik, S

    Akdere, M., C ¸ etintemel, U., Riondato, M., Upfal, E. & Zdonik, S. Learning-based Query Performance Modeling and Prediction. 2012 IEEE 28th International Conference On Data Engineering . pp. 390-401 (2012)

    2012

  27. [35]

    & Chaudhuri, S

    Li, J., K ¨onig, A., Narasayya, V . & Chaudhuri, S. Robust es- timation of resource consumption for SQL queries using sta- tistical techniques. Proc. VLDB Endow. . 5, 1555-1566 (2012,7), https://doi.org/10.14778/2350229.2350269

    2012

  28. [36]

    & Stoica, I

    Yang, Z., Liang, E., Kamsetty, A., Wu, C., Duan, Y ., Chen, X., Abbeel, P., Hellerstein, J., Krishnan, S. & Stoica, I. Deep unsupervised cardinality estimation. Proc. VLDB Endow. . 13, 279-292 (2019,11), https://doi.org/10.14778/3368289.3368294

    2019

  29. [37]

    & Ponomaryov, D

    Vasilenko, N., Demin, A. & Ponomaryov, D. Adaptive Cost Model for Query Optimization. (2024), https://arxiv.org/abs/2409.17136

    2024 arXiv

  30. [38]

    & Others Adaptive and Robust Query Execu- tion for Lakehouses at Scale

    Xue, M., Chen, S., Lam, A., Li, Y ., Bu, Y ., Hovell, H., Ma, Y ., Li, X., Paranjpye, S., Somani, A. & Others Adaptive and Robust Query Execu- tion for Lakehouses at Scale. Proceedings Of The VLDB Endowment . 17, 3947-3959 (2024)

    2024

  31. [39]

    & Diao, Y

    Lyu, C., Fan, Q., Guyard, P. & Diao, Y . A Spark Optimizer for Adaptive, Fine-Grained Parameter Tuning. Proceedings Of The VLDB Endowment . 17, 3565-3579 (2024,7), http://dx.doi.org/10.14778/3681954.3682021

    2024

  32. [40]

    & Others Impala: A Modern, Open-Source SQL Engine for Hadoop

    Kornacker, M., Behm, A., Bittorf, V ., Bobrovytsky, T., Ching, C., Choi, A., Erickson, J., Grund, M., Hecht, D., Jacobs, M. & Others Impala: A Modern, Open-Source SQL Engine for Hadoop.. Cidr. 1 pp. 9 (2015)

    2015

  33. [41]

    & Boncz, P

    Zukowski, M., Wiel, M. & Boncz, P. Vectorwise: A Vectorized An- alytical DBMS. 2012 IEEE 28th International Conference On Data Engineering. pp. 1349-1350 (2012)

    2012

  34. [42]

    & Sun, J

    He, K., Zhang, X., Ren, S. & Sun, J. Deep residual learning for image recognition. Proceedings Of The IEEE Conference On Computer Vision And Pattern Recognition. pp. 770-778 (2016)

    2016

Pith tools

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