Search

Making predictions bounded by uncertainty is a crucial component of modern decision support systems. Knowledge graphs provide a structured, semantic-oriented approach to data integration, storage and retrieval; however, they represent data in an absolute way and do not natively support reasoning under uncertain future conditions. In this paper, we present a novel technique for building a probabilistic model from a knowledge graph using a Bayesian network, which is a step towards enabling probabilistic reasoning under uncertainty within a knowledge graph. Our approach supports mixing of continuously and discretely-distributed variables, which is necessary for jointly processing real-world data, but has not typically been supported in prior work. As an interface to the probabilistic model, we propose an extension of the SPARQL query language called Orion DSL, which is currently a working prototype. We also define a custom probabilistic ontology in order to store outputs of the model directly in the knowledge graph alongside the original data, which we refer to as a Probabilistic Knowledge Graph (PKG). The evaluation shows that: (1) the dependencies and distributions of data in a synthetically-generated knowledge graph were accurately captured by the Bayesian model, and (2) an SPARQL query against the PKG to retrieve computed probability distributions was orders of magnitude more performant than a similarly-intentioned query against the base knowledge graph. We anticipate that the models generated by this system will have applications in the areas of predicting missing data, approximate query processing, and utility-based optimization. Future work will involve more detailed explorations of each of these topics as we work towards a PKG-based decision support system. [ABSTRACT FROM AUTHOR]

A critical issue in Big Data management is to address the variety of data–data are produced by disparate sources, presented in various formats, and hence inherently involves multiple data models. Multi-Model DataBases (MMDBs) have emerged as a promising approach for dealing with this task as they are capable of accommodating multi-model data in a single system and querying across them with a unified query language. This article aims to offer a comprehensive survey of a wide range of multi-model query languages of MMDBs. In particular, we first present the SQL-based extensions toward multi-model data, including the standard SQL extensions such as SQL/XML, SQL/JSON, and GQL, and the non-standard SQL extensions such as SQL++ and SPASQL. We then study the manners in which document-based and graph-based query languages can be extended to support multi-model data. We also investigate the query languages that provide native support on multi-model data. Finally, this article provides insights into the open challenges and problems of multi-model query languages. [ABSTRACT FROM AUTHOR]

The Graph Query Language (GraphQL) is a powerful language for application programming interface (API) manipulation in web services. It has been recently introduced as an alternative solution for addressing the limitations of RESTful APIs. This article introduces an automated solution for GraphQL API testing. We present a full framework for automated API testing, from the schema extraction to test case generation. In addition, we consider two kinds of testing: white-box and black-box testing. The white-box testing is performed when the source code of the GraphQL API is available. Our approach is based on evolutionary search. Test cases are evolved to intelligently explore the solution space while maximizing code coverage and fault-finding criteria. The black-box testing does not require access to the source code of the GraphQL API. It is therefore of more general applicability, albeit it has worse performance. In this context, we use a random search to generate GraphQL data. The proposed framework is implemented and integrated into the open source EvoMaster tool. With enabled white-box heuristics (i.e., white-box mode), experiments on 7 open source GraphQL APIs and three search algorithms show statistically significant improvement of the evolutionary approach compared to the baseline random search. In addition, experiments on 31 online GraphQL APIs reveal the ability of the black-box mode to detect real faults. [ABSTRACT FROM AUTHOR]

Graph mining has emerged as a significant field of research with applications spanning multiple domains, including marketing, corruption analysis, business, and politics. The exploration of knowledge within graphs has garnered considerable attention due to the exponential growth of graph-modeled data and its potential in applications where data relationships are a crucial component, and potentially being even more important than the data themselves. However, the increasing use of graphs for data storing and modeling presents unique challenges that have prompted advancements in graph mining algorithms, data modeling and storage, query languages for graph databases, and data visualization techniques. Despite there being various methodologies for data analysis, they predominantly focus on structured data and may not be optimally suited for highly connected data. Accordingly, this work introduces a novel methodology specifically tailored for knowledge discovery in labeled and heterogeneous graphs (KDG), and it presents three case studies demonstrating its successful application in addressing various challenges across different application domains. [ABSTRACT FROM AUTHOR]

