Rete network slicing for model queries

Zoltán Ujhelyi, Gábor Bergmann, D. Varró

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

Declarative model queries captured by graph patterns are frequently used in model driven engineering tools for the validation of well-formedness constraint or the calculation of various model metrics. However, their high level nature might make it hard to understand all corner cases of complex queries. When debugging erroneous patterns, a common task is to identify which conditions or constraints of a query caused some model elements to appear in the results. Slicing techniques in traditional programming environments are used to calculate similar dependencies between program statements. Here, we introduce a slicing approach for model queries based on Rete networks, a cache structure applied for the incremental evaluation of model queries. The proposed method reuses the structural information encoded in the Rete networks to calculate and present a trace of operations resulting in some model elements to appear in the result set. The approach is illustrated on a running example of validating well-formedness over UML state machine models using graph patterns as a model query formalism.

Original languageEnglish
Title of host publicationGraph Transformation - 9th International Conference, ICGT 2016 in Memory of Hartmut Ehrig, Held as Part of STAF 2016, Proceedings
PublisherSpringer Verlag
Pages137-152
Number of pages16
Volume9761
ISBN (Print)9783319405292
DOIs
Publication statusPublished - 2016
Event9th International Conference on Graph Transformation, ICGT 2016 in Memory of Hartmut Ehrig held as part of Conference on Software Technologies: Applications and Foundations, STAF 2016 - Vienna, Austria
Duration: Jul 5 2016Jul 6 2016

Publication series

NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Volume9761
ISSN (Print)03029743
ISSN (Electronic)16113349

Other

Other9th International Conference on Graph Transformation, ICGT 2016 in Memory of Hartmut Ehrig held as part of Conference on Software Technologies: Applications and Foundations, STAF 2016
CountryAustria
CityVienna
Period7/5/167/6/16

Fingerprint

Slicing
Query
Model
Calculate
Programming Environments
Debugging
Graph Model
State Machine
Cache
Reuse
Trace
Engineering
Metric
Evaluation
Graph in graph theory

Keywords

  • Graph patterns
  • Model queries
  • Program slicing

ASJC Scopus subject areas

  • Theoretical Computer Science
  • Computer Science(all)

Cite this

Ujhelyi, Z., Bergmann, G., & Varró, D. (2016). Rete network slicing for model queries. In Graph Transformation - 9th International Conference, ICGT 2016 in Memory of Hartmut Ehrig, Held as Part of STAF 2016, Proceedings (Vol. 9761, pp. 137-152). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 9761). Springer Verlag. https://doi.org/10.1007/978-3-319-40530-8_9

Rete network slicing for model queries. / Ujhelyi, Zoltán; Bergmann, Gábor; Varró, D.

