In this paper, we address the problem of evaluating historical queries on graphs. To this end, we investigate the use of graph deltas, i.e., a log of time-annotated graph operations. Our storage model maintains the current graph snapshot and the delta. We reconstruct past snapshots by applying appropriate parts of the graph delta on the current snapshot. Query evaluation proceeds on the reconstructed snapshots but we also propose algorithms based mostly on deltas for efficiency. We introduce various techniques for improving performance, including materializing intermediate snapshots, partial reconstruction and indexing deltas.
There is a large body of work on temporal data management including relational databases (see, for example @cite_3 and @cite_12 for excellent surveys on the topic), RDF (e.g., @cite_6 ) and XML documents (e.g., @cite_2 , @cite_7 ). Although maintaining deltas has also been used in such cases, the large scale and the logical model, being in our case a graph, introduces new problems.
@cite_7 @cite_3 @cite_6 @cite_2 @cite_12
2163032501 2155069392 1507944889 2101491706
Many relational domains contain temporal information and dynamics that are important to model (e.g., social networks, protein networks). However, past work in relational learning has focused primarily on modeling static "snapshots" of the data and has largely ignored the temporal dimension of these data. In this work, we extend relational techniques to temporally-evolving domains and outline a representational framework that is capable of modeling both temporal and relational dependencies in the data. We develop efficient learning and inference techniques within the framework by considering a restricted set of temporal-relational dependencies and using parameter-tying methods to generalize across relationships and entities. More specifically, we model dynamic relational data with a two-phase process, first summarizing the temporal-relational information with kernel smoothing, and then moderating attribute dependencies with the summarized relational information. We develop a number of novel temporal-relational models using the framework and then show that the current approaches to modeling static relational data are special cases within the framework. We compare the new models to the competing static relational methods on three real-world datasets and show that the temporal-relational models consistently outperform the relational models that ignore temporal information - achieving significant reductions in error ranging from 15 to 70 . Recently, large-scale knowledge bases have been constructed by automatically extracting relational facts from text. Unfortunately, most of the current knowledge bases focus on static facts and ignore the temporal dimension. However, the vast majority of facts are evolving with time or are valid only during a particular time period. Thus, time is a significant dimension that should be included in knowledge bases. In this paper, we introduce a complete information extraction framework that harvests temporal facts and events from semi-structured data and free text of Wikipedia articles to create a temporal ontology. First, we extend a temporal data representation model by making it aware of events. Second, we develop an information extraction method which harvests temporal facts and events from Wikipedia infoboxes, categories, lists, and article titles in order to build a temporal knowledge base. Third, we show how the system can use its extracted knowledge for further growing the knowledge base. We demonstrate the effectiveness of our proposed methods through several experiments. We extracted more than one million temporal facts with precision over 90 for extraction from semi-structured data and almost 70 for extraction from text. From the Publisher: Temporal database systems are systems that provide special support for storing, querying, and updating historical and or future data. Current DBMSs provide essentially no temporal features at all, but this situation is likely to change soon for a variety of reasons; in fact, temporal databases are virtually certain to become important sooner rather than later, in the commercial world as well as in academia. This book provides an in-depth description of the foundations and principles on which those temporal DBMSs will be built. These foundations and principles are firmly rooted in the relational model of data; thus, they represent an evolutionary step, not a revolutionary one, and they will stand the test of time. This book is arranged in three parts and a set of appendixes: * Preliminaries: Provides a detailed review of the relational model, and an overview of the Tutorial D language. * Laying the Foundations: Explains basic temporal data problems and introduces fundamental constructs and operators for addressing those problems. * Building on the Foundations: Applies the material of the previous part to issues of temporal database design, temporal constraints, temporal query and update, and much more. * Appendixes: Include annotated references and bibliography, implementation considerations, and other topics. KEY FEATURES: * Describes a truly relational approach to the temporal data problem. * Addresses implementation as well as model issues. * Covers recent research on new database design techniques, a new normal form, new relational operators, new update operators, a new approach to the problem of granularity, support for cyclic pointtypes, and other matters. * Includes review questions and exercises in every chapter. * Suitable for both reference and tutorial purposes. The new Semantic Web recommendations for RDF, RDFS and OWL have, at their heart, the RDF graph. Jena2, a second-generation RDF toolkit, is similarly centered on the RDF graph. RDFS and OWL reasoning are seen as graph-to-graph transforms, producing graphs of virtual triples. Rich APIs are provided. The Model API includes support for other aspects of the RDF recommendations, such as containers and reification. The Ontology API includes support for RDFS and OWL, including advanced OWL Full support. Jena includes the de facto reference RDF XML parser, and provides RDF XML output using the full range of the rich RDF XML grammar. N3 I O is supported. RDF graphs can be stored in-memory or in databases. Jena's query language, RDQL, and the Web API are both offered for the next round of standardization.