A natural language interface (NLI) to databases is an interface that translates a natural language question to a structured query that is executable by database management systems (DBMS). However, an NLI that is trained in the general domain is hard to apply in the spatial domain due to the idiosyncrasy and expressiveness of the spatial semantics. Moreover, there are a wide range of database servers available, and a unilingual NLI model limits its practical usage. In this article, we propose to not only address the spatial domain generalization challenge, but also support multilingual back-end, i.e., supporting different query languages, such as SQL and Prolog. For the challenge of spatial semantics, we propose a spatial comprehension model that is able to recognize the meaning of spatial entities based on the semantics of context and effectively resolve the ambiguity given the spatial semantics. The spatial semantics learned from the spatial comprehension model is then injected to the natural language question to ease the burden of capturing the spatial-specific semantics. We also propose to add a prefix symbol to support the multilingual back-end (e.g., query languages). With our spatial comprehension model and symbol injections, our NLI for the spatial domain, named SpatialNLI, is able to capture the semantic structure of the question and translate it to the corresponding syntax of an executable query accurately. We also experimentally ascertain that SpatialNLI outperforms state-of-the-art methods. [ABSTRACT FROM AUTHOR]

The requirement for data interchange, access, and retrieval from diverse databases. This requirement is getting more and more crucial. However, retrieving this data from a heterogeneous database necessitates juggling many kinds of query languages, data models, and structure. The goal of this project is to create a unified access control approach (UACA), which will be managed by service data object (SDO) technologies and will be based on an agent mechanism for application access to business databases. To create a unified data access control, applications must be submitted through a UACA. To prevent a direct link to the database and application security threats, unified access control isolates applications from databases. Application systems submit a request for identity authentication to the database access control system using the data access protocol of the access control system. Data are finally transmitted to the application system after identity authentication, data gathering, and data transmission. This investigation led to the creation of a client-middle layer, which is also in charge of transformation and optimization, to ensure uniform data access control and access to the heterogeneous database. It also manages system communication using the TCP/IP protocol to guarantee the accuracy and reliability of the connection. SDO data retrieval offers strong adaptability and system compatibility. [ABSTRACT FROM AUTHOR]

In a cloud environment, resources should be acquired quickly and automatically released at runtime. Traditional trajectory data partitions, indexing and query processing techniques are extended, so that they can take advantage of the cloud of large clusters of highly parallel processing capabilities. There are ways with trajectory data in the cloud database query processing. The advanced sensing techniques available today caused the existence of many types of trajectory datasets whose study can form a strong basis for decision making regarding a data context. Trajectory data generally includes trajectory classification, trajectory clustering, and trajectory associations and so on. All these tools need trajectory similarity measures to get comparisons in trajectory data. Some of the popular existing methods of trajectory similarity include Euclidean distance, semantic distance and there near variants. Each variant of these techniques exhibits notable differences in measurement of similarity and computational difficulty. This paper targeted to deal with this situation with the goal of lower computational efforts in trajectory similarity computations. A two‐phase trajectory similarity measure is defined. The first phase does point level analysis of trajectory points representing all trajectories and the following phase use the analysis to find the similarities. Using a hybrid similarity framework, new means for trajectory clustering and trajectory query processing are developed. From trajectory analysis followed by trajectory clustering, evaluation of cluster quality and processing of trajectory query are undertaken in this paper in different ways from the existing methods. All the proposed developments are tested with trajectory datasets with multiple attributes and the results are more favour to proposed framework than the existing ones. [ABSTRACT FROM AUTHOR]

