Joachim Van Herwegen

Query Execution Optimization for Clients of Triple Pattern Fragments

In order to reduce the server-side cost of publishing queryable Linked Data, Triple Pattern Fragments tpf were introduced as ai¾?simple interface to rdf triples. They allow for sparql query execution at low server cost, by partially shifting the load from servers to clients. The previously proposed query execution algorithm uses more http requests than necessary, and only makes partial use of the available metadata. In this paper, we propose a new query execution algorithm for a client communicating with a tpf server. In contrast to ai¾?greedy solution, we maintain an overview of the entire query to find the optimal steps for solving a given query. We show multiple cases in which our algorithm reaches solutions with far fewer http requests, without significantly increasing the cost in other cases. This improves the efficiency of common sparql queries against tpf interfaces, augmenting their viability compared to the more powerful, but more costly, sparql interface.

Opportunistic Linked Data Querying Through Approximate Membership Metadata

Between urii¾?dereferencing and the sparql protocol lies ai¾?largely unexplored axis of possible interfaces to Linked Data, each with its own combination of trade-offs. One of these interfaces is Triple Pattern Fragments, which allows clients to execute sparql queries against low-cost servers, at the cost of higher bandwidth. Increasing a clients efficiency means lowering the number of requests, which can among others be achieved through additional metadata in responses. We noted that typical sparql query evaluations against Triple Pattern Fragments require ai¾?significant portion of membership subqueries, which check the presence of ai¾?specific triple, rather than ai¾?variable pattern. This paper studies the impact of providing approximate membership functions, i.e., Bloom filters and Golomb-coded sets, as extra metadata. In addition to reducing http requests, such functions allow to achieve full result recall earlier when temporarily allowing lower precision. Half of the tested queries from ai¾?WatDiv benchmark test set could be executed with up to ai¾?third fewer http requests with only marginally higher server cost. Query times, however, did not improve, likely due to slower metadata generation and transfer. This indicates that approximate membership functions can partly improve the client-side query process with minimal impact on the server and its interface.

Substring Filtering for Low-Cost Linked Data Interfaces

Recently, Triple Pattern Fragments tpfs were introduced as ai¾?low-cost server-side interface when high numbers of clients need to evaluate sparql queries. Scalability is achieved by moving part of the query execution to the client, at the cost of elevated query times. Since the tpfs interface purposely does not support complex constructs such as sparql filters, queries that use them need to be executed mostly on the client, resulting in long execution times. We therefore investigated the impact of adding ai¾?literal substring matching feature to the tpfs interface, with the goal of improving query performance while maintaining low server cost. In this paper, we discuss the client/server setup and compare the performance of sparql queries on multiple implementations, including Elastic Search and case-insensitive fm-index. Our evaluations indicate that these improvements allow for faster query execution without significantly increasing the load on the server. Offering the substring feature on tpf servers allows users to obtain faster responses for filter-based sparql queries. Furthermore, substring matching can be used to support other filters such as complete regular expressions or range queries.

Knowledge Representation as Linked Data: Tutorial

The process of extracting, structuring, and organizing knowledge requires processing large and originally heterogeneous data sources. Offering existing data as Linked Data increases its shareability, extensibility, and reusability. However, using Linking Data as a means to represent knowledge can be easier said than done. In this tutorial, we elaborate on how to semantically annotate data, and generate and publish Linked Data. We introduce [R2]RML languages to generate Linked Data. We also show how to easily publish Linked Data on the Web as Triple Pattern Fragments. As a result, participants, independently of their knowledge background, can model, annotate and publish Linked Data on their own.

ComSem: Digitization and Semantic Annotation of Comic Books

The popularity of digital comic books keeps rising, causing an increase in interest from traditional publishers. Digitizing existing comic books can require much work though, since older comic books were made when digital versions were not taken into account. Additions such as digital panel segmentation and semantic annotation, which increase the discoverability and functionality, were only introduced at a later point in time. To this end, we made ComSem: a tool to support publishers in this task by automating certain steps in the process and making others more accessible. In this paper we present our demo and how it can be used to easily detect comic book panels and annotate them with semantic metadata.

Interactive Comparison of Triple Pattern Fragments Query Approaches

In order to reduce the server-side cost of publishing queryable Linked Data, Triple Pattern Fragments tpf were introduced as ai¾źsimple interface to rdf triples. They allow for sparql query execution at low server cost, by partially shifting the load from servers to clients. The previously proposed query execution algorithm provides a solution that is highly inefficient, often requiring an amount of http calls that is magnitudes larger than the optimal solution. We have proposed a new query execution algorithm with the aim to solve this problem. Our solution significantly improves on the current work by maintaining a complete overview of the query instead of just looking at local optima. In this paper, we describe a demo that allows a user to easily compare the results of both implementations. We show both query results and number of executed http calls, proving a clear picture of the difference between the two algorithms.