The RDF Mapping Language (RML) enables, among other formats, the mapping of tabular data as Comma-Separated Values (CSV) les to RDF graphs. Unfortunately, the widely used spreadsheet format is currently neglected by its speci cation and well-known implementations. Therefore, we extended RML Mapper to support Microsoft Excel spreadsheet les and demonstrate its capabilities in an interactive online demo. Our approach allows to access various meta data of spreadsheet cells in typical RML maps. Some experimental features for more speci c use cases are also provided. The implementation code is publicly available in a GitHub fork.
As soon as knowledge graphs have to be constructed from given data, the
use of mapping languages is a common practice. Such languages let users de ne
declarative rules to map various input data formats to a complex interconnected
graph. In the Semantic Web community such graphs are usually modeled with
the Resource Description Framework (RDF) [
Since the spreadsheet methodology enables a well understood, easy and fast possibility to enter data, they are widely used by knowledge workers, especially in the industrial sector. In contrast to simply structured CSV les, spreadsheets can model complex workbooks containing multiple sheets with cells having rich meta data. Besides its content, a single cell may store additional information such as its appearance (colors, styles and borders) or cell comments. How these cells should be lled or styled by users is not predetermined by spreadsheet applications in general. As a consequence, in practice, cells can contain inconsistent and unstructured content which can be arbitrarily arranged in a sheet. That is why a mapping of such data to RDF can become a challenging task.
Although spreadsheets are frequently used in industry, well-known RML-based
mappers such as RML Mapper3, CARML4, RocketRML [
In summary, this demo paper presents the following contributions to RML: { an implementation to access Excel spreadsheets via an RML logical source in order to iterate (and also lter) cells in sheets { a mechanism to retrieve cell meta data by relative and absolute distances in an RML reference formulation { two experimental features to map from one cell (a) information of di erent properties and (b) multiple complex entities { a prototypical implementation of the features in RML Mapper In the next section, we describe in detail how we realized the Excel support in RML. 2
Our approach is implemented as an extension to the RML Mapper tool in a separate GitHub fork6. For demonstration purpose, we additionally provide an interactive demo page7 where visitors can try various mapping examples.
At its core, our component utilizes the Apache POI8 library to read Microsoft Excel spreadsheets as a rst step, but it is conceivable in future to support also 3 https://github.com/RMLio/rmlmapper-java 4 https://github.com/carml/carml 5 https://github.com/shenwei356/csvtk 6 https://github.com/mschroeder-github/rmlmapper-java/tree/mschroederfeatures 7 http://www.dfki.uni-kl.de/~mschroeder/demo/excel-rml 8 https://poi.apache.org other spreadsheets such as LibreO ce or Google Spreadsheets by using appropriate APIs. In order to refer to spreadsheet contents as a logical source, a small spreadsheet ontology9 (usually pre xed with ss) was designed. As demonstrated in Listing 1.1, using a spreadsheet reference formulation (Line 2), a workbook source should name a spreadsheet le (Line 5), a referring sheet by name (Line 6) and a range of cells in the sheet (Line 7). A triples map that uses this logical source will iterate over single cells in the given range.
Listing 1.1: Exemplary RML de nition of a spreadsheet le as a logical source. 1 [ a rml : L o g i c a l S o u r c e ; 2 rml : r e f e r e n c e F o r m u l a t i o n q l : S p r e a d s h e e t ; 3 rml : s o u r c e [ 4 a s s : Workbook ; 5 s s : u r l " workbook . x l s x " ; 6 s s : sheetName " Papers " ; 7 s s : range "A2 : A5" ; 8 s s : j a v a S c r i p t F i l t e r "/Knownnw∗ / . t e s t ( v a l u e S t r i n g ) " # o p t i o n a l 9 ] 10 ]
Optionally, a lter can be added that picks certain cells based on a JavaScript program (Line 8). Regarding our example, a regular expression is used to iterate over only those cells which contain the phrase \Know". Using the expressive script language and variables that represent cell meta data, appropriate lter procedures can be realized. However, it is also conceivable to implement it as an FnO function instead, which receives cell meta data and returns a boolean value.
Listing 1.2: Demonstration of how cell meta data can be accessed in RML maps.
1 r r : subjectMap [
2 r r : template " http : / / example . org /f a d d r e s s g"
3 ] ;
4 r r : predicateObjectMap [
5 r r : predicateMap [
6 r r : template " http : / / example . org / f [
In various RML maps, meta data of the currently iterated cell can be retrieved, as demonstrated in Listing 1.2. For example in Line 2, a template expression inserts the cell's address (like \A2") to form a unique URI for a subject resource. However, often it is required to refer to nearby cells in order to construct appropriate statements. To refer to other cells relatively from the current cell, we introduce a parenthesis notation, like (column,row). A column shift (x-axis of the sheet) and a row shift (y-axis of the sheet) allows to reach any cell relative to the cell representing the subject resource. Regarding Line 9 of our example, numeric values which are located two columns away on the right are used as objects in the mapped statements. In a similar way, cells can be referenced absolutely by using square brackets (Line 6). We use relative and absolute distances, because 9 http://www.dfki.uni-kl.de/~mschroeder/ld/ss spreadsheets in general can contain arbitrarily structured tables without any anchor points like column names (in contrast to CSVs).
As already mentioned, spreadsheet cells have several meta data values that need to be retrievable in a mapping through variables (written in the following with monospaced font). A cell's location in a sheet can be accessed either as a usual spreadsheet address or as column and row indices. Since a cell (if not empty) stores either a string value or a numeric value, various possibilities are given to access its content: valueNumeric retrieves a oating point value (valueInt an integer value), valueBoolean a boolean value, valueFormula if a cell contains a formula (valueError to get its possible error code) and valueString retrieves its text content. Besides content, one could also be interested in the appearance of a cell in a sheet: since it can be colored, backgroundColor and foregroundColor can be queried as a hexadecimal RGB value. Regarding the used font, fontColor, fontName and fontSize are available. On a more ne-grained level, cells can also store formatted text which is returned by valueRichText. The formatted text is represented in an HTML syntax to enable usual XML-parsers to access tags and attributes, for example, \ b¡ i¡ font face='Arial' color='# 0000'¡red, italic and bold /font¡ /i¡ /b¡".
If spreadsheets were completed in an inconsistent manner, it happens that cells were unintentionally lled with di erent data types. For such cases, one can use the value variable to always obtain a string representation of a cell's content regardless of its cell type. However, if this is not su cient because more details are needed, the json variable could be used to retrieve a JavaScript Object Notation (JSON) representation of a cell. The JSON object contains, besides the cell type, various data types mentioned above.
In our demo implementation, we do not retrieve all aspects of a spreadsheet (e.g. border thickness), yet they could easily be added to our code if desired. 2.1
Experimental Features We also would like to propose some experimental features that we found useful in our use cases. However, the o cial introduction of these extensions would require to change the RML speci cation on some points.
Multiple Di erent Properties in a Cell. In our use cases, we frequently
experienced that users record multiple information in one cell. Each piece of
information ij P I then corresponded to a di erent property pj P P . Following the
current RML speci cation, one has to de ne for each pj P P a separate
predicateobject map. Instead, we propose a shortcut such that only one predicate-object
map is needed. This is done by allowing that an RDF list of properties pj P P
can be passed in a predicate map. By implementing a suitable Function Ontology
(FnO) [
Multiple Complex Entities in a Cell. Similarly to the previous observation, we often discovered that users mention several entities in a single cell. A prominent example is a list of persons having rst and last names, for instance book authors. Represented as an RDF graph, such complex entities potentially require several statements to be fully expressed. An FnO function that is able to perform entity extraction would need to return an arbitrary large RDF graph in a certain serialization format (e.g. Turtle) instead of a single value. In order to integrate such a return value in an object map, we de ne a new term type ss:Graph. Once this term type is chosen, the returning RDF graph is parsed and added to the emerging knowledge graph. To prevent that all returning resources are mapped in the object map, a special ss:SelectedObjects resource together with rr:object statements should be returned by the function, too. This way, all resources are added to the knowledge graph, yet only selected ones are mapped. 3
In the past, several similar approaches were implemented that map spreadsheets to RDF using a language. Domain speci c languages (DSL) other than RML are provided to let knowledge engineers express how input data shall be mapped to a graph structure.
Spread2RDF10 uses a Ruby-internal language while M 2 (Mapping Master)
[
With our implementation, we combine the feature of mapping spreadsheets with the advantages of the well speci ed RML approach. Those who already used the language and need to process spreadsheets do not have to look for an alternative anymore. 4
In this paper we discussed that spreadsheets, despite being widely used, are still not supported by the RDF Mapping Language (RML). We therefore proposed a rst solution which extends the already existing RML Mapper tool with necessary components. Additionally, experimental features were introduced too. A publicly available web page12 demonstrates the new capabilities. 10 https://github.com/marcelotto/spread2rdf 11 https://github.com/Data2Semantics/TabLinker 12 http://www.dfki.uni-kl.de/~mschroeder/demo/excel-rml
In the future, we plan to integrate our proposed solution in the RML speci
cation [
Acknowledgements This work was funded by the BMBF project SensAI (grant no. 01IW20007). 13 https://github.com/kg-construct/r2rml-implementation-report