Apache Sedona (formerly GeoSpark) is a new in-memory cluster computing system for processing large-scale spatial data, which extends the core of Apache Spark to support spatial datatypes, partitioning techniques, spatial indexes, and spatial operations (e.g. spatial range, nearest neighbor, and spatial join queries). Distance-based Join Queries (DJQs), like nearest neighbor join (kNNJQ) or closest pairs queries (kCPQ), are not supported by it. Therefore, in this paper, we investigate how to design and implement efficient DJQ distributed algorithms in Apache Sedona, using the most appropriate spatial partitioning and other optimization techniques. The results of an extensive set of experiments with real-world datasets are presented, demonstrating that the proposed kNNJQ and kCPQ distributed algorithms are efficient, scalable, and robust in Apache Sedona. Finally, Sedona is also compared to other similar cluster computing systems, showing the best performance for kCPQ and competitive results for kNNJQ. [ABSTRACT FROM AUTHOR]

Secure semantic searching can search arbitrary query words semantically related to keywords over the encrypted data. However, most of the current schemes perform the matching after query semantic expansion on the plaintext. The existing works rarely support cross‐lingual searching that breaks the language barrier to allow a query issued in a lingual to retrieve the documents written in other languages. Meanwhile, most of the previous schemes are difficult to be applied to real‐time applications because of their poor efficiency. This letter designs an efficient cross‐lingual secure semantic searching scheme that performs semantic analysis, semantic matching, and relevance ranking on the ciphertext. The proposed scheme encrypts the language‐aligned word vectors of the keywords, and further calculates the semantic similarity between the encrypted vectors to perform clustering for the encrypted keywords. Therefore, the scheme uses the encrypted language‐aligned word vectors of query words to perform cross‐lingual semantic matching only with the cluster centre keywords to get encrypted keywords semantically related to the query, instead of scanning all the keywords, thus significantly improving the search efficiency. The scheme also realises the ciphertext relevance ranking algorithm to rank the documents. Experimental results show the practicability of the proposed scheme. [ABSTRACT FROM AUTHOR]

Summary Cutevariant is a graphical user interface (GUI)-based desktop application designed to filter variations from annotated VCF file. The application imports data into a local SQLite database where complex filter queries can be built either from GUI controllers or using a domain-specific language called Variant Query Language. Cutevariant provides more features than existing applications and is fully customizable thanks to a complete plugins architecture. Availability and implementation Cutevariant is distributed as a multiplatform client-side software under an open source license and is available at https://github.com/labsquare/cutevariant. [ABSTRACT FROM AUTHOR]

As an alternative of Internet protocol (IP) multicast, application layer multicast (ALM) is widely used with the advantage of simplicity and flexibility. However, the existing problems of large transmission delay and poor stability limit the application and development. In this article, to solve these problems, an ALM model based on node potential (NP) and topological index (TI) is proposed. The proposed model considers the factors of node capability and node distance in constructing and maintaining multicast tree to reduce transmission delay and increase stability, and thus it improves the application level in realtime multimedia multicast. The computer simulations prove that the proposed model reduces the ALM transmission delay, increases multicast tree stability effectively, and improves the ALM performance, and therefore it is suitable to apply in large-scale real-time multimedia environment. [ABSTRACT FROM AUTHOR]

The advantage of recursive programming is that it is very easy to write and it only requires very few lines of code if done correctly. Structured query language (SQL) is a database language and is used to manipulate data. In Microsoft SQL Server 2000, recursive queries are implemented to retrieve data which is presented in a hierarchical format, but this way has its disadvantages. Common table expression (CTE) construction introduced in Microsoft SQL Server 2005 provides the significant advantage of being able to reference itself to create a recursive CTE. Hierarchical data structures, organizational charts and other parent-child table relationship reports can easily benefit from the use of recursive CTEs. The recursive query is illustrated and implemented on some simple hierarchical data. In addition, one business case study is brought forward and the solution using recursive query based on CTE is shown. At the same time, stored procedures are programmed to do the recursion in SQL. Test results show that recursive queries based on CTEs bring us the chance to create much more complex queries while retaining a much simpler syntax. [ABSTRACT FROM AUTHOR]

