Streamlining Knowledge Graph Creation with PyRML

Andrea Giovanni Nuzzolese

REVIEW 2 major objections 4 minor 14 references

Streamlining Knowledge Graph Creation with PyRML

T0 review · 2 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read PyRML is a Python-native RML engine that passes 306 of 323 RML-Core conformance tests and runs faster than RMLMapper.

desk verdict PyRML is a genuinely useful Python-native RML engine with strong conformance evidence; the performance claims outrun the benchmark that supports them. read the letter →

arxiv 2505.20949 v1 pith:QDNYK7BZ submitted 2025-05-27 cs.DB cs.AI

Andrea Giovanni Nuzzolese This is my paper

classification cs.DBcs.AI

keywords RMLdeclarativemappingsknowledgegraphconstructionPythonPandasRDFLibR2RMLsemanticdataintegration

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

PyRML is a Python-native library for constructing knowledge graphs from tabular and semi-structured data using declarative RML mappings. The paper claims that PyRML passes 306 of the 323 official RML-Core conformance tests, with a perfect score on CSV, JSON, and XML sources and only bounded gaps on SPARQL and relational databases. It also reports that PyRML completes the test cases faster and with lower variance than the Java-based RMLMapper, with the largest gap on database sources. If correct, this matters because data scientists can author, test, and execute mappings inside a Python environment using Pandas and RDFLib, lowering the barrier to FAIR-aligned knowledge graph construction.

What carries the argument

The design centers on a four-module architecture. The API module defines a TermMap class hierarchy that mirrors the RML and R2RML ontologies, so every mapping construct is also an RDFLib graph node; the core module implements logical sources backed by Pandas DataFrames and vectorized apply(); the functions module supports FnO-style RML functions plus a decorator for registering user-defined Python functions; and the mapper module provides the RMLConverter that parses mappings, renders Jinja2 templates, and executes single-threaded or parallel conversion. The vectorized DataFrame apply is the mechanism that carries the reported speed advantage.

What would settle it

Run PyRML and RMLMapper on a large, production-shaped dataset (for example, several million rows with nested JSON, many-to-many joins, and null-valued join columns) and compare wall-clock time and memory; if PyRML is not faster or fails the join cases that the RML-Core suite flags, the generality of the speed claim fails.

Watch

Extended reading notes

Core claim

The paper's central claim is that declarative knowledge graph construction can be both standards-compliant and Python-native without sacrificing speed. PyRML mirrors the RML/R2RML class taxonomy: subject, predicate, object, and predicate-object maps are Python objects that can be built programmatically or parsed from an RDF mapping document. Mapping execution treats each logical source as a Pandas DataFrame and applies term maps in a vectorized pass. On the RML-Core suite the paper reports full conformance for CSV (39/39), JSON (40/40), and XML (38/38), 24/26 for SPARQL, and 55/60 for each of MySQL, PostgreSQL, and SQL Server, with failures attributed to SPARQL joins, SQL reserved keywords, null-value joins, language tags, boolean casting, and custom SQL queries. Benchmarks against RMLMapper show lower average execution times and lower standard deviations across all source types.

Load-bearing premise

The benchmark assumes the minimal, deterministic RML-Core test cases are representative of real knowledge graph construction workloads, so the measured speed advantage carries over to production-scale data.

Editorial extensions

If this is right

RML mappings can be authored, tested, and executed in notebooks and Python pipelines without a separate Java or Docker runtime.
Mapping logic becomes unit-testable inside Python test frameworks, since each RML-Core case is exercised as a unit test.
User-defined transformation functions can be registered as RML functions and reused declaratively across mappings.
The reported conformance gives Python users a standards-based path to FAIR, ontology-aligned RDF generation from CSV, JSON, XML, SPARQL, and SQL sources.
Planned fixes for the 17 failing cases would bring near-complete RML-Core compliance to all supported source types.

Reading between the lines

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

The benchmark uses only minimal RML-Core cases, so the reported speedup is a lower-bound-style existence proof; how it scales to large, nested, or multi-source production data is left untested.
If the speed advantage is mostly due to avoiding JVM startup, then RMLMapper's separate process overhead, not its mapping engine, is what PyRML is beating on small inputs.
A natural extension would be to benchmark incremental materialization and memory footprint, since PyRML holds logical sources in Pandas DataFrames and materializes RDF via RDFLib.

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.

