Pith. sign in

REVIEW 4 major objections 5 minor 29 references

Towards Agentic Schema Refinement

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 The paper proposes a semantic layer made of small, reusable database views and shows that a multi-agent LLM simulation can generate such views, decomposing a 61-table schema into 1,146 narrow views.

desk verdict A promising workshop paper on multi-agent LLM view discovery whose central interpretability claim rests on a statistic that is largely built into the mechanism. read the letter →

arxiv 2412.07786 v1 pith:5HQZFXUF submitted 2024-11-25 cs.DB cs.AI

Agapi Rissaki , Ilias Fountalis , Nikolaos Vasiloglou , Wolfgang Gatterbauer This is my paper · ORCID
classification cs.DBcs.AI
keywords semanticlayerdatabaseviewsschemarefinementmulti-agentLLMviewdiscoveryentity-relationshipmodeldataexplorationtext-to-SQL
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

Large enterprise databases are hard to explore: tables are wide, column names are cryptic, and understanding what the data means takes tedious work. This paper argues that a semantic layer built from small, reusable database views can stand between the schema and the user, distilling entities and relationships into manageable pieces. To build that layer without a human expert, it runs a multi-agent LLM simulation in which an Analyst, a Critic, and a Verifier iteratively decompose complex queries into views and validate them by executing them in the database. On a 61-table commercial database the process produced 1,146 views with median width 3, down from a median table width of 28, and on a second, extremely wide public dataset it produced 632 views. The paper is a preliminary demonstration: the claims are about feasibility and structural effects, not about measured gains in user performance.

What carries the argument

The engine is a schema refinement mechanism implemented as a multi-agent conversation. A view is a virtual table defined by a stored SQL query. The Analyst proposes analytics tasks, writes SQL, and defines intermediate views; the Critic reviews the views for refinement quality and suggests alternatives; and the Verifier executes the views in a database engine to confirm correctness. To keep the process tractable, sessions run on connected components of the primary-key/foreign-key schema graph, focus each session with a graph retrieval algorithm, and pass chat summaries between sessions so later work reuses existing views and avoids repeating earlier tasks. The output is the set of validated views that acts as the semantic layer, and a post-processing step clusters the views into an entity-relationship model.

What would settle it

Run a controlled comparison in which human analysts or a text-to-SQL system answer a fixed set of questions against either the original schema or the generated semantic layer. If query correctness, completion time, or confidence does not improve with the views, the claim that the views form an easier-to-interpret refined schema would be falsified.

Watch

Extended reading notes

Core claim

The central claim is that schema refinement can be automated: given only the schema, a data sample, and minimal seed instructions, a multi-agent LLM simulation discovers a set of views that serve as a refined version of the original schema, with tables effectively decomposed into smaller components. The authors demonstrate this on a commercial customer-engagement database with 61 tables and 1,770 columns, where the simulation produced 1,146 views with median width 3 compared with the original median table width of 28; the views cover 80.79% of the original columns, preserve 54.84% of the original pairwise column relationships, and add 7,229 new relationships through joins. They also report a second case study on a large public healthcare dataset where 632 views were generated from 113 tables, several of which had hundreds of columns. The authors further claim that grouping the views and extracting an entity-relationship model gives users immediate insight into the semantic content of the database, with each entity or relationship mapped to validated SQL views.

Load-bearing premise

The load-bearing premise is that a view with fewer columns is more interpretable and useful, since the paper uses median view width as its main evidence of refinement and does not include a user study or task-based metric connecting narrow views to better comprehension or query accuracy.

Editorial extensions

If this is right

  • Users can bootstrap understanding of an unfamiliar database by reading the entity-relationship model instead of exploring dozens of wide tables.
  • Analytics queries become shorter and more reusable because they can be rewritten against the discovered views using standard SQL.
  • The semantic layer surfaces hidden connections, adding 7,229 pairwise column relationships that no original table captured.
  • Because each session handles only connected schema components and keeps memory between sessions, the approach scales to schemas larger than a single LLM context window.
  • The mapping from entities and relationships to validated views gives a direct path from a conceptual question to executable SQL, lowering the barrier to querying without deep schema knowledge.