Arguments in argumentation systems cannot always be considered as standalone entities, requiring the consideration of the pieces of evidence they rely on. This evidence might have to be retrieved from external sources such as databases or the web, and each attempt to retrieve a piece of evidence comes with an associated cost. Moreover, a piece of evidence may be available in a given scenario but not in others, and this is not known beforehand. As a result, the collection of active arguments (whose entire set of evidence is available) that can be used by the argumentation machinery of the system may vary from one scenario to another. In this work, we consider an Abstract Argumentation Framework with Fallible Evidence that accounts for these issues, and propose a heuristic measure used as part of the acceptability calculus (specifically, for building pruned dialectical trees) with the aim of minimizing the evidence retrieval cost of the arguments involved in the reasoning process. We provide an algorithmic solution that is empirically tested against two baselines and formally show the correctness of our approach. [ABSTRACT FROM AUTHOR]

Aiming at ontology-based data access to temporal data, we design two-dimensional temporal ontology and query languages by combining logics from the (extended) DL-Lite family with linear temporal logic LTL over discrete time (Z,<). Our main concern is first-order rewritability of ontology-mediated queries (OMQs) that consist of a 2D ontology and a positive temporal instance query. Our target languages for FO-rewritings are two-sorted FO(<)--first-order logic with sorts for time instants ordered by the built-in precedence relation < and for the domain of individuals--its extension FO(<,=) with the standard congruence predicates t ≤ 0 (mod n), for any fixed n > 1, and FO(RPR) that admits relational primitive recursion. In terms of circuit complexity, FO(<, ≡)- and FO(RPR)-rewritability guarantee answering OMQs in uniform AC0 and NC¹, respectively. We proceed in three steps. First, we define a hierarchy of 2D DL-Lite/LTL ontology languages and investigate the FO-rewritability of OMQs with atomic queries by constructing projections onto 1D LTL OMQs and employing recent results on the FO-rewritability of propositional LTL OMQs. As the projections involve deciding consistency of ontologies and data, we also consider the consistency problem for our languages. While the undecidability of consistency for 2D ontology languages with expressive Boolean role inclusions might be expected, we also show that, rather surprisingly, the restriction to Krom and Horn role inclusions leads to decidability (and ExpSpace-completeness), even if one admits full Booleans on concepts. As a final step, we lift some of the rewritability results for atomic OMQs to OMQs with expressive positive temporal instance queries. The lifting results are based on an in-depth study of the canonical models and only concern Horn ontologies. [ABSTRACT FROM AUTHOR]

Group skyline query is a powerful tool for optimal group analysis. Most of the existing group skyline queries select optimal groups by comparing the dominance relationship between aggregate-based points; such feature creates difficulties for users to specify an appropriate aggregate function. Besides, many significant groups that have great attractions to users in practice may be overlooked. To address these issues, the group skyline (GSky) query is formulated on the basis of a general definition of group dominance operator. While the existing GSky query algorithms are effective, there is still room for improvement in terms of progressiveness and efficiency. In this paper, we propose some new lemmas which facilitate direct generation of the GSky query results. Consecutively, we design a layered unit-based (LU) algorithm that applies a layered optimum strategy. Additionally, for the GSky query over the data that are dynamically produced and cannot be indexed, we propose a novel index-independent algorithm, called sorted-based progressive (SP) algorithm. The experimental results demonstrate the effectiveness, efficiency, and progressiveness of the proposed algorithms. By comparing with the state-of-the-art algorithm for the GSky query, our LU algorithm is more scalable and two orders of magnitude faster. [ABSTRACT FROM AUTHOR]

