Pith. sign in

REVIEW 3 major objections 8 minor 42 references

SINT-Flow: Schema Integration using Large Language Model Workflows

T0 review · 3 major / 8 minor · reviewed 2026-07-31 · grok-4.5

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

Pith's one-line read Five LLM operators, wired into workflows, can fully automate schema integration and split denormalized multi-entity tables into entity-specific relations.

desk verdict Solid systems paper: real multi-entity splitting plus a usable benchmark, with headline F1s that rest on soft overlap alignment to author GT. read the letter →

arxiv 2607.24492 v1 pith:HDWFFP56 submitted 2026-07-27 cs.CL

Keti Korini , Christian Bizer This is my paper · ORCID
classification cs.CL
keywords SchemaIntegrationInferenceManagementBenchmarkLargeLanguageModelsTableSplittingMatchingSelf-Consistency
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

Schema integration asks for one coherent global schema that covers every concept, attribute, and relationship in a set of heterogeneous source tables. Existing methods are either semi-automatic or leave denormalized tables that mix several entity types as a single flat relation. This paper claims that a small set of large-language-model operators—table splitting, schema matching with a review loop, table grouping, attribute merging, and integrated-schema output—can be composed into end-to-end workflows that both unify attributes and decompose multi-entity tables into separate entity-specific relations linked by generated keys. On a new ten-task benchmark of 93 tables built for this setting, the best workflow per model reaches at least 96% F1 on entity-type detection, 85% on attribute assignment, and 83% on mapping source columns to the integrated attributes. Self-consistency across three operator runs and a post-match review loop measurably lift those scores, showing that structured prompting plus lightweight verification is enough to turn general-purpose LLMs into fully automatic schema integrators without human review or classical functional-dependency mining.

What carries the argument

Five composable LLM operators (Table Splitting, Schema Matching with a post-match review loop, Table Grouping, Attribute Merging, Integrated Schema Output), run under a self-consistency strategy that merges three high-temperature runs by majority vote or co-occurrence, arranged into three alternative workflows that differ mainly in when entity types are detected.

What would settle it

Run the same workflows on a held-out collection of real multi-entity tables whose integrated schemas and column-to-type assignments were fixed by independent database designers (not the authors), and check whether entity-type, attribute, and mapping F1 stay at or above the reported 96/85/83 thresholds; a clear drop falsifies the claim that the operators generalize.

Watch

Extended reading notes

Core claim

SINT-Flow shows that fully automated end-to-end schema integration—including decomposition of denormalized tables that describe multiple entity types—is achievable by composing five LLM operators into workflows. On SINT-Bench the best workflow per backbone reaches F1 of at least 96% for entity-type detection, 85% for attribute detection, and 83% for mapping input columns onto the integrated attributes, without instance-level transforms or entity deduplication.

Load-bearing premise

Entity types and which columns belong to them can be recovered reliably from column headers plus the first ten example rows by prompting an LLM, without discovering functional dependencies, and the hand-built benchmark ground truth is a fair external yardstick for that recovery.

Editorial extensions

If this is right

  • Data lakes that store wide denormalized extracts can be automatically normalized into entity-specific relations with foreign keys before analytics or ML.
  • Schema integration pipelines no longer require a human in the loop for entity-type discovery or attribute unification on the scale of tens of tables.
  • Open-weight models of moderate size can substitute for hosted models when privacy rules forbid sending tables off-premise, at comparable mapping F1.
  • Self-consistency plus a cheap match-review loop become standard reliability layers for any multi-step LLM data-preparation workflow.
  • New schema-integration benchmarks must supply per-table entity-type and column-assignment ground truth, not only flat attribute correspondences.

Reading between the lines

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

  • The same operator kit could be reused for ontology learning from relational dumps by treating the integrated entity types as classes and the foreign keys as object properties.
  • Because table splitting never uses classical FD miners, the method may degrade on tables whose entity boundaries are purely statistical and invisible from ten sample rows and headers alone—suggesting a hybrid FD-plus-LLM variant as a natural next test.
  • Workflow choice (split-per-table vs split-on-integrated-table) tracking model family hints that prompt-budget and long-context skill, not just raw accuracy, should guide which workflow is shipped in a product.
  • If mapping F1 remains high when column headers are ablated, the approach would transfer to header-less web tables; the paper leaves that ablation open.
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 / 8 minor

