Creating Vocabulary Mappings and Data Structures to Assist in the Creation of Modern Data Format Files


The popularity of modern data formats like JSON-LD, Turtle, N-Triples is on the rise due to the increasing need for effective data interoperability, integration, and the desire to derive meaningful insights from large and diverse data sets. Standard vocabularies, such as those used in the Semantic Web and Linked Data contexts, provide a common language for annotating and understanding data. They enable data from different sources or domains to be easily combined and understood, enhancing data interoperability and reusability. These standard vocabularies also foster consistency, improve data quality, and facilitate machine-readability, thereby enhancing the overall value and utility of data. Meanwhile, SPARQL, as a powerful query language for RDF data, allows users to retrieve and manipulate data stored in RDF format. It supports complex queries, enabling the extraction of meaningful insights from large and diverse datasets. The ability of SPARQL to traverse complex data relationships, combined with the use of standard vocabularies, offers a sophisticated and flexible approach for data analysis in today’s data-rich world.

Mapping technical metadata to a standard vocabulary

One task that is highly recommended to do when working with Linked Data and SPARQL is to map a dataset’s technical metadata with standard (or customized) vocabularies.

Technical metadata terms where often created a long time ago and may have not been named in an optimal way to provide a highly meaningful name. Mapping this metadata to a vocabulary can enable us to ask more meaningful and insightful questions about a particular dataset.

More explicitly, mapping technical metadata to a standard vocabulary, often referred to as an ontology, offers several key benefits, especially in terms of data interoperability, reusability, and understanding:

  • Interoperability – Standard vocabularies are shared and understood across different systems, platforms, and communities. By using them, you ensure that your data can be easily exchanged and understood outside of its original context. This is particularly important for web-based data sharing (e.g., in the Semantic Web or Linked Data contexts) and for collaborations across different organizations or disciplines.
  • Reusability – By mapping to a standard vocabulary, you’re not only making your data understandable to others, but you’re also making it reusable. Other people can use your data for their own purposes, and you can use theirs, provided you’re all using the same vocabularies.
  • Data Integration – When data from different sources or domains is mapped to the same standard vocabulary, it can be easily combined and analyzed together, facilitating data integration tasks.
  • Consistency and Quality – Standard vocabularies provide a consistent way of describing data. By adopting a standard vocabulary, you help ensure the consistency and quality of your metadata, making it more reliable.
  • Semantic Understanding – Standard vocabularies often come with defined semantics, i.e., the meaning of terms is explicitly defined and agreed upon. This enhances the machine-readability and understanding of your data.
  • Search and Discovery – Metadata mapped to standard vocabularies can be more easily indexed and discovered by search engines or other discovery tools that are aware of these vocabularies. This can improve the visibility and accessibility of your data.
  • Future-Proofing – Standards tend to persist over time, and by mapping your metadata to a standard, you’re helping to future-proof your data against changes in specific technologies or platforms.

By mapping technical metadata to standard vocabularies, you’re improving the overall value and utility of your data. However, it’s important to choose the right vocabularies for your specific needs, and to keep in mind that mapping is an investment that requires effort to set up and maintain.

Key decisions when creating mappings between technical metadata and vocabularies

Creating mappings between technical metadata and standard vocabularies is a nuanced process with multiple approaches, each with its own trade-offs. There is no single “perfect” solution, as the best approach largely depends on the specific data, use cases, and the broader data strategy of your organization. Some might opt for a direct mapping to properties for granular detail and simplicity, while others might choose to map to classes for a structured and organized data model. These decisions directly impact how you will interact with your data, particularly when it comes to querying with SPARQL. For example, mapping directly to properties can lead to simpler SPARQL queries, as you can directly access and manipulate specific data elements. However, mapping to classes might provide a richer context for your data, enabling more complex analyses and inferences, even though it might require more intricate SPARQL queries. Ultimately, the mapping strategy should be a considered decision based on an understanding of these trade-offs, and it should align with the needs of your data consumers, the nature of your data, and the goals of your organization.

Following we’ll discuss some of drivers and dimensions to consider when creating these mappings.

Mapping granularity

Granularity is a critical factor to consider when mapping vocabularies to technical metadata. It refers to the level of detail represented in the mappings. High granularity means the metadata is broken down into very detailed components, while low granularity refers to a more generalized or high-level view of the metadata. The degree of granularity chosen can have significant implications for how your data is used and understood. For instance, more granular mappings can provide a detailed understanding of data elements, making them useful for precise data analysis or operations on specific data elements. They can also support complex SPARQL queries, enabling the extraction of nuanced insights from the data. On the other hand, less granular mappings can simplify data navigation and understanding, particularly for high-level data management or governance tasks. However, they might not support detailed queries or analyses. The choice of granularity should therefore be guided by the nature of your data, the intended use cases, and the needs of your data consumers. Balancing granularity with usability is key to creating effective mappings that serve your organization’s data strategy.