Tuple-independent and disjoint-independent probabilistic databases (TI- and DI-PDBs) represent uncertain data in a factorized form as a product of independent random variables that represent either tuples (TI-PDBs) or sets of tuples (DI-PDBs). When the user submits a query, the database derives the marginal probabilities of each output-tuple, exploiting the underlying assumptions of statistical independence. While query processing in TI- and DI-PDBs has been studied extensively, limited research has been dedicated to the problems of updating or deriving the parameters from observations of query results. Addressing this problem is the main focus of this article. We first introduce Beta Probabilistic Databases (B-PDBs), a generalization of TI-PDBs designed to support both (i) belief updating and (ii) parameter learning in a principled and scalable way. The key idea of B-PDBs is to treat each parameter as a latent, Beta-distributed random variable. We show how this simple expedient enables both belief updating and parameter learning in a principled way, without imposing any burden on regular query processing. Building on B-PDBs, we then introduce Dirichlet Probabilistic Databases (D-PDBs), a generalization of DI-PDBs with similar properties. We provide the following key contributions for both B- and D-PDBs: (i) We study the complexity of performing Bayesian belief updates and devise efficient algorithms for certain tractable classes of queries; (ii) we propose a soft-EM algorithm for computing maximum-likelihood estimates of the parameters; (iii) we present an algorithm for efficiently computing conditional probabilities, allowing us to efficiently implement B- and D-PDBs via a standard relational engine; and (iv) we support our conclusions with extensive experimental results. [ABSTRACT FROM AUTHOR]

Abstract To date, widely implemented and full-featured query languages for building models in their native exchange formats do not exist. While interesting proposals exist for querying Industry Foundation Classes (IFC) models, their functionality is often incomplete and their semantics not precisely defined. With the introduction of the ifcOWL ontology as an equivalent to the IFC schema in the Web Ontology Language (OWL), an option to represent such models in RDF (Resource Description Framework, a general information modeling method) is provided, and such models can be queried using SPARQL (SPARQL Protocol and RDF Query Language). The size of data sets in complex building projects, however, renders the use of clear-text encoded RDF infeasible in many cases. A SPARQL implementation, compatible with ifcOWL , is proposed, directly atop a standardized binary serialization format for IFC building models. This novel format is the binary equivalent of traditional IFC serialization formats but with more compact storage and less overhead than the graph serialization in RDF. The format is based on ISO 10303-26 and relies on an open standard for organizing large amounts of data: Hierarchical Data Format version 5 (HDF5). Due to hierarchical partitioning and fixed-length records, only small subsets of the data are read to answer queries, improving efficiency. A prototypical implementation of the query engine is provided in the Python programming language. In several realistic use cases, the proposed system performs equivalent to or better than the state of the art in SPARQL querying on building models. For large datasets, the proposed storage format results in files that are 2–3 times smaller than the current, most concise, RDF databases while offering a platform-neutral, containerized exchange file. Highlights • A SPARQL query engine is presented that operates directly on IFC building models. • The models are in a binary format suitable for efficiently retrieving subsets. • In several cases, the system performs equivalent or better to the state of the art. [ABSTRACT FROM AUTHOR]

Abstract Let D = { T 1 , T 2 , … , T D } be a collection of D documents having n characters in total. Given two patterns P and Q , and an integer k > 0 , we consider the following queries. • top - k forbidden pattern query: Among all documents containing P , but not Q , report the k documents most relevant to P. • top - k two pattern query: Among all documents that contain both P and Q , report the k documents most relevant to P. For the above two queries, we provide a linear space index with O (| P | + | Q | + n k) query time, under some standard relevance functions such as PageRank and TermFrequency. The document listing version of the above two problems asks to report all t documents that either contain P , but not Q , or contain both P and Q , depending on the query type. As a corollary of the top- k result, we obtain a linear space and O (| P | + | Q | + n t) query time solution for the document listing problems. We conjecture that any significant improvement over these results is highly unlikely. We also consider the scenario when the query consists of more than two patterns. Finally, we present space-efficient indexes for these problems. [ABSTRACT FROM AUTHOR]