Desk Editor's Note

read the letter

PyRML is a genuinely useful piece of tooling: a Python-native RML engine that gives data scientists a programmatic way to build knowledge graphs. The conformance evaluation is the paper's real asset. PyRML passes all RML-Core tests for CSV, JSON, and XML, and 24/26 for SPARQL and 55/60 for each of three SQL dialects, with the failures honestly documented as bounded implementation gaps (SQL keyword quoting, null joins, xsd:boolean casting). The test scripts and Docker setup are on GitHub, so the claims are reproducible. That is real evidence, and the paper deserves credit for doing it properly.

The soft spot is the performance comparison with RMLMapper. The numbers come entirely from the RML-Core suite, which is minimal by design. On inputs that small, wall-clock time is dominated by process startup, and the reported gaps (roughly 0.6-0.8s per case) are exactly what you would expect from JVM startup alone. There are no row counts, no warm-up, no RMLMapper version, no confidence intervals or medians, just averages over 10 runs and standard deviations. That does not support the paper's conclusion that PyRML is 'consistently' faster or suited to latency-sensitive pipelines. The stress-test note is right on target.

Even so, I would not knock the paper down for this. The conformance work stands, and the performance section is a secondary selling point that can be fixed with a larger, realistic benchmark. The writing is clear, the limitations are stated, and the self-references in the adoption section are minor. My only other nit is the 'PostSQL' typo in Table 1.

This paper is for the Semantic Web community, specifically practitioners who want a Python-native RML option. It deserves peer review because the tool and conformance evidence are real, and the performance overreach is correctable. I would accept it, with a request that the benchmark be redone or the claims be softened accordingly.

Referee Report

2 major / 4 minor

Summary. The paper presents PyRML, a Python-native library for declarative knowledge graph construction using the RDF Mapping Language (RML). The system architecture consists of API, core, functions, and mapper modules; mappings can be defined programmatically or loaded from RML documents, and execution is based on Pandas DataFrames. The evaluation uses the official RML-Core test suite: PyRML passes all CSV/JSON/XML cases, 24/26 SPARQL cases, and 55/60 cases for each of MySQL, PostgreSQL, and SQL Server. A performance comparison against RMLMapper reports lower average execution times and lower standard deviations on all source types. The paper concludes that PyRML is standards-compliant and well-suited for automated or latency-sensitive KG pipelines.

Significance. If the conformance results are taken at face value, PyRML is a useful addition to the RML tooling landscape: it is open source, Python-native, has a programmatic interface, and its conformance is checked against an external standardized suite rather than a self-defined test set. The availability of the test scripts and Docker setup is commendable and makes the conformance evaluation reproducible. The performance claim is not yet convincing, but the conformance claim itself is well-supported and the performance weakness is fixable within the scope of a revision.

major comments (2)

[§4.1–4.2, Figure 2] The performance comparison does not support the conclusion that PyRML is consistently faster. The benchmark uses only the minimal RML-Core test cases, which Section 4.1 itself describes as minimal and deterministic; no input row counts are reported, no warm-up procedure is described, and no RMLMapper version or JVM configuration is given. On such tiny inputs, wall-clock time is plausibly dominated by process startup (Python/Pandas for PyRML, JVM for RMLMapper), and the reported gaps (e.g., CSV 1.06s vs 1.79s, XML 0.99s vs 1.83s) are consistent with a fixed offset of roughly 0.6–0.8s. To support the latency-sensitive claim in Section 5, the authors should add workloads large enough to amortize startup, report per-row or per-triple throughput, and include dataset sizes and engine versions.
[§4.2, Figure 2] The ‘lower standard deviation’ claim is not statistically supported. Each test case was executed only 10 times, and the paper reports averages and standard deviations without medians, confidence intervals, or a significance test; on such small samples, the standard deviation is itself noisy. Report per-run distributions and a paired test (or at least median and interquartile range) before claiming lower variance.

minor comments (4)

[Table 1] The row label “PostSQL” should be “PostgreSQL”.
[§4.2] The text says “error bars represent standard deviotions” and refers to values “reported among brackets,” but Figure 2 and its caption do not make clear where the bracketed values appear; please clarify.
[§3.1] There is a typo in “core molude” and inconsistent spacing in code listings; the snippets would be easier to read with proper syntax highlighting and consistent indentation.
[§3.2] The adoption metrics (GitHub stars, forks, clones, views) are not scientific evidence and could be moved to an availability section rather than presented as impact.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: PyRML's conformance and performance claims are evaluated against the external RML-Core test suite and RMLMapper, with no fitted inputs or self-defined targets.