Summary. The paper presents SINT-Flow, a framework of five LLM-based operators (Table Splitting, Schema Matching, Table Grouping, Attribute Merging, Integrated Schema Output) that can be sequenced into three end-to-end schema integration workflows. The distinguishing capability over prior work is the splitting of denormalized input tables that describe multiple entity types into entity-specific relations before/while deriving an integrated schema with foreign keys. The authors also introduce SINT-Bench, 10 integration tasks (93 tables, eight with ≥2 entity types per table) with ground truth for table splitting, grouping, matching, and the integrated schema. Evaluated with GPT-5.2 and Qwen-3.6-27B, the best workflow per model reaches F1 ≥ 0.96 for entity-type detection, ≥ 0.85 for attribute detection, and ≥ 0.83 for column-to-integrated-attribute mappings. Ablations attribute +3–13% mapping F1 to self-consistency over 3 runs and +5%/+10% (attributes/mappings) to a post-matching LLM review loop. The Schema Matching Operator is further compared to COMA, ALITE (TURL/Qwen embeddings), and SI-LLM on SINT-Bench and the external Real Benchmark, where it outperforms all baselines on attribute grouping.

Significance. If the results hold, the paper makes two useful contributions. First, SINT-Flow is, to my knowledge, the first fully automated schema integration method that splits denormalized multi-entity tables into entity-specific relations as part of integration; the five-operator design and the finding that workflow 2 (implicit matching) underperforms workflows with an explicit matching step are informative for the growing literature on LLM-based data preparation. Second, SINT-Bench fills a real gap: no existing tabular integration benchmark includes table-splitting ground truth, and the benchmark covers 10 tasks / 93 tables with per-operator ground truth, enabling error-propagation analysis. The paper ships reproducible artifacts (code, data, prompts on GitHub), per-operator evaluations, an error taxonomy with concrete examples (Tables 8, 10), runtime/token accounting (Table 5), and ablations of both self-consistency and the review loop. The evaluation on an open-weight model (Qwen-3.6-27B) alongside GPT-5.2 is valuable for privacy-constrained deployment scenarios. These are exactly the ingredients needed for the community to build on the work.

major comments (3)
  1. [§6, Evaluation Metrics] The headline numbers (96/85/83% F1) depend entirely on an alignment procedure that is under-specified. Predicted entity types are mapped to GT types 'based on the overlap between attributes assigned to the types,' and predicted attributes are mapped to GT attributes 'using the overlap between column values of columns mapped to these attributes.' No overlap measure (Jaccard? containment?), threshold, tie-breaking rule, or assignment algorithm (greedy vs. optimal matching) is given. Two concrete risks: (i) a structurally wrong split (e.g., an over-merged 'EventVenue' or an over-split 'Contact') can still align to whichever GT type it overlaps most, converting a structural error into partial credit on all three reported aspects; (ii) value-overlap alignment is unreliable exactly in the regime the paper itself documents — Table 10 shows columns with overlapping values but different semantics
  2. [§5, Data Collection; §2.1] The ground truth embeds several author choices that interact with the method's own design, and their effect on the reported F1 is not quantified. (a) Headers in the GDS-derived and WikiDBs-derived tasks were renamed 'using an LLM'; LLM-renamed headers are plausibly more legible to LLM priors than organically heterogeneous headers, which could inflate performance relative to naturally occurring tables. (b) The integrated schemata were manually constructed, yet Figure 1 itself shows that multiple integrated schemata (flat vs. entity-decomposed) are legitimate for the same input; the paper reports no inter-annotator agreement or adjudication process, so the objectivity of the yardstick for attribute detection and mappings is unclear. (c) The ≥3-attributes-per-entity-type rule (§2.1) is a method hyperparameter; if the GT entity types were constructed under the same rule, the rule is part of
  3. [§7.4.1, Table 6] The self-consistency ablation confounds the strategy with decoding temperature. The self-consistency setup runs each operator 3 times at high temperature (Qwen: 0.7; GPT-5.2: 1.0) and combines outputs; the 'Avg. 3 runs' baseline runs at temperature 0.001/0. The reported gains (+13% Qwen, +3% GPT-5.2) therefore compare 'majority-vote over diverse samples' against 'low-temperature single decoding,' not against 'high-temperature single decoding' or 'high-temperature averaging without voting.' A run at high temperature without self-consistency is the natural control for isolating the voting contribution. Additionally, comparing one consistent output to the *average* of three individual runs mixes estimator quality with run-to-run variance; please report per-run results at high temperature alongside the consistent output. As the utility of self-consistency is one of the four stated contributi