Summary: Structure Query Language Injection Attack is among the top 10‐security threats that can be used on the web application to cause severe damage or gain unauthorized data access to the application server. Many reports have indicated an average of 64% of global websites are at risk of being attack by SQL injection, and many of the top companies have experienced thousands of attacks attempts through SQL injection. The current trend shows the increasing number of attacks factor as a result of the daily deployment of these applications without security detection and prevention mechanism is placed. To overcome this challenge, researches in academia and industry presented a proposal that automates SQL injection vulnerabilities assessment on the tested application. Current studies show the need to enhance techniques of these proposals to reduce the false alarms. In this study, we propose a component‐based technique to minimize the incidence of inaccurate results, as well as enable the ease of improving the proposed solution. The study uses three costumed applications as tested to evaluate the accuracy of the proposed solution. Each of these testbed consists of several vulnerabilities where the experimental evaluation performs to test the proposed tool. An empirical evaluation is carried out on three vulnerable custom websites to evaluate the effectiveness of the proposed study. The experiment results indicated significant results in terms of high accuracy. On the other hand, the proposed solution also has better capabilities to analyze page response based on four different techniques. Moreover, the proposed solution is the only solution that performs stored procedure attacks SQL and bypass login authentication even if the returned records are limited restriction is applied. [ABSTRACT FROM AUTHOR]

Nowadays time-stamped data is being generated by a variety of applications and stored in a variety of database systems. Depending on the data structure and the importance of the time aspect those database systems may be either general-purpose or time-series oriented. Most popular time-series DBMS use only simple data types for non-time values, whereas generalpurpose databases usually lack specialized query methods designed for time-series aspects. Each of those solutions has some drawbacks as far as data handling is concerned. Extending SQL with built-in time series focused components enables the combination of relational queries with document and time-series-oriented queries. At the same time, the popularity of SQL among data analysts and data scientists would give them the benefit of an easy start. This paper presents such an extension and introduces ChQL, a query language designed to work with both document data and multivariate time series. This language is designed to imitate the syntax of the Python language, so that it could be easily integrated as a library into object-oriented languages such as Python, Javascript, or PHP. The main architectural concept behind the data model for both languages is to use a mixed data model based on both document and time-series storage. This paper is focused on the languages time-series related features and their architectural consequences. [ABSTRACT FROM AUTHOR]

We survey foundational features underlying modern graph query languages. We first discuss two popular graph data models: edge-labelled graphs, where nodes are connected by directed, labelled edges and property graphs, where nodes and edges can further have attributes. Next we discuss the two most fundamental graph querying functionalities: graph patterns and navigational expressions. We start with graph patterns, in which a graph-structured query is matched against the data. Thereafter, we discuss navigational expressions, in which patterns can be matched recursively against the graph to navigate paths of arbitrary length; we give an overview of what kinds of expressions have been proposed and how they can be combined with graph patterns.We also discuss several semantics under which queries using the previous features can be evaluated, what effects the selection of features and semantics has on complexity, and offer examples of such features in three modern languages that are used to query graphs: SPARQL, Cypher and Gremlin. We conclude by discussing the importance of formalisation for graph query languages; a summary of what is known about SPARQL, Cypher and Gremlin in terms of expressivity and complexity; and an outline of possible future directions for the area. [ABSTRACT FROM AUTHOR]

Let P be a set of n uncertain points in R d , where each point p i ∈ P is associated with a real value v i and exists with probability α i ∈ ( 0 , 1 ] independently of the other points. We present algorithms for building an index on P so that for a d -dimensional query rectangle ρ , the expected maximum value or the most-likely maximum value in ρ can be computed quickly. Our main contributions include the following: (i) The first index of sub-quadratic size to achieve a sub-linear query time in any dimension. (ii) A conditional lower bound for most-likely range-max queries, based on the conjectured hardness of the set-intersection problem. (iii) A near-linear-size index for estimating the expected range-max value within approximation factor 1/2 in O ( polylog ( n ) ) time. (iv) Extensions of our algorithm to more general uncertainty models and for computing the top- k values of the range-max. [ABSTRACT FROM AUTHOR]