Reading between the lines

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

  • A testable extension the paper leaves open is whether narrowness itself drives interpretability; a user study comparing fact-finding and query-writing on the original schema versus the semantic layer would turn the structural claim into a behavioral one.
  • The second case study's low column coverage (18.87%) suggests that on extremely wide schemas the process deliberately discards most columns; checking whether real queries ever need the discarded columns would show whether low coverage is a weakness or a useful abstraction.
  • The discovered views could be compared with the output of standard normalization based on functional dependencies; where the LLM-driven decomposition agrees with syntactic normalization, the semantic value is confirmed, and where it diverges, the difference would reveal what external knowledge contributes.
  • Because the views are validated by execution inside the database, the same pipeline could be re-run when a schema evolves, providing a low-cost way to keep a semantic layer up to date.
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. The paper proposes building a semantic layer over complex databases as a set of small, reusable SQL views, discovered by a multi-agent LLM simulation. Three agents (Analyst, Critic, Verifier) iteratively define, refine, and validate views, with the aim of distilling the original schema into entities and relationships that are easier for users to understand. The authors report a proof-of-concept study on a public Braze demo database (61 tables, 1146 views, median view width 3 vs. median table width 28) and an additional case study on CMS data feeds (113 tables, 632 views), plus an entity-relationship mapping derived from the views. The central claim is that the generated views constitute a refined, semantically meaningful version of the original schema that gives users immediate insight into the database.

Significance. If validated, the multi-agent view-discovery framework would be a practical contribution to automated semantic-layer construction, addressing a real pain point in database exploration and text-to-SQL systems. The approach is concrete: views are executable SQL objects, the Verifier checks them by executing them in a database engine, and the code is publicly available. The paper also demonstrates that the method can scale to wide, realistic schemas. However, the current evidence is structural statistics only; the semantic-usefulness claim is asserted rather than measured. The lack of any baseline, user study, task-based accuracy metric, or repeated-run variance means the central value proposition—that narrower views are easier to interpret and that the ER model aids comprehension—remains unsupported. The contribution is therefore a promising system description rather than a validated method.

major comments (4)
  1. [Section 3, Fig. 3] The median-width comparison (3 vs. 28) is presented as validating that the views are a refined version of the schema, but that conclusion does not follow. The view-generation mechanism in Section 2.1 defines views as projections, filters, or query subexpressions of the original tables, so producing narrower outputs is a direct consequence of the mechanism rather than a discovered semantic property. A random decomposition into 3-column fragments would achieve the same median width without any claim of interpretability. To support the refinement claim, the authors need a task-based or human evaluation (e.g., measuring whether users or text-to-SQL systems answer questions more accurately using the semantic layer) or at least a comparison against a non-semantic baseline such as random column groupings.
  2. [Section 3, final paragraph] The claim that a new user 'can immediately gain insight' and that each entity/relationship is 'mapped to database views, validated for correctness and usefulness' relies on labels and validation performed by the same multi-agent framework that generated the views. The Verifier checks only that views execute successfully, not that they are semantically meaningful. There is no user study, no external benchmark, and no comparison of query results with and without the semantic layer. This self-referential validation is a circularity risk: the framework's own assessment of 'usefulness' cannot substitute for an independent measure of whether the views actually improve exploration or query formulation.
  3. [Appendix A.1, Table 2] In the CMS case study, only 0.5% of original column co-occurrences are preserved in the views, yet the authors call this 'expected' and use it to argue that the refinement discards only non-semantic relations. This is a load-bearing assumption: if the discarded relations include many that are semantically important, the 0.5% preservation rate could indicate that the decomposition is largely arbitrary. The paper provides no evidence that the preserved relations are more semantically meaningful than the discarded ones, nor any downstream task that would demonstrate the semantic loss is acceptable. A concrete test would be to check whether typical analytic queries over the original schema can still be answered (or answered more simply) using the views.
  4. [Section 3 and Appendix A.1] The experimental evaluation consists of two datasets, each with a single run of the multi-agent simulation, and no baselines, no variance, and no error analysis. The paper acknowledges the results are preliminary, but the abstract and introduction make general claims about 'our approach' paving the way for LLM-powered database exploration. Since the central usefulness claim rests entirely on the reported structural statistics, at least one additional supporting experiment is needed: for example, repeated runs to show stability, a comparison against a non-agentic or random view-generation baseline, or a small user study measuring comprehension of the schema with and without the semantic layer. Without such evidence, the results cannot distinguish a meaningful semantic layer from an arbitrary set of projections.