full rationale

The paper's central claims are (i) that PyRML conforms to the RML-Core specification across several source types and (ii) that it is faster and more stable than RMLMapper. Both are assessed against external, independent references: the official RML-Core test cases maintained by the Knowledge Graph Construction Community Group, and the widely used RMLMapper engine. The conformance result is a direct pass/fail comparison of generated RDF graphs against expected outputs defined by an external standard, not against any quantity fitted from PyRML itself. The performance benchmark compares wall-clock execution times on the same test suite against a third-party engine; while the methodology may be questioned on grounds of representativeness or startup-cost effects, that is a benchmarking-validity concern, not circularity. The only self-citation is reference [12], used in the conclusion to point to LLM-assisted mapping generation as future work; it is not load-bearing for any central claim. The statement that PyRML's class hierarchy mirrors the RML/R2RML ontologies is a design description, not a derivation of correctness. No equation or fitted parameter is reused as a prediction, and no uniqueness theorem or prior result by the same author is invoked to force a choice. The derivation chain is therefore self-contained with respect to external tests and baselines.

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

The central claim rests on the validity of the RML-Core test suite as a conformance oracle and on the representativeness of that suite for performance benchmarking. No free parameters or invented entities are introduced.

assumptions (3)

domain assumption The RML-Core test suite is an authoritative and sufficient benchmark for RML compliance.
Section 4.1 uses this suite as the sole correctness oracle and treats passing tests as evidence of conformance.
ad hoc to paper The timing measurements on the small RML-Core test cases are representative of real-world performance.
Section 4.2 draws a 'consistent performance advantage' conclusion from these micro-benchmarks; no production-scale datasets are tested.
domain assumption RMLMapper was run under comparable conditions with no configuration disadvantage.
The paper does not specify RMLMapper version, JVM flags, or startup handling, so the comparison assumes fairness.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Streamlining Knowledge Graph Creation with PyRML." pith.science (2026). https://pith.science/paper/QDNYK7BZ

@misc{pith2026250520949,
  author       = {Pith},
  title        = {Pith review of: Streamlining Knowledge Graph Creation with PyRML},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QDNYK7BZ}},
  note         = {Machine review of arXiv:2505.20949}
}

read the original abstract

Knowledge Graphs (KGs) are increasingly adopted as a foundational technology for integrating heterogeneous data in domains such as climate science, cultural heritage, and the life sciences. Declarative mapping languages like R2RML and RML have played a central role in enabling scalable and reusable KG construction, offering a transparent means of transforming structured and semi-structured data into RDF. In this paper, we present PyRML, a lightweight, Python-native library for building Knowledge Graphs through declarative mappings. PyRML supports core RML constructs and provides a programmable interface for authoring, executing, and testing mappings directly within Python environments. It integrates with popular data and semantic web libraries (e.g., Pandas and RDFlib), enabling transparent and modular workflows. By lowering the barrier to entry for KG creation and fostering reproducible, ontology-aligned data integration, PyRML bridges the gap between declarative semantics and practical KG engineering.

Figures

Figures reproduced from arXiv: 2505.20949 by the authors.

**Figure 1.** The architecture of PyRML API module. The API module provides the abstract base classes that define the core structure of the programming interface for capturing the RML model within the software platform. At the top of this structure is the TermMap abstract base class, which represents any entity in an RML mapping associated with an IRI and intended for generating RDF data from a logical table. It is worth noting … view at source ↗