minor comments (8)
  1. [§7.1, Table 3] Results are only reported as averages over the 10 tasks. Given the small benchmark and the heterogeneity visible in Table 1, a per-task breakdown of Table 3 (at least in an appendix or the repository, with a pointer in the paper) would substantially improve interpretability. Standard deviations are only given for the ablation (Table 6).
  2. [Table 5] Table 5's per-operator column is labeled 'Attribute Grouping' but the operator is called 'Attribute Merging' throughout the text; please make naming consistent. The same inconsistency appears implicitly in Figure 7.
  3. [Figure 3] Figure 3 appears to show the schema-matching prompt twice (the duplicated text block); please check the figure layout.
  4. [Various] Typos: 'aglobal' (§1); 'evaluaiton' (§6); 'attibuted' (§8); 'metods' (§9); 'Inegration' in reference [28]; 'co-occurence' (multiple places); 'Table 1 given an overview' (§5); '% Date' in the Flight Information row of Table 1 is missing the percentage figure.
  5. [§6, Table Serialization] The 10-row prompt sample (§6, Table Serialization) sorts rows by completeness before sampling; this biases the shown instances toward fuller rows. A short ablation or at least a discussion of the sensitivity of Table Splitting to row count/order would be useful, since §2.1 motivates the LLM approach precisely by applicability to small, noisy tables.
  6. [Abstract; Table 3] The abstract's 'at least 96/85/83%' refers to the best workflow per model, but the best workflow differs between models (W1 for GPT-5.2, W3 for Qwen). Please state this explicitly in the abstract; as written, a reader may assume a single configuration achieves all three numbers.
  7. [§7.2] §7.2 reports that 71% of Integrated Output Operator mapping errors are inherited from upstream operators; it would strengthen the error-propagation analysis to report how this percentage was computed (e.g., counterfactual re-runs with GT inputs to downstream operators), which would also quantify the ceiling of each operator in isolation.
  8. [§8, §9] The claim in §8 that no prior work splits denormalized tables by entity type is plausible given the literature, but SI-LLM [40] is quite close (named-entity-column detection); the distinction would be sharper with a concrete example of an input SI-LLM cannot decompose and SINT-Flow can.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: empirical LLM workflows scored against external (author-built) task GT; F1 is measured, not forced by construction.

full rationale

SINT-Flow is a systems paper: five LLM operators are composed into workflows, run on tables, and scored with Precision/Recall/F1 against SINT-Bench ground truth (and, for attribute grouping, the external Real Benchmark). Nothing in the claimed chain reduces an output identity to a fitted input. Self-consistency (§3) is majority/co-occurrence aggregation over three stochastic runs; the review loop (Alg. 1) is a post-hoc match filter—both are procedural and still evaluated against held GT, not identities that make the reported F1 true by definition. There is no uniqueness theorem, no parameter fit renamed as a prediction, and no load-bearing self-citation that substitutes for evidence. Author construction of SINT-Bench and overlap-based alignment of predicted types/attributes to GT (§6) are evaluation-validity concerns, not circular derivation: the workflows do not encode the GT, and soft alignment can inflate or deflate scores without making Eq./claim X equivalent to its inputs. Baseline comparisons (COMA, ALITE, SI-LLM) further anchor the Schema Matching Operator externally. Score 0; steps empty.

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

Load-bearing content is mostly engineering design choices and evaluation conventions, not deep mathematical axioms. The central performance claim rests on LLM competence given headers+samples, author-defined entity-type GT, overlap-based scoring alignment, and several hand-set thresholds (min attributes, row sample size, self-consistency vote of 3). No new physical entities; invented pieces are methodological (operators, benchmark, workflows).