minor comments (5)
  1. [Figure 1] The SQL for query Q' uses the alias 's' in the WHERE and GROUP BY clauses ('o.staff_id = s.staff_id', 'GROUP BY s.staff_id') even though the table is aliased as 'i' in the FROM clause; the query would not execute as written. Please fix to use 'i.staff_id' consistently.
  2. [Table 1 and Appendix A.1] Several origin table names contain an erroneous space, e.g., 'USERS_BEHA VIORS_UPGRADEDAPP' and 'USERS_BEHA VIORS_UNINSTALL' in Table 1; these should be 'USERS_BEHAVIORS_...'.
  3. [Figure 3 caption] The caption says 'We ignore the top 1% views in terms of width' but does not state whether this exclusion affects the reported median view width and relation counts; please clarify the exact filtering rule and its effect on the statistics.
  4. [Appendix A.1] The phrase 'abstracting away too detailed information' is unclear; please rephrase to explain which information is abstracted away and why it is considered too detailed.
  5. [Section 3] The sentence 'thus validating that the generated views serve as a refined version' overstates what a width distribution can show; consider replacing 'validating' with 'suggesting' or 'illustrating' to match the preliminary nature of the study.

Circularity Check

2 steps flagged · score 6.0 of 10

The median-width comparison that 'validates' the refined schema is a built-in output of the instructed decomposition mechanism, and the 'usefulness' validation is performed by the same framework that generated the views.

  1. self definitional [Section 2.1 (Schema refinement mechanism) and Section 3, Figure 3b]
    "The main idea behind view discovery is to start with complex queries and then express them in a simpler way by decomposing them into modular components. ... In Fig. 3b, we see that most generated views have few columns (median width 3, Fig. 3a) in contrast to tables in the original schema which are often wide (median width 28, Fig. 3a), thus validating that the generated views serve as a refined version of the original schema with tables effectively decomposed into smaller components."

    The property offered as validation (narrow views) is exactly the property the agents were instructed to produce: 'decomposing them into modular components' is the prescribed mechanism of view discovery. Thus the median-width comparison is a restatement of the method's design, not an independent confirmation that the views are semantically refined. A random decomposition of wide tables into few-column fragments would yield the same width distribution without establishing interpretability, so the claimed evidence reduces to the definition of the mechanism.

  2. other [Section 3, entity-relationship post-processing paragraph]
    "Note that each entity and relationship discovered is directly mapped to a set of database views, validated for correctness and usefulness via our multi-agent schema refinement framework."

    The same multi-agent framework that generated the views and their LLM-produced entity/relationship labels also serves as the validator of 'usefulness' and semantic quality. No human study, query-accuracy benchmark, or external ground-truth is used; the paper's adjacent claim that 'a new user can immediately gain insight' is therefore supported only by the system's own self-assessment. SQL correctness is checked by execution, but usefulness and interpretability are not independently measured, closing the validation loop inside the generating framework.

full rationale