The granularity of your enterprise-wide vocabulary definitions should be determined by several factors, including the intended usage of the vocabulary, the complexity and diversity of your data, and the needs of your users. Here are some considerations:

  • Intended Usage – If the vocabulary will be used for high-level data management and governance, more general terms may be sufficient. However, if the vocabulary will be used for detailed data analysis, more granular terms may be needed.
  • Data Complexity and Diversity – If your enterprise deals with a wide range of diverse data types and domains, a more granular vocabulary may be required to adequately represent and distinguish between these different types of data.
  • User Needs – The needs of your users should also inform the granularity of your vocabulary. If users need to perform detailed queries or analysis on the data, a more granular vocabulary will be beneficial. Conversely, if users primarily need to understand and navigate the data at a high level, a less granular vocabulary may suffice.
  • Balance – It’s important to strike a balance between granularity and usability. A vocabulary that is too granular may become unwieldy and difficult to use, while a vocabulary that is not granular enough may not provide sufficient detail to be useful.
  • Future-Proofing – Consider the future needs of your enterprise as well. It may be beneficial to err on the side of more granularity to accommodate future use cases, even if it’s not immediately needed.
  • Consistency with Existing Standards – If you’re basing your vocabulary on existing standards or linking it to external vocabularies, the granularity of these standards may also inform the granularity of your vocabulary.

Remember, creating an enterprise-wide vocabulary is not a one-size-fits-all task. The best approach will depend on the specific needs and context of your enterprise. It can be helpful to involve a diverse group of stakeholders in the process to ensure that the vocabulary meets the needs of all users.

Granularity Example

Let’s take an example from a healthcare domain. Suppose you’re mapping technical metadata related to patient information to a standard vocabulary.

  1. High Granularity: Here, you would have very specific, detailed classes or properties. For instance, you could have distinct classes for `Patient`, `MedicalHistory`, `Prescription`, `Doctor`, and so on. Under each of these classes, you could have specific properties. For example, under Patient, you might have properties like `firstName`, `lastName`, `dateOfBirth`, `gender`, `address`, `contactNumber`, and more. Under `MedicalHistory`, you could have `diagnoses`, `surgeries`, `allergies`, etc. This level of detail allows for very specific querying and analysis. For example, you could easily retrieve all patients who have a specific diagnosis, or find out the average age of patients with a certain type of allergy.
  2. Low Granularity: In this case, you might have a more generalized class like `PatientInformation`, with properties such as `name`, `contactInfo`, `medicalDetails`. Here, the properties are more generalized and less detailed. For example, `medicalDetails` might be a text field that includes all medical history information. This level of granularity simplifies the data model but can limit the specificity of your queries. For instance, it would be challenging to use this model to retrieve all patients with a specific diagnosis, as that information is nested within the `medicalDetails` property.

In both cases, the level of granularity chosen has significant implications for how the data can be used, queried, and understood. Higher granularity allows for more specific querying and analysis but can lead to more complex data models, while lower granularity simplifies the data model but can limit the specificity of your queries. The right balance will depend on your specific data and use cases.

Mapping to classes or properties

When mapping fields to vocabularies in a domain, the best approach depends on the level of granularity and specificity you need for your data. Both mapping to classes (such as `ContactPoint`) and properties (like `telephone`) have their benefits and can be used effectively based on the context and requirements of your data model.

Mapping to Classes – Mapping to classes, such as `ContactPoint`, can be beneficial when you want to group related properties and represent them as a cohesive unit. By mapping to a class, you can create a more structured data model that represents the relationships and hierarchy between different entities. This approach is particularly useful when you have multiple properties related to the same concept, like different contact details for a customer.

Benefits of mapping to classes

  1. Provides a more structured and organized data model.
  2. Enables better representation of relationships and hierarchy between entities.
  3. Facilitates easier navigation and querying of the data.

Mapping to Properties – Mapping directly to properties, such as `telephone`, can be useful when you want to focus on specific data elements and their values. This approach allows for a more granular representation of your data, making it easier to search, filter, and analyze based on individual properties.

Benefits of mapping to properties

  1. Offers a more granular and detailed representation of data.
  2. Simplifies searching, filtering, and analyzing specific data elements.
  3. Provides flexibility to map data elements independently of their related classes.

Ultimately, the best approach depends on your specific use case and data modeling requirements. You can also use a combination of both mapping to classes and properties to achieve the desired level of granularity and organization in your data model.

Implications of mapping to classes or properties when querying data