We optimize multiway equijoins on relational tables using degree information. We give a new bound that uses degree information to more tightly bound the maximum output size of a query. On real data, our bound on the number of triangles in a social network can be up to 95 times tighter than existing worst case bounds. We show that using only a constant amount of degree information, we are able to obtain join algorithms with a running time that has a smaller exponent than existing algorithms-for any database instance. We also show that this degree information can be obtained in nearly linear time, which yields asymptotically faster algorithms in the serial setting and lower communication cost algorithms in the MapReduce setting. In the serial setting, the data complexity of join processing can be expressed as a function O(INx + OUT) in terms of input size IN and output size OUT in which x depends on the query. An upper bound for x is given by the fractional hypertreewidth. We are interested in situations in which we can get algorithms for which x is strictly smaller than the fractional hypertreewidth. We say that a join can be processed in subquadratic time if x < 2. Building on the AYZ algorithm for processing cycle joins in quadratic time, for a restricted class of joins which we call 1-series-parallel graphs, we obtain a complete decision procedure for identifying subquadratic solvability (subject to the 3-SUM problem requiring quadratic time). Our 3-SUM based quadratic lower bound is tight, making it the only known tight bound for joins that does not require any assumption about the matrix multiplication exponent ω. We also give a MapReduce algorithm that meets our improved communication bound and handles essentially optimal parallelism. [ABSTRACT FROM AUTHOR]

We present a cheating-sensitive quantum protocol for Privacy-Preserving Nearest Neighbor Query based on Oblivious Quantum Key Distribution and Quantum Encryption. Compared with the classical related protocols, our proposed protocol has higher security, because the security of our protocol is based on basic physical principles of quantum mechanics, instead of difficulty assumptions. Especially, our protocol takes single photons as quantum resources and only needs to perform single-photon projective measurement. Therefore, it is feasible to implement this protocol with the present technologies. [ABSTRACT FROM AUTHOR]

In this paper, we study a new type of indoor queries, called the indoor trip planning query (iTPQ). We have observed that the existing methods for outdoor spaces cannot be applied directly to indoor spaces, due to the difference in the underlying networks. Outdoor spaces, which are normally represented as spatial road networks, are commonly modelled as a graph. In contrast, indoor spaces have distinct features (e.g. rooms, doors, hallways) that do not exist in road networks. So far, no specific solutions have been proposed for iTPQ. Even if outdoor techniques are revised for iTPQ, they fail to process iTPQ efficiently. In this paper, we propose an indoor-specific technique, based on the indoor VIP-Tree, called the VIP-Tree neighbor expansion (VNE) method, that also includes new pruning techniques in both pre-processing and query processing phases. Our experimental results show that our proposed method VNE outperforms other indoor and outdoor algorithms by several orders of magnitude in terms of processing time with low indexing cost. [ABSTRACT FROM AUTHOR]

Large-scale distributed computing environments provide a vast amount of heterogeneous computing resources from different sources for resource sharing and distributed computing. Discovering appropriate resources in such environments is a challenge which involves several different subjects. In this paper, we provide an investigation on the current state of resource discovery protocols, mechanisms, and platforms for large-scale distributed environments, focusing on the design aspects. We classify all related aspects, general steps, and requirements to construct a novel resource discovery solution in three categories consisting of structures, methods, and issues. Accordingly, we review the literature, analyzing various aspects for each category. [ABSTRACT FROM AUTHOR]

An enterprise database contains a global, integrated, and consistent representation of a company’s data. Multi-level modeling facilitates the definition and maintenance of such an integrated conceptual data model in a dynamic environment of changing data requirements of diverse applications. Multi-level models transcend the traditional separation of class and object with clabjects as the central modeling primitive, which allows for a more flexible and natural representation of many real-world use cases. In deep instantiation, the number of instantiation levels of a clabject or property is indicated by a single potency. Dual deep modeling (DDM) differentiates between source potency and target potency of a property or association and supports the flexible instantiation and refinement of the property by statements connecting clabjects at different modeling levels. DDM comes with multiple generalization of clabjects, subsetting/specialization of properties, and multi-level cardinality constraints. Examples are presented using a UML-style notation for DDM together with UML class and object diagrams for the representation of two-level user views derived from the multi-level model. Syntax and semantics of DDM are formalized and implemented in F-Logic, supporting the modeler with integrity checks and rich query facilities. [ABSTRACT FROM AUTHOR]

The Simple Protocol and RDF Query Language (SPARQL) query language allows users to issue a structural query over a resource description framework (RDF) graph. However, the lack of a spatiotemporal query language limits the usage of RDF data in spatiotemporal-oriented applications. As the spatiotemporal information continuously increases in RDF data, it is necessary to design an effective and efficient spatiotemporal RDF data management system. In this paper, we formally define the spatiotemporal information-integrated RDF data, introduce a spatiotemporal query language that extends the SPARQL language with spatiotemporal assertions to query spatiotemporal information-integrated RDF data, and design a novel index and the corresponding query algorithm. The experimental results on a large, real RDF graph integrating spatial and temporal information (> 180 million triples) confirm the superiority of our approach. In contrast to its competitors, gst-store outperforms by more than 20%-30% in most cases. [ABSTRACT FROM AUTHOR]

There are two types of high-performance graph processing engines: low-and high-level engines. Low-level engines (Galois, PowerGraph, Snap) provide optimized data structures and computation models but require users to write low-level imperative code, hence ensuring that efficiency is the burden of the user. In high-level engines, userswrite in query languages like datalog (SociaLite) or SQL (Grail). High-level engines are easier to use but are orders of magnitude slower than the low-level graph engines. We present EmptyHeaded, a highlevel engine that supports a rich datalog-like query language and achieves performance comparable to that of low-level engines. At the core of EmptyHeaded's design is a new class of join algorithms that satisfy strong theoretical guarantees, but have thus far not achieved performance comparable to that of specialized graph processing engines. To achieve high performance, EmptyHeaded introduces a new join engine architecture, including a novel query optimizer and execution engine that leverage single-instruction multiple data (SIMD) parallelism. With this architecture, EmptyHeaded outperforms high-level approaches by up to three orders of magnitude on graph pattern queries, PageRank, and Single-Source Shortest Paths (SSSP) and is an order of magnitude faster than many low-level baselines. We validate that EmptyHeaded competes with the bestof-breed low-level engine (Galois), achieving comparable performance on PageRank and at most 3× worse performance on SSSP. Finally, we show that the EmptyHeaded design can easily be extended to accommodate a standard resource description framework (RDF)workload, the LUBM benchmark. On the LUBM benchmark, we show that EmptyHeaded can compete with and sometimes outperform two high-level, but specialized RDF baselines (TripleBit and RDF-3X), while outperforming MonetDB by up to three orders of magnitude and LogicBlox by up to two orders of magnitude. [ABSTRACT FROM AUTHOR]

We study the complexity of quantum query algorithms that make p queries in parallel in each timestep. This model is in part motivated by the fact that decoherence times of qubits are typically small, so it makes sense to parallelize quantum algorithms as much as possible. We show tight bounds for a number of problems, specifically $$\Theta ((n/p)^{2/3})$$ p-parallel queries for element distinctness and $$\Theta ((n/p)^{k/(k+1)})$$ for $$k$$ -sum. Our upper bounds are obtained by parallelized quantum walk algorithms, and our lower bounds are based on a relatively small modification of the adversary lower bound method, combined with recent results of Belovs et al. on learning graphs. We also prove some general bounds, in particular that quantum and classical p-parallel query complexity are polynomially related for all total functions f when p is small compared to f's block sensitivity. [ABSTRACT FROM AUTHOR]

Recently, many question answering systems that derive answers from linked data repositories have been developed. The purpose of this survey is to identify the common features and approaches of the semantic question answering (SQA) systems, although many different and prototype systems have been designed. The SQA systems use a formal query language like SPARQL and knowledge of a specific vocabulary. This paper analyses different frameworks, architectures, or systems that perform SQA and classifies SQA systems based on different criteria. [ABSTRACT FROM AUTHOR]

NoSQL databases are gaining more and more popularity and are an important alternative to relational databases. Examples of such databases are Neo4j, MongoDB and ArangoDB. These databases are described in this article, compared with each other, and the performance results for adding an object to the database, deleting an object, searching and populating the database are presented. Results show that the fastest database is MongoDB, except for one measurement of removal. [ABSTRACT FROM AUTHOR]