The paper's core artifact, a set of executable SQL views produced by a multi-agent LLM simulation, is real and independently checkable: the views are materialized, the code is public, and the SQL can be run against the Braze dataset. That part is not circular. However, the paper's central evaluative claim is circular in two places. First, the quantitative evidence that the views constitute a 'refined version' of the schema is the width distribution, but the refinement mechanism in Section 2.1 is defined as decomposing queries into modular components, so small view width is a designed output rather than a discovered semantic property. Second, the semantic usefulness of the entities and relationships is 'validated' by the same multi-agent schema refinement framework that created them, with no external user study or task-based metric. Appendix A.1 further shows that on the CMS case only 0.5% of original column co-occurrences are preserved, a loss the paper hand-waves as 'expected' without independent evidence that the retained structure is the semantically relevant one. The paper honestly labels the study as preliminary and defers text-to-SQL evaluation to future work, which mitigates but does not remove the self-referential validation. No self-citation load-bearing issues exist. Overall, the central validation reduces partly by construction, giving a score of 6.

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

The paper's claims depend on the assumptions that small views are semantically useful, that LLM agents can write correct SQL, that the decomposition mechanism extracts meaningful entities, and that sampled schema subgraphs represent the whole database. None of these is measured against an external ground truth; the only execution check is syntactic correctness of views.

assumptions (4)
  • domain assumption A semantic layer consisting of small views improves user understanding and analytical workflows.
    The paper motivates the work with this assumption in the Introduction and does not evaluate it.
  • domain assumption LLM agents, with execution-based verification, can propose correct and meaningful SQL views.
    The whole method rests on GPT-4's ability to generate useful SQL; no error rates are reported.
  • ad hoc to paper Decomposing complex queries into reusable views is a valid mechanism for extracting semantics.
    The schema refinement mechanism in Section 2.1 is introduced specifically for this method, with no evidence that it produces semantically coherent views.
  • domain assumption Graph connected component sampling and GraphRAG provide representative coverage of the schema.
    Section 2.2 states this; coverage is reported as column percentages but no comparison to other sampling strategies is given.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Towards Agentic Schema Refinement." pith.science (2026). https://pith.science/paper/5HQZFXUF

@misc{pith2026241207786,
  author       = {Pith},
  title        = {Pith review of: Towards Agentic Schema Refinement},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/5HQZFXUF}},
  note         = {Machine review of arXiv:2412.07786}
}
read the original abstract

Large enterprise databases can be complex and messy, obscuring the data semantics needed for analytical tasks. We propose a semantic layer in-between the database and the user as a set of small and easy-to-interpret database views, effectively acting as a refined version of the schema. To discover these views, we introduce a multi-agent Large Language Model (LLM) simulation where LLM agents collaborate to iteratively define and refine views with minimal input. Our approach paves the way for LLM-powered exploration of unwieldy databases.

Figures

Figures reproduced from arXiv: 2412.07786 by the authors.