The decision to map data to classes versus properties can significantly impact how you construct and execute SPARQL queries against these mappings. Here are some implications and consequences to consider:

  1. Query Complexity – Mapping to classes may lead to more complex SPARQL queries. For example, if you map to a class like `ContactPoint`, you may need to traverse several levels of classes and properties to retrieve a specific piece of information, like a telephone number. On the other hand, mapping directly to properties like `telephone` simplifies your queries as you can directly access the desired data.
  2. Flexibility – Mapping to properties gives you flexibility to query individual data elements independently. However, mapping to classes, while it might complicate the query, provides more context about the relationships between different data elements, which might be beneficial for certain types of queries or analysis.
  3. Data Integrity and Consistency – When you map to classes, it can help enforce a certain level of data integrity and consistency, as you are essentially creating a more rigid schema that data must adhere to. This can be beneficial when running SPARQL queries, as you can have more confidence in the structure and format of the data you’re querying.
  4. Resource Retrieval – If data is mapped to classes, retrieving all data related to a particular resource could be more straightforward. A simple SPARQL query could retrieve all data related to an instance of a class. If data is directly mapped to properties, retrieving all related data might require a more complex query, depending on the structure of the data.
  5. Performance – Depending on the RDF store and the complexity of your dataset and queries, there may be performance implications. More complex queries (like those potentially required when mapping to classes) might lead to slower query execution times.

Remember, the choice between mapping to classes or properties isn’t always an either/or situation. In many cases, a combination of both is used to balance the need for detailed data access and maintaining a structured, understandable data model.

Mapping to both classes and properties

It is possible and quite common to map technical metadata to both classes and properties when creating semantic models. This approach helps to provide a balance between detail (properties) and structure (classes), facilitating a better understanding and usage of the data.

Using classes, you can group related properties together and represent them as a cohesive unit, providing a high-level view of the data’s structure. This is useful when you want to understand the relationships between different data elements and navigate through the data in a structured manner.

On the other hand, mapping directly to properties allows you to provide more granular detail about specific data elements. This is beneficial when you want to perform operations or queries on specific pieces of data.

By combining both approaches, you can create a semantic model that is both structured and detailed. This allows for more flexibility when running SPARQL queries, as you can choose to either retrieve data at a high level (based on classes) or drill down to specific data elements (based on properties).

However, it’s important to note that the choice of whether to map to classes, properties, or both should depend on the specific needs and requirements of your project. Carefully consider the nature of your data, how it will be used, and what kind of queries you expect to run before deciding on your mapping strategy.

Hierarchical versus flattened data model representations

When modeling data that will be converted to modern data formats, the choice between using a flattened data structure and a more hierarchical structure depends on your specific use case and requirements. Both approaches have their own benefits and drawbacks:

Flattened Data Structures


  1. Simplicity – Flattened structures are generally easier to understand and work with because they don’t involve nested elements.
  2. Data Manipulation – With a flat structure, operations like sorting, filtering, and querying can be simpler and more efficient because all the data is on the same level.
  3. Data Consistency – Flattened structures can help ensure data consistency as each piece of information has a specific place and there’s less room for ambiguity.


  1. Lack of Context – In a flattened structure, the relationships between different data elements might not be as clear or well-defined.
  2. Redundancy – Flat structures can lead to data redundancy if the same data needs to be repeated for multiple items.
  3. Scalability Issues – Flat structures can become unwieldy as your data grows in complexity.

Hierarchical Data Structures


  1. Context and Relationships – Hierarchical structures can clearly show the relationships between different data elements, providing more context.
  2. Efficient Representation – Hierarchical structures can often represent complex data more efficiently, reducing redundancy.
  3. Natural Fit for Certain Types of Data – Some types of data, like organizational structures or file directories, naturally fit into a hierarchical structure.


  1. Complexity – Hierarchical structures can become complex and difficult to understand or navigate, particularly for deeply nested data.
  2. Data Manipulation – Operations like sorting, filtering, and querying can be more complex with hierarchical structures.
  3. Flexibility – Hierarchical structures can be less flexible as they rigidly define the relationships between data elements.

Ultimately, the decision between flattened and hierarchical structures should be guided by factors like the nature of your data, the intended use cases, and the needs of your users. It’s also worth noting that JSON-LD allows for a mix of both flat and hierarchical structures, providing flexibility to accommodate various data modeling needs.


the process of mapping technical metadata to standard vocabularies, and the selection of data structures, whether hierarchical or flat, require a deep understanding of the data, its intended uses, and the needs of the data consumers. It’s critical to balance granularity with usability, as the level of detail in your mappings and data structures can significantly impact your ability to query and analyze your data.

Tools like OpenRefine, which facilitate the mapping process, can be instrumental in helping organizations leverage the power of Linked Data and Semantic Web technologies. Yet, the tool is only as effective as the strategies that guide its use.

The decision to map to classes, properties, or both in standard vocabularies depends on various factors including the nature of your data, and the complexity of the queries you intend to run. While mapping to properties might simplify SPARQL queries, mapping to classes can provide a richer context for your data, enabling more complex analyses and inferences.

When it comes to data structures in formats like JSON-LD, a balance between flat and hierarchical structures often needs to be struck. Flattened structures offer simplicity and ease of data manipulation, while hierarchical structures provide clarity in data relationships and can efficiently represent complex data.

Ultimately, these decisions should not be made in isolation but should be part of a broader data strategy that aligns with your organization’s objectives and the needs of your data consumers. There is no one-size-fits-all approach, and it’s important to understand the trade-offs involved to make informed decisions.