Graph Transformation - 9th International Conference, ICGT 2016 in Memory of Hartmut Ehrig, Held as Part of STAF 2016, Proceedings. Vol. 9761 Springer Verlag, 2016. p. 137-152 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 9761).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Ujhelyi, Z, Bergmann, G & Varró, D 2016, Rete network slicing for model queries. in Graph Transformation - 9th International Conference, ICGT 2016 in Memory of Hartmut Ehrig, Held as Part of STAF 2016, Proceedings. vol. 9761, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 9761, Springer Verlag, pp. 137-152, 9th International Conference on Graph Transformation, ICGT 2016 in Memory of Hartmut Ehrig held as part of Conference on Software Technologies: Applications and Foundations, STAF 2016, Vienna, Austria, 7/5/16. https://doi.org/10.1007/978-3-319-40530-8_9
Ujhelyi Z, Bergmann G, Varró D. Rete network slicing for model queries. In Graph Transformation - 9th International Conference, ICGT 2016 in Memory of Hartmut Ehrig, Held as Part of STAF 2016, Proceedings. Vol. 9761. Springer Verlag. 2016. p. 137-152. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/978-3-319-40530-8_9
Ujhelyi, Zoltán ; Bergmann, Gábor ; Varró, D. / Rete network slicing for model queries. Graph Transformation - 9th International Conference, ICGT 2016 in Memory of Hartmut Ehrig, Held as Part of STAF 2016, Proceedings. Vol. 9761 Springer Verlag, 2016. pp. 137-152 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
@inproceedings{981d6122b30b4c96b93412f977b0ce29,
title = "Rete network slicing for model queries",
abstract = "Declarative model queries captured by graph patterns are frequently used in model driven engineering tools for the validation of well-formedness constraint or the calculation of various model metrics. However, their high level nature might make it hard to understand all corner cases of complex queries. When debugging erroneous patterns, a common task is to identify which conditions or constraints of a query caused some model elements to appear in the results. Slicing techniques in traditional programming environments are used to calculate similar dependencies between program statements. Here, we introduce a slicing approach for model queries based on Rete networks, a cache structure applied for the incremental evaluation of model queries. The proposed method reuses the structural information encoded in the Rete networks to calculate and present a trace of operations resulting in some model elements to appear in the result set. The approach is illustrated on a running example of validating well-formedness over UML state machine models using graph patterns as a model query formalism.",
keywords = "Graph patterns, Model queries, Program slicing",
author = "Zolt{\'a}n Ujhelyi and G{\'a}bor Bergmann and D. Varr{\'o}",
year = "2016",
doi = "10.1007/978-3-319-40530-8_9",
language = "English",
isbn = "9783319405292",
volume = "9761",
series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
publisher = "Springer Verlag",
pages = "137--152",
booktitle = "Graph Transformation - 9th International Conference, ICGT 2016 in Memory of Hartmut Ehrig, Held as Part of STAF 2016, Proceedings",

}

TY - GEN

T1 - Rete network slicing for model queries

AU - Ujhelyi, Zoltán

AU - Bergmann, Gábor

AU - Varró, D.

PY - 2016

Y1 - 2016

N2 - Declarative model queries captured by graph patterns are frequently used in model driven engineering tools for the validation of well-formedness constraint or the calculation of various model metrics. However, their high level nature might make it hard to understand all corner cases of complex queries. When debugging erroneous patterns, a common task is to identify which conditions or constraints of a query caused some model elements to appear in the results. Slicing techniques in traditional programming environments are used to calculate similar dependencies between program statements. Here, we introduce a slicing approach for model queries based on Rete networks, a cache structure applied for the incremental evaluation of model queries. The proposed method reuses the structural information encoded in the Rete networks to calculate and present a trace of operations resulting in some model elements to appear in the result set. The approach is illustrated on a running example of validating well-formedness over UML state machine models using graph patterns as a model query formalism.

AB - Declarative model queries captured by graph patterns are frequently used in model driven engineering tools for the validation of well-formedness constraint or the calculation of various model metrics. However, their high level nature might make it hard to understand all corner cases of complex queries. When debugging erroneous patterns, a common task is to identify which conditions or constraints of a query caused some model elements to appear in the results. Slicing techniques in traditional programming environments are used to calculate similar dependencies between program statements. Here, we introduce a slicing approach for model queries based on Rete networks, a cache structure applied for the incremental evaluation of model queries. The proposed method reuses the structural information encoded in the Rete networks to calculate and present a trace of operations resulting in some model elements to appear in the result set. The approach is illustrated on a running example of validating well-formedness over UML state machine models using graph patterns as a model query formalism.

KW - Graph patterns

KW - Model queries

KW - Program slicing

UR - http://www.scopus.com/inward/record.url?scp=84977501998&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=84977501998&partnerID=8YFLogxK

U2 - 10.1007/978-3-319-40530-8_9

DO - 10.1007/978-3-319-40530-8_9

M3 - Conference contribution

AN - SCOPUS:84977501998

SN - 9783319405292

VL - 9761

T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

SP - 137

EP - 152

BT - Graph Transformation - 9th International Conference, ICGT 2016 in Memory of Hartmut Ehrig, Held as Part of STAF 2016, Proceedings

PB - Springer Verlag

ER -