Figure 1
Figure 1. Example of the schema refinement mechanism on the schema [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. A single chat session implementing the schema refinement mechanism (Figure (a)). A [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Structural properties of the distilled views composing the semantic layer. We ignore the top [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Diagram of entities (with their attributes) and relationships. [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

29 extracted references · 19 canonical work pages

  1. [1]

    Gpt-4 technical report

    Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774, 2023

    arXiv 2023

  2. [2]

    Inode: Building an end-to-end data exploration system in practice

    Sihem Amer-Yahia, Georgia Koutrika, Martin Braschler, Diego Calvanese, Davide Lanti, Hendrik Lücke-Tieke, Alessandro Mosca, Tarcisio Mendes de Farias, Dimitris Papadopoulos, Yogendra Patil, Guillem Rull, Ellery Smith, Dimitrios Skoutas, Srividya Subramanian, and Kurt Stockinger. Inode: Building an end-to-end data exploration system in practice. SIGMOD Rec...

    work page 2022

  3. [3]

    What is a semantic layer?, 2024

    AtScale. What is a semantic layer?, 2024

    work page 2024

  4. [4]

    C3: Zero-shot text-to-sql with chatgpt

    Xuemei Dong, Chao Zhang, Yuhang Ge, Yuren Mao, Yunjun Gao, Jinshu Lin, Dongfang Lou, et al. C3: Zero-shot text-to-sql with chatgpt. arXiv preprint arXiv:2307.07306, 2023

    arXiv 2023

  5. [5]

    NL2SQL is a solved problem

    Avrilia Floratou, Fotis Psallidas, Fuheng Zhao, Shaleen Deep, Gunther Hagleither, Joyce Cahoon, Rana Alotaibi, Jordan Henkel, Abhik Singla, Alex van Grootel, Kai Deng, Katherine Lin, Marcos Campos, Venkatesh Emani, Vivek Pandit, Wenjing Wang, and Carlo Curino. NL2SQL is a solved problem... Not! In CIDR, 2024

    work page 2024

  6. [6]

    Text-to-sql empowered by large language models: A benchmark evaluation

    Dawei Gao, Haibin Wang, Yaliang Li, Xiuyu Sun, Yichen Qian, Bolin Ding, and Jingren Zhou. Text-to-sql empowered by large language models: A benchmark evaluation. PVLDB, 17(5):1132–1145, 2024

    work page 2024

  7. [7]

    Chawla, Olaf Wiest, and Xiangliang Zhang

    Taicheng Guo, Xiuying Chen, Yaqi Wang, Ruidi Chang, Shichao Pei, Nitesh V . Chawla, Olaf Wiest, and Xiangliang Zhang. Large language model based multi-agents: A survey of progress and challenges. In IJCAI, pages 8048–8057, 8 2024

    work page 2024

  8. [8]

    G-retriever: Retrieval-augmented generation for textual graph understanding and question answering

    Xiaoxin He, Yijun Tian, Yifei Sun, Nitesh V Chawla, Thomas Laurent, Yann LeCun, Xavier Bresson, and Bryan Hooi. G-retriever: Retrieval-augmented generation for textual graph understanding and question answering. arXiv preprint arXiv:2402.07630, 2024

    arXiv 2024

Show all 29 references
  1. [9]

    Data ambiguity strikes back: How documentation improves GPT’s text-to-SQL

    Zezhou Huang, Pavan Kalyan Damalapati, and Eugene Wu. Data ambiguity strikes back: How documentation improves GPT’s text-to-SQL. In NeurIPS 2023 Second Table Representation Learning Workshop, 2023

    2023

  2. [10]

    What is a semantic layer, and how does it turn your data into knowledge?, 2022

    Sean Leslie. What is a semantic layer, and how does it turn your data into knowledge?, 2022

    2022

  3. [11]

    Camel: Communicative agents for" mind" exploration of large language model society

    Guohao Li, Hasan Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. Camel: Communicative agents for" mind" exploration of large language model society. In NeurIPS, volume 36, pages 51991–52008, 2023

    2023

  4. [12]

    Resdsql: Decoupling schema linking and skeleton parsing for text-to-sql

    Haoyang Li, Jing Zhang, Cuiping Li, and Hong Chen. Resdsql: Decoupling schema linking and skeleton parsing for text-to-sql. In AAAI, volume 37, pages 13067–13075, 2023

    2023

  5. [13]

    Agent hospital: A simulacrum of hospital with evolvable medical agents

    Junkai Li, Siyu Wang, Meng Zhang, Weitao Li, Yunghwei Lai, Xinhui Kang, Weizhi Ma, and Yang Liu. Agent hospital: A simulacrum of hospital with evolvable medical agents. arXiv preprint arXiv:2405.02957, 2024

    2024 arXiv

  6. [14]

    Chain of hindsight aligns language models with feedback

    Hao Liu, Carmelo Sferrazza, and Pieter Abbeel. Chain of hindsight aligns language models with feedback. In ICLR, 2024

    2024

  7. [15]

    Agentlite: A lightweight library for building and advancing task-oriented llm agent system

    Zhiwei Liu, Weiran Yao, Jianguo Zhang, Liangwei Yang, Zuxin Liu, Juntao Tan, Prafulla K Choubey, Tian Lan, Jason Wu, Huan Wang, et al. Agentlite: A lightweight library for building and advancing task-oriented llm agent system. arXiv preprint arXiv:2402.15538, 2024

    2024 arXiv

  8. [16]

    Insightpilot: An llm- empowered automated data exploration system

    Pingchuan Ma, Rui Ding, Shuai Wang, Shi Han, and Dongmei Zhang. Insightpilot: An llm- empowered automated data exploration system. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 346–352, 2023

    2023

  9. [17]

    Agentinstruct: Toward generative teaching with agentic flows

    Arindam Mitra, Luciano Del Corro, Guoqing Zheng, Shweti Mahajan, Dany Rouhana, Andres Codas, Yadong Lu, Wei-ge Chen, Olga Vrousgos, Corby Rosset, et al. Agentinstruct: Toward generative teaching with agentic flows. arXiv preprint arXiv:2407.03502, 2024

    2024 arXiv

  10. [18]

    Din-sql: decomposed in-context learning of text-to-sql with self-correction

    Mohammadreza Pourreza and Davood Rafiei. Din-sql: decomposed in-context learning of text-to-sql with self-correction. In NeurIPS, 2023. 5

    2023

  11. [19]

    Improving generalization in language model-based text-to-sql semantic parsing: Two simple semantic boundary-based techniques

    Daking Rai, Bailin Wang, Yilun Zhou, and Ziyu Yao. Improving generalization in language model-based text-to-sql semantic parsing: Two simple semantic boundary-based techniques. In ACL, 2023

    2023

  12. [20]

    Database Management Systems

    Raghu Ramakrishnan and Johannes Gehrke. Database Management Systems. McGraw-Hill, Inc., 3 edition, 2002

    2002

  13. [21]

    Reflexion: an autonomous agent with dynamic memory and self-reflection

    Noah Shinn, Beck Labash, and Ashwin Gopinath. Reflexion: an autonomous agent with dynamic memory and self-reflection. arXiv preprint arXiv:2303.11366, 2023

    2023 arXiv

  14. [22]

    SQLPrompt: In-context text-to-SQL with minimal labeled data

    Ruoxi Sun, Sercan Arik, Rajarishi Sinha, Hootan Nakhost, Hanjun Dai, Pengcheng Yin, and Tomas Pfister. SQLPrompt: In-context text-to-SQL with minimal labeled data. In Findings of the Association for Computational Linguistics: EMNLP 2023, pages 542–550, 2023

    2023

  15. [23]

    Chain-of-thought prompting elicits reasoning in large language models

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. In NeurIPS, volume 35, pages 24824–24837, 2022

    2022

  16. [24]

    Autogen: Enabling next-gen llm applications via multi-agent conversation framework

    Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, Ahmed Hassan Awadallah, Ryen W White, Doug Burger, and Chi Wang. Autogen: Enabling next-gen llm applications via multi-agent conversation framework. In COLM, 2024

    2024

  17. [25]

    Tree of thoughts: Deliberate problem solving with large language models, 2023

    Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models, 2023. arXiv preprint arXiv:2305.10601, 2023

    2023 arXiv

  18. [26]

    React: Synergizing reasoning and acting in language models

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In ICLR, 2023. 6 Original Schema Semantic Layer # tables 113 # views 632 # median table width 24 # median view width 4 # ma...

    2023

  19. [27]

    - It will be based on the common user interactions between the two types of campaigns

    **View 1: users_interacted_with_email_push_campaigns** - This view will combine the distinct user IDs who interacted with email and push notification campaigns. - It will be based on the common user interactions between the two types of campaigns

  20. [28]

    - It will provide a cleaner and more focused dataset for email campaign analysis

    **View 2: email_engagement_metrics** - This view will extract relevant engagement metrics (open rates, click-through rates, etc.) for email campaigns. - It will provide a cleaner and more focused dataset for email campaign analysis

  21. [29]

    view_definitions

    **View 3: push_notification_engagement_metrics** - This view will extract relevant engagement metrics for push notification campaigns. - It will allow for a clearer and more concise analysis of push notification campaign engagement. By creating these views, you can simplify yo...

Pith tools

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