**Figure 2.** Comparison of PyRML with RMLMapper respect to execution time of test cases expressed in seconds. The results demonstrate a consistent performance advantage for PyRML across all source types. For example, on CSV sources, PyRML achieved an average execution time of 1.06 seconds, compared to 1.79 seconds for RMLMapper. Similar gains are observed for XML (0.99s vs. 1.83s), JSON (0.92s vs. 1.70s), and SPARQL (1.18s vs. … view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

14 extracted references · 9 canonical work pages

[1]

https://doi.org/10.3233/SW-223135

Arenas-Guerrero, J., Chaves-Fraga, D., Toledo, J., Pérez, M.S., Corcho, O.: Morph- KGC:Scalableknowledgegraphmaterializationwithmappingpartitions.Semantic Web15(1), 1–20 (2024). https://doi.org/10.3233/SW-223135

work page doi:10.3233/sw-223135 2024
[2]

Streamlining Knowledge Graph Construction with a fa\c{c}ade: The SPARQL Anything project

Asprino, L., Daga, E., Dowdy, J., Mulholland, P., Gangemi, A., Ratta, M.: Stream- lining knowledge graph construction with a fa\c{c}ade: The SPARQL Anything project. arXiv preprint arXiv:2310.16700 (2023)

work page Pith review arXiv 2023
[3]

In: Further with Knowledge Graphs, pp

Daga, E., Asprino, L., Mulholland, P., Gangemi, A.: Facade-X: an opinionated approach to SPARQL anything. In: Further with Knowledge Graphs, pp. 58–73. IOS Press (2021)

work page 2021
[4]

In: Bizer, C., Heath, T., Auer, S., Berners-Lee, T

Dimou, A., Sande, M.V., Colpaert, P., Verborgh, R., Mannens, E., de Walle, R.V.: Rml: A generic language for integrated rdf mappings of heterogeneous data. In: Bizer, C., Heath, T., Auer, S., Berners-Lee, T. (eds.) LDOW. CEUR Workshop Proceedings, vol. 1184. CEUR-WS.org (2014)

work page 2014
[5]

Friedman, M., Levy, A., Millstein, T.: Navigational plans for data integration. In: Proceedings of the sixteenth national conference on Artificial intelligence and the eleventh Innovative applications of artificial intelligence conference innovative applications of artificial intelligence. pp. 67–73. AAAI ’99/IAAI ’99, American Association for Artificial ...

work page 1999
[6]

VLDB Journal10(4), 270– 294 (2001)

Halevy, A.Y.: Answering queries using views: A survey. VLDB Journal10(4), 270– 294 (2001)

2001
[7]

ACM Computing Surveys54(4), 1–37 (May 2022)

Hogan, A., Blomqvist, E., Cochez, M., d’amato, C., Melo, G.D., Gutierrez, C., Kirrane, S., Gayo, J.E.L., Navigli, R., Neumaier, S., Ngomo, A.C.N., Polleres, A., Rashid, S.M., Rula, A., Schmelzeisen, L., Sequeda, J., Staab, S., Zimmer- mann, A.: Knowledge Graphs. ACM Computing Surveys54(4), 1–37 (May 2022). https://doi.org/10.1145/3447772,https://dl.acm.or...

doi:10.1145/3447772 2022
[8]

Semantic Web16(2), SW–243580 (2025)

Iglesias, E., Vidal, M.E., Collarana, D., Chaves-Fraga, D.: Empowering the sdm- rdfizer tool for scaling up to complex knowledge graph creation pipelines. Semantic Web16(2), SW–243580 (2025)

work page 2025

Show all 14 references

[9]

In: Payne, T.R., Presutti, V., Qi, G., Poveda-Villalón, M., Stoilos, G., Hollink, L., Kaoudi, Z., Cheng, G., Li, J

Iglesias-Molina, A., Van Assche, D., Arenas-Guerrero, J., De Meester, B., De- bruyne, C., Jozashoori, S., Maria, P., Michel, F., Chaves-Fraga, D., Dimou, A.: The RML Ontology: A Community-Driven Modular Redesign After a Decade of Experience in Mapping Heterogeneous Data to RDF...

2023
[10]

In: The Semantic Web- ISWC 2015: 14th International Semantic Web Conference, Bethlehem, PA, USA, October 11-15, 2015, Proceedings, Part I 14

Lembo, D., Mora, J., Rosati, R., Savo, D.F., Thorstensen, E.: Mapping analysis in ontology-based data access: Algorithms and complexity. In: The Semantic Web- ISWC 2015: 14th International Semantic Web Conference, Bethlehem, PA, USA, October 11-15, 2015, Proceedings, Part I 14...

2015
[11]

In: Proceedings of the twenty-first ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems

Lenzerini, M.: Data integration: a theoretical perspective. In: Proceedings of the twenty-first ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems. pp. 233–246. PODS ’02, ACM, New York, NY, USA (2002). https://doi.org/http://doi.acm.org/10.1145/543613.543644

2002
[12]

arXiv preprint arXiv:2503.05388 (2025)

Lippolis, A.S., Saeedizade, M.J., Keskisärkkä, R., Zuppiroli, S., Ceriani, M., Gangemi, A., Blomqvist, E., Nuzzolese, A.G.: Ontology generation using large language models. arXiv preprint arXiv:2503.05388 (2025)

2025 arXiv
[13]

Theoretical Com- puter Science239(2), 189–210 (2000)

Ullman, J.D.: Information integration using logical views. Theoretical Com- puter Science239(2), 189–210 (2000). https://doi.org/DOI: 10.1016/S0304- 3975(99)00219-4 Streamlining Knowledge Graph Creation with PyRML 17

2000 doi
[14]

Scientific Data3(1), 160018 (Mar 2016)

Wilkinson, M.D., Dumontier, M., Aalbersberg, I.J., Appleton, G., Axton, M., Baak, A., Blomberg, N., Boiten, J.W., da Silva Santos, L.B., Bourne, P.E., Bouw- man, J., Brookes, A.J., Clark, T., Crosas, M., Dillo, I., Dumon, O., Edmunds, S., Evelo, C.T., Finkers, R., Gonzalez-Bel...

2016

Pith tools

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

[1] [1]

https://doi.org/10.3233/SW-223135

Arenas-Guerrero, J., Chaves-Fraga, D., Toledo, J., Pérez, M.S., Corcho, O.: Morph- KGC:Scalableknowledgegraphmaterializationwithmappingpartitions.Semantic Web15(1), 1–20 (2024). https://doi.org/10.3233/SW-223135

work page doi:10.3233/sw-223135 2024

[2] [2]

Streamlining Knowledge Graph Construction with a fa\c{c}ade: The SPARQL Anything project

Asprino, L., Daga, E., Dowdy, J., Mulholland, P., Gangemi, A., Ratta, M.: Stream- lining knowledge graph construction with a fa\c{c}ade: The SPARQL Anything project. arXiv preprint arXiv:2310.16700 (2023)

work page Pith review arXiv 2023

[3] [3]

In: Further with Knowledge Graphs, pp

Daga, E., Asprino, L., Mulholland, P., Gangemi, A.: Facade-X: an opinionated approach to SPARQL anything. In: Further with Knowledge Graphs, pp. 58–73. IOS Press (2021)

work page 2021

[4] [4]

In: Bizer, C., Heath, T., Auer, S., Berners-Lee, T

Dimou, A., Sande, M.V., Colpaert, P., Verborgh, R., Mannens, E., de Walle, R.V.: Rml: A generic language for integrated rdf mappings of heterogeneous data. In: Bizer, C., Heath, T., Auer, S., Berners-Lee, T. (eds.) LDOW. CEUR Workshop Proceedings, vol. 1184. CEUR-WS.org (2014)

work page 2014

[5] [5]

Friedman, M., Levy, A., Millstein, T.: Navigational plans for data integration. In: Proceedings of the sixteenth national conference on Artificial intelligence and the eleventh Innovative applications of artificial intelligence conference innovative applications of artificial intelligence. pp. 67–73. AAAI ’99/IAAI ’99, American Association for Artificial ...

work page 1999

[6] [6]

VLDB Journal10(4), 270– 294 (2001)

Halevy, A.Y.: Answering queries using views: A survey. VLDB Journal10(4), 270– 294 (2001)

2001

[7] [7]

ACM Computing Surveys54(4), 1–37 (May 2022)

Hogan, A., Blomqvist, E., Cochez, M., d’amato, C., Melo, G.D., Gutierrez, C., Kirrane, S., Gayo, J.E.L., Navigli, R., Neumaier, S., Ngomo, A.C.N., Polleres, A., Rashid, S.M., Rula, A., Schmelzeisen, L., Sequeda, J., Staab, S., Zimmer- mann, A.: Knowledge Graphs. ACM Computing Surveys54(4), 1–37 (May 2022). https://doi.org/10.1145/3447772,https://dl.acm.or...

doi:10.1145/3447772 2022

[8] [8]

Semantic Web16(2), SW–243580 (2025)

Iglesias, E., Vidal, M.E., Collarana, D., Chaves-Fraga, D.: Empowering the sdm- rdfizer tool for scaling up to complex knowledge graph creation pipelines. Semantic Web16(2), SW–243580 (2025)

work page 2025