free parameters (4)
  • minimum_attributes_per_entity_type = 3
    Table Splitting keeps an entity type only if ≥3 columns can be assigned; this threshold is chosen to avoid overly narrow tables and directly shapes entity-type recall/precision.
  • prompt_row_sample_size = 10
    Only the first 10 rows (after sorting by fullness) are serialized into prompts; semantics of rare columns may depend on this cutoff.
  • self_consistency_run_count_and_majority = 3 runs; majority / > half co-occurrence
    Each operator is run 3 times; correspondences/groups kept when co-occurrence or vote exceeds half the runs. Ablation shows large F1 sensitivity especially for Qwen.
  • LLM_decoding_temperatures = GPT 1.0 / Qwen 0.7 (main); near-zero for non-SC
    GPT-5.2 temperature=1 (0 for non-SC ablation); Qwen non-thinking defaults temperature=0.7, top_p=0.8, top_k=20 (0.001 without SC). These control diversity of the paths that self-consistency aggregates.
assumptions (5)
  • domain assumption Integrated schemas should satisfy Batini et al. completeness/correctness, minimality, and understandability.
    Stated in §1 as the normative target of schema integration; evaluation proxies this via entity/attribute/mapping F1 rather than human understandability studies.
  • domain assumption LLM background knowledge plus a few example rows can replace functional-dependency discovery for noisy or small tables when assigning columns to entity types.
    Explicit methodological choice in §2.1 rejecting FD algorithms because quality depends on data size/quality.
  • domain assumption Semantic column correspondence can be judged pairwise by an LLM and refined by a second-pass reviewer that checks cross-links within emerging attribute groups.
    Core of Schema Matching Operator and Algorithm 1; ablation treats the loop as performance-critical.
  • ad hoc to paper Predicted entity types and integrated attributes may be aligned to ground truth via overlap of assigned attributes or mapped column values before computing P/R/F1.
    Evaluation protocol in §6; this alignment step is necessary for string-level naming variance but can soften errors.
  • domain assumption Standard precision/recall/F1 on correspondences, groupings, and mappings are adequate proxies for integration quality (no human UX study of understandability).
    Throughout §6–7; Batini understandability is not directly measured.
invented entities (3)
  • SINT-Flow five operators (Table Splitting, Schema Matching, Table Grouping, Attribute Merging, Integrated Schema Output)
    purpose: Decompose end-to-end schema integration into composable LLM tools with verification hooks.
    Framework contribution of §2; not claimed as natural kinds beyond the method.
  • SINT-Bench (10 tasks, 93 tables, multi-entity splitting GT) independent evidence
    purpose: Provide the first schema-integration benchmark with per-table entity-type and attribute-assignment ground truth plus integrated schemas with FKs.
    Introduced in §5 from GOBY, GDS, Join Benchmark, WikiDBs, and Dataset Search tables with author processing.
  • Three named workflows (entity detection on inputs; implicit matching; entity detection on integrated table)
    purpose: Test operator ordering effects, especially when splitting happens early vs on a unified intermediate table.
    §4; empirical comparison object rather than a discovered natural law.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SINT-Flow: Schema Integration using Large Language Model Workflows." pith.science (2026). https://pith.science/paper/HDWFFP56

@misc{pith2026260724492,
  author       = {Pith},
  title        = {Pith review of: SINT-Flow: Schema Integration using Large Language Model Workflows},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/HDWFFP56}},
  note         = {Machine review of arXiv:2607.24492}
}
read the original abstract

The goal of schema integration is, given a set of input schemata or tables, to derive a global, unified schema that is able to represent the concepts, attributes, and relationships of all input tables in a coherent fashion. This paper presents SINT-Flow, a schema integration framework composed of five LLM-based operators that can be combined into workflows to perform fully automated, end-to-end schema integration. In contrast to existing approaches, SINT-Flow can process denormalized source tables that contain attributes describing multiple entity types. During the schema integration process, these tables are decomposed into separate entity-specific relations. To evaluate SINT-Flow, we introduce SINT-Bench, a schema integration benchmark comprising 10 schema integration tasks consisting of altogether 93 relational tables, including tables that describe multiple types of entities. We evaluate SINT-Flow using GPT-5.2 as well as the open-weight model Qwen-3.6-27B as alternative backbone models. Using these models, SINT-Flow achieves F1 scores of at least 96% for entity-type detection, 85% for attribute detection, and 83% for schema mapping. Furthermore, we perform an ablation study to prove the utility of the applied self-consistency strategy as well as the inclusion of a review loop into the schema matching operator.

Figures

Figures reproduced from arXiv: 2607.24492 by the authors.

Figure 1
Figure 1. Example of a schema integration task consisting of [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 3
Figure 3. Schema Matching Prompt: an example. tables which refer to the same semantic concept. Based on previous work on schema matching for tabular data [26], we prompt the LLM to find the matching columns in a table-pair-wise manner, i.e. we pass the input tables in pairs and ask the LLM to return all correspondences between the columns of the tables [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figure 4
Figure 4. Table Grouping Prompt: an example. The output of the operator is the grouping of the tables under their respective entity type 𝐸 = {𝐸1, 𝐸2, ...𝐸𝑘 } where 𝐸𝑘 is composed of all tables in𝑇𝐸 that refer to the entity type 𝐸𝑘 and 𝑘 is the number of distinct entity types found in the input tables. At this operator, the previously created attribute groups 𝐴𝐺 from the Schema Matching Operator are split into attribute groups… view at source ↗
Figures from the paper (3 more)
Figure 5
Figure 5. Figure 5: Integrated Schema Output Operator: an example of its input and output. [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 7
Figure 7. Figure 7: The three schema integration workflows combining [PITH_FULL_IMAGE:figures/full_fig_p006_7.png]
Figure 6
Figure 6. Figure 6: Table Splitting Operator: example of consistent [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

42 extracted references · 3 linked inside Pith

  1. [1]

    Bernstein

    Suad Alagić and Philip A. Bernstein. 2002. A Model Theory for Generic Schema Management. InDatabase Programming Languages, Giorgio Ghelli and Gösta Grahne (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 228–246

    2002

  2. [2]

    Basel Alshaikhdeeb and Kamsuriah Ahmad. 2015. Integrating correlation clus- tering and agglomerative hierarchical clustering for holistic schema matching. Journal of Computer Science11, 3 (2015), 484

    2015

  3. [3]

    Simran Arora, Brandon Yang, Sabri Eyuboglu, Avanika Narayan, Andrew Ho- jel, Immanuel Trummer, and Christopher Ré. 2023. Language Models Enable Simple Systems for Generating Structured Views of Heterogeneous Data Lakes. Proceedings of the VLDB Endowment17, 2 (2023), 92–105

    2023

  4. [4]

    Muhammad Nabeel Asim, Muhammad Wasim, Muhammad Usman Ghani Khan, Waqar Mahmood, and Hafiza Mahnoor Abbasi. 2018. A survey of ontology learning techniques and applications.Database2018 (2018), bay101

    2018

  5. [5]

    Hamed Babaei Giglou, Jennifer D’Souza, and Sören Auer. 2023. LLMs4OL: Large language models for ontology learning. InInternational semantic web conference. Springer, 408–427

    2023

  6. [6]

    Nelly Barret, Ioana Manolescu, and Prajna Upadhyay. 2024. Computing generic abstractions from application datasets. InEDBT 2024-27th International Conference on Extending Database Technology, Vol. 27. 94–107

    2024

  7. [7]

    Carlo Batini, B Demo, and Antonio Di Leva. 1984. A methodology for conceptual design of office data bases.Information Systems9, 3-4 (1984), 251–263

    1984

  8. [8]

    Carlo Batini, Maurizio Lenzerini, and Shamkant B. Navathe. 1986. A comparative analysis of methodologies for database schema integration.ACM computing surveys (CSUR)18, 4 (1986), 323–364

    1986

Show all 42 references
  1. [9]

    Henrik Bongertmann, Benjamin Nast, Leon Griesch, Henry Rotzoll, and Kurt Sandkuhl. 2025. Large Language Models for Structuring and Integration of Heterogeneous Data. (2025)

    2025

  2. [10]

    Dan Brickley, Matthew Burgess, and Natasha Noy. 2019. Google dataset search: Building a search engine for datasets in an open web ecosystem. InThe world wide web conference. 1365–1375

    2019

  3. [11]

    Shui-Lung Chuang and Kevin Chen-Chuan Chang. 2008. Integrating web query results: holistic schema matching. InProceedings of the 17th ACM conference on Information and knowledge management. 33–42

    2008

  4. [12]

    Anish Das Sarma, Xin Dong, and Alon Halevy. 2008. Bootstrapping pay-as-you- go data integration systems. InProceedings of the 2008 ACM SIGMOD international conference on Management of data. 861–874

    2008

  5. [13]

    Xiang Deng, Huan Sun, Alyssa Lees, You Wu, and Cong Yu. 2022. Turl: Table understanding through representation learning.ACM SIGMOD Record51, 1 (2022), 33–40

    2022

  6. [14]

    Hong-Hai Do and Erhard Rahm. 2002. COMA—a system for flexible combination of schema matching approaches. InVLDB’02: Proceedings of the 28th International Conference on Very Large Databases. Elsevier, 610–621

    2002

  7. [15]

    Fabien Duchateau, Zohra Bellahsene, and Ela Hunt. 2007. XBenchMatch: a Benchmark for XML Schema Matching Tools.. InVLDB, Vol. 7. 1318–1321

    2007

  8. [16]

    Bin He and Kevin Chen-Chuan Chang. 2003. Statistical schema matching across web query interfaces. InProceedings of the 2003 ACM SIGMOD international conference on Management of data. 217–228

    2003

  9. [17]

    Bin He and Kevin Chen-Chuan Chang. 2006. Automatic complex schema match- ing across web query interfaces: A correlation mining approach.ACM Transac- tions on Database Systems (TODS)31, 1 (2006), 346–395

    2006

  10. [18]

    Bin He, Kevin Chen-Chuan Chang, and Jiawei Han. 2004. Discovering complex matchings across web query interfaces: a correlation mining approach. InProceed- ings of the tenth ACM SIGKDD international conference on Knowledge discovery and data mining. 148–157. Korini and Bizer

    2004

  11. [19]

    Prudhvi Janga and Karen C Davis. 2013. Tabular web data: schema discovery and integration. InInternational Conference on Data Warehousing and Knowledge Discovery. Springer, 26–33

    2013

  12. [20]

    Daomin Ji, Hui Luo, Zhifeng Bao, and J Shane Culpepper. 2025. Table integration in data lakes unleashed: pairwise integrability judgment, integrable set discovery, and multi-tuple conflict resolution.The VLDB Journal34, 3 (2025), 36

    2025

  13. [21]

    Moe Kayali, Fabian Wenz, Nesime Tatbul, and Çağatay Demiralp. 2024. Mind the data gap: Bridging llms to enterprise data integration.arXiv preprint arXiv:2412.20331(2024)

    2024 arXiv

  14. [22]

    Aamod Khatiwada, Roee Shraga, Wolfgang Gatterbauer, and Renée J Miller. 2022. Integrating data lake tables.Proceedings of the VLDB Endowment16, 4 (2022), 932–945

    2022

  15. [23]

    Christos Koutras, George Siachamis, Andra Ionescu, Kyriakos Psarakis, Jerry Brons, Marios Fragkoulis, Christoph Lofi, Angela Bonifati, and Asterios Katsi- fodimos. 2021. Valentine: Evaluating matching techniques for dataset discovery. In2021 IEEE 37th International Conference ...

    2021

  16. [24]

    Sebastian Kruse and Felix Naumann. 2018. Efficient discovery of approximate dependencies.Proceedings of the VLDB Endowment11, 7 (2018), 759–772

    2018

  17. [25]

    Lukas Laskowski, Michael Hladik, Jan Portisch, Fabian Panse, and Felix Naumann

  18. [26]

    Peng Li, Yeye He, Dror Yashar, Weiwei Cui, Song Ge, Haidong Zhang, Danielle Rifinski Fainman, Dongmei Zhang, and Surajit Chaudhuri. 2024. Table-gpt: Table fine-tuned gpt for diverse table tasks.Proceedings of the ACM on Management of Data2, 3 (2024), 1–28

    2024

  19. [27]

    Chuangtao Ma and Bálint Molnár. 2022. Ontology learning from relational database: Opportunities for semantic information integration.Vietnam Journal of Computer Science9, 01 (2022), 31–57

    2022

  20. [28]

    Shamkant B Navathe and Suresh G Gadgil. 1982. A Methodology for View Inegration in Logical Database Design. InProceedings of the 8th International Conference on Very Large Data Bases. 142–164

    1982

  21. [29]

    Mojtaba Nayyeri, Athish A Yogi, Nadeen Fathallah, Ratan Bahadur Thapa, Hans- Michael Tautenhahn, Anton Schnurpel, and Steffen Staab. 2025. Retrieval- Augmented Generation of Ontologies from Relational Databases.arXiv preprint arXiv:2506.01232(2025)

    2025 arXiv

  22. [30]

    Jin Pei, Jun Hong, and David Bell. 2006. A novel clustering-based approach to schema matching. InInternational Conference on Advances in Information Systems. Springer, 60–69

    2006

  23. [31]

    Erhard Rahm and Philip A Bernstein. 2001. A survey of approaches to automatic schema matching.the VLDB Journal10 (2001), 334–350

    2001

  24. [32]

    Stefano Spaccapietra, Christine Parent, and Yann Dupont. 1992. Model indepen- dent assertions for integration of heterogeneous schemas.The VLDB Journal1, 1 (1992), 81–126

    1992

  25. [33]

    Weifeng Su, Jiying Wang, and Frederick Lochovsky. 2006. Holistic schema matching for web query interfaces. InInternational Conference on Extending Database Technology. Springer, 77–94

    2006

  26. [34]

    Mikel Val-Calvo, Mikel Egaña Aranguren, Juan Mulero-Hernández, Ginés Almagro-Hernández, Prashant Deshmukh, José Antonio Bernabé-Díaz, Paola Espinoza-Arias, José Luis Sánchez-Fernández, Juergen Mueller, and Jesu- aldo Tomás Fernández-Breis. 2025. OntoGenix: Leveraging Large Lan...

    2025

  27. [35]

    Liane Vogel, Jan-Micha Bodensohn, and Carsten Binnig. 2024. WikiDBs: A Large-Scale Corpus Of Relational Databases From Wikidata. InThe Thirty-eight Conference on Neural Information Processing Systems Datasets and Benchmarks Track. https://openreview.net/pdf?id=abXaOcvujs

    2024

  28. [36]

    Denny Vrandečić and Markus Krötzsch. 2014. Wikidata: a free collaborative knowledgebase.Commun. ACM57, 10 (2014), 78–85

    2014

  29. [37]

    Qin Wang, Youhuan Li, Yansong Feng, Si Chen, Ziming Li, Pan Zhang, Zhichao Shi, Yuequn Dou, Zebin Huang, Zihui Si, et al. 2025. Schemaagent: a multi-agents framework for generating relational database schema.arXiv e-prints(2025), arXiv–2503

    2025

  30. [38]

    Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc V Le, et al . 2023. Self- Consistency Improves Chain of Thought Reasoning in Language Models. In The Eleventh International Conference on Learning Representations

    2023

  31. [39]

    Wensheng Wu, Clement Yu, AnHai Doan, and Weiyi Meng. 2004. An interactive clustering-based approach to integrating source query interfaces on the deep web. InProceedings of the 2004 ACM SIGMOD international conference on Management of data. 95–106

    2004

  32. [40]

    Zhenyu Wu, Jiaoyan Chen, and Norman W Paton. 2025. Schema Inference for Tabular Data Repositories Using Large Language Models.arXiv preprint arXiv:2509.04632(2025)

    2025 arXiv

  33. [41]

    Zhenyu Wu, Jiaoyan Chen, and Norman W Paton. 2025. Taxonomy inference for tabular data using large language models. InEuropean Semantic Web Conference. Springer, 403–422

    2025

  34. [2025]

    Proceedings of the ACM on Management of Data3, 6 (2025), 1–27

    Burr: A Benchmark for Ontology Learning from Relational Databases. Proceedings of the ACM on Management of Data3, 6 (2025), 1–27

    2025

Pith tools

Reviewed July 31, 2026 · model on record in the stance chip above.