Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
Formal Data Model Based on Json
Limitations of Nonrecursive Programs
Conclusion
References
All Topics
Computer Science
Theoretical Computer Science

J-Logic

Profile image of Jan HiddersJan Hidders

2017

https://doi.org/10.1145/3034786.3056106
visibility

…

description

13 pages

link

1 file

Abstract

We propose a logical framework, based on Datalog, to study the foundations of querying JSON data. The main feature of our approach, which we call J-Logic, is the emphasis on paths. Paths are sequences of keys and are used to access the tree structure of nested JSON objects. J-Logic also features "packing" as a means to generate a new key from a path or subpath. J-Logic with recursion is computationally complete, but many queries can be expressed without recursion, such as deep equality. We give a necessary condition for queries to be expressible without recursion. Most of our results focus on the deterministic nature of JSON objects as partial functions from keys to values. Predicates defined by J-Logic programs may not properly describe objects, however. Nevertheless we show that every object-toobject transformation in J-Logic can be defined using only objects in intermediate results. Moreover we show that it is decidable whether a positive, nonrecursive J-Logic program always returns an object when given objects as inputs. Regarding packing, we show that packing is unnecessary if the output does not require new keys. Finally, we show the decidability of query containment for positive, nonrecursive J-Logic programs.

Related papers

Datalog LITE: a deductive query language with linear time model checking
Erich Grädel

ACM Transactions on Computational Logic, 2002

View PDFchevron_right
JSON Functionally
Jaroslav Pokorný

Advances in Databases and Information Systems, 2020

Document databases use JSON (JavaScript Object Notation) for data representation. In the category of NoSQL databases they support an ability to handle large volumes of data at the absence of an explicit data schema. On the other hand, schema information is sometimes essential for applications during data retrieval. Consequently, there are approaches to schema construction in the JSON community. We will suppose JSON collections equipped by a schema compatible in its expressivity to the JSON Schema recommendation. We use a formal approach based on typed functional data objects. We accommodate a classical approach to functional databases based on a typed λ-calculus to obtain a powerful nonprocedural query language over JSON data with sound semantics.

View PDFchevron_right
Decidable containment of recursive queries
Diego Calvanese

2002

One of the most important reasoning tasks on queries is checking containment, ie, verifying whether one query yields necessarily a subset of the result of another one. Query containment, is crucial in several contexts, such as query optimization, query reformulation, knowledge-base verification, information integration, integrity checking, and cooperative answering. Containment is undecidable in general for Datalog, the fundamental language for expressing recursive queries.

View PDFchevron_right
Relationlog: A typed extension to Datalog with sets and tuples
Alberto Pettorossi

The Journal of Logic Programming, 1998

We study the relationships between the correctness of logic program transformation and program termination. We consider de nite programs and we identify somè invariants' of the program transformation process. The validity of these invariants ensures the preservation of the success set semantics, provided that the existential termination of the initial program implies the existential termination of the nal program. We also identify invariants for the preservation of the nite failure set semantics. We consider four very general transformation rules: de nition introduction, definition elimination, i-replacement, and nite failure. Many versions of the transformation rules proposed in the literature, including unfolding, folding, and goal replacement, are instances of the i-replacement rule. By using our proposed invariants which are based on Clark completion, we prove, for our transformation rules, various results concerning the preservation of both the success set and nite failure set semantics. By exploiting some powerful properties of the Clark completion, we are able to derive simple proofs of these preservation results. These proofs are much simpler than those done by induction on the construction of the SLD-trees, like the ones proposed in the literature for related results.

View PDFchevron_right
Efficiently computable datalog^E programs
Marco Manna, G. Terracina

Datalog ∃ is the extension of Datalog, allowing existentially quantified variables in rule heads. This language is highly expressive and enables easy and powerful knowledge-modeling, but the presence of existentially quantified variables makes reasoning over Datalog ∃ undecidable, in the general case. The results in this paper enable powerful, yet decidable and efficient reasoning (query answering) on top of Datalog ∃ programs. On the theoretical side, we define the class of parsimonious Datalog ∃ programs, and show that it allows of decidable and efficiently-computable reasoning. Unfortunately, we can demonstrate that recognizing parsimony is undecidable. However, we single out Shy, an easily recognizable fragment of parsimonious programs, that significantly extends both Datalog and Linear-Datalog ∃ , while preserving the same (data and combined) complexity of query answering over Datalog, although the addition of existential quantifiers. On the practical side, we implement a bottom-up evaluation strategy for Shy programs inside the DLV system, enhancing the computation by a number of optimization techniques to result in DLV ∃ -a powerful system for answering conjunctive queries over Shy programs, which is profitably applicable to ontology-based query answering. Moreover, we carry out an experimental analysis, comparing DLV ∃ against a number of stateof-the-art systems for ontology-based query answering. The results confirm the effectiveness of DLV ∃ , which outperforms all other systems in the benchmark domain.

View PDFchevron_right
Datalog and Description Logics: Expressive Power
Luigi Palopoli

1997

Recently there was some attention on integration of description logics of the AL-family with rule-based languages for querying relational databases such as Datalog, so as to achieve the best characteristics of both kinds of formalisms in a common framework. Formal analysis on such hybrid languages has been limited to computational complexity: i.e., how much time/space it is needed to answer to a specific query? This paper carries out a different formal analysis, the one dealing with expressiveness, which gives precise characterization of the concepts definable as queries. We first analyze the applicability to hybrid languages of formal tools developed for characterizing the expressive power of relational query languages. We then present some preliminary results on the expressiveness of hybrid languages. In particular, we show that relatively simple hybrid languages are able to define all finite structures expressed by skolemized universally quantified second-order formulae with some constraints on the quantified predicates.

View PDFchevron_right
Negation-Closure for JSON Schema
Giorgio Ghelli

Cornell University - arXiv, 2022

JSON Schema is an evolving standard for describing families of JSON documents. It is a logical language, based on a set of assertions that describe features of the JSON value under analysis and on logical or structural combinators for these assertions, including a negation operator. Most logical languages with negation enjoy negation closure, that is, for every operator they have a negation dual that expresses its negation. We show that this is not the case for JSON Schema, we study how that changed with the latest versions of the Draft, and we discuss how the language may be enriched accordingly. In the process, we define an algebraic reformulation of JSON Schema, which we successfully employed in a prototype system for generating schema witnesses.

View PDFchevron_right
A logic of reachable patterns in linked data-structures
Antoine Meyer

Journal of Logic and …, 2007

View PDFchevron_right
Query answering on expressive Datalog+/- ontologies
Leopoldo Bertossi

CEUR eBooks, 2016

View PDFchevron_right
Not Elimination and Witness Generation for JSON Schema
Giorgio Ghelli

ArXiv, 2021

JSON Schema is an evolving standard for the description of families of JSON documents. JSON Schema is a logical language, based on a set of assertions that describe features of the JSON value under analysis and on logical or structural combinators for these assertions. As for any logical language, problems like satisfaction, not-elimination, schema satisfiability, schema inclusion and equivalence, as well as witness generation, have both theoretical and practical interest. While satisfaction is trivial, all other problems are quite difficult, due to the combined presence of negation, recursion, and complex assertions in JSON Schema. To make things even more complex and interesting, JSON Schema is not algebraic, since we have both syntactic and semantic interactions between different keywords in the same schema object. With such motivations, we present in this paper an algebraic characterization of JSON Schema, obtained by adding opportune operators, and bymirroring existing ones.We ...

View PDFchevron_right

References (38)

  1. REFERENCES
  2. S. Abiteboul and R. Hull. Data functions, datalog and negation. In H. Boral and P.A. Larson, editors, 1988
  3. Proceedings SIGMOD International Conference on Management of Data, pages 143-153. ACM Press, 1988.
  4. S. Abiteboul, R. Hull, and V. Vianu. Foundations of Databases. Addison-Wesley, 1995.
  5. S. Abiteboul and P.C. Kanellakis. Object identity as a query language primitive. Journal of the ACM, 45(5):798-842, 1998.
  6. S. Abiteboul and V. Vianu. Procedural languages for database queries and updates. Journal of Computer and System Sciences, 41(2):181-229, 1990.
  7. S. Abiteboul and V. Vianu. Datalog extensions for database queries and updates. Journal of Computer and System Sciences, 43(1):62-124, 1991.
  8. P.C. Arocena, B. Glavic, and R.J. Miller. Value invention in data exchange. In Proceedings 2013 SIGMOD Conference, pages 157-168. ACM, 2013.
  9. P. Barceló and R. Pichler, editors. Datalog in Academia and Industry: Second International Workshop, Datalog 2.0, volume 7494 of Lecture Notes in Computer Science. Springer, 2012.
  10. C. Beeri and M.Y. Vardi. A proof procedure for data dependencies. Journal of the ACM, 31(4):718-741, 1984.
  11. A. Bonner and G. Mecca. Sequences, Datalog, and transducers. Journal of Computer and System Sciences, 57:234-259, 1998.
  12. A.J. Bonner and G. Mecca. Querying sequence databases with transducers. Acta Informatica, 36:511-544, 2000.
  13. P. Buneman, A. Deutsch, and W.-C. Tan. A deterministic model for semi-structured data. http://users.soe.ucsc.edu/˜tan/papers/1998/icdt.pdf. Presented at the Workshop on Query Processing for Semistructured Data and Non-standard Data Formats, Jerusalem, Israel, January 13, 1999.
  14. P. Buneman, S.A. Naqvi, V. Tannen, and L. Wong. Principles of programming with complex objects and collection types. Theoretical Computer Science, 149(1):3-48, 1995.
  15. L. Cabibbo. The expressive power of stratified logic programs with value invention. Information and Computation, 147(1):22-56, 1998.
  16. A.K. Chandra and D. Harel. Computable queries for relational data bases. Journal of Computer and System Sciences, 21(2):156-178, 1980.
  17. O. de Moor, G. Gottlob, T. Furche, and A. Sellers, editors. Datalog Reloaded: First International Workshop, Datalog 2010, volume 6702 of Lecture Notes in Computer Science. Springer, 2011.
  18. The JSON data interchange format. Standard ECMA-404, October 2013.
  19. D. Florescu and G. Fourny. JSONiq: The history of a query language. IEEE Internet Computing, 17(5):86-90, 2013.
  20. G. Fourny. JSONiq, the SQL of NoSQL. http://www.28.io/jsoniq-the-sql-of-nosql. Retrieved 25 November 2016.
  21. D.D. Freydenberger and D. Reidenbach. Bad news on decision problems for patterns. Information and Computation, 208(1):83-96, 2010.
  22. T. Furche, G. Gottlob, B. Neumayr, and E. Sallinger. Data wrangling for big data: Towards a lingua franca for data wrangling. In R. Pichler and A. Soares da Silva, editors, Proceedings 10th Alberto Mendelzon International Workshop on Foundations of Data Management, volume 1644 of CEUR Workshop Proceedings, 2016.
  23. H. Garcia-Molina, Y. Papakonstantinou, D. Quass, A. Rajaraman, Y. Sagiv, J. Ullman, V. Vassalos, and J. Widom. The TSIMMIS approach to mediation: data models and languages. Journal of Intelligent Information Systems, 8(2):117-132, 1997.
  24. M. Gyssens, J. Paredaens, J. Van den Bussche, and D. Van Gucht. A graph-oriented object database model. IEEE Transactions on Knowledge and Data Engineering, 6(4):572-586, 1994.
  25. S.S. Huang, T.J. Green, and B.T. Loo. Datalog and emerging applications: an interactive tutorial. In Proceedings 2011 ACM SIGMOD International Conference on Management of Data, pages 1213-1216. ACM Press, 2011.
  26. R. Hull and M. Yoshikawa. ILOG: Declarative creation and manipulation of object identifiers. In D. McLeod, R. Sacks-Davis, and H. Schek, editors, Proceedings of the 16th International Conference on Very Large Data Bases, pages 455-468. Morgan Kaufmann, 1990.
  27. M. Kifer and J. Wu. A logic for programming with complex objects. Journal of Computer and System Sciences, 47(1):77-120, 1993.
  28. A. Klug and R. Price. Determining view dependencies using tableaux. ACM Transactions on Database Systems, 7:361-380, 1982.
  29. G. Kuper and M. Vardi. The logical data model. ACM Transactions on Database Systems, 18(3):379-413, 1993.
  30. G. Mecca and A.J. Bonner. Query languages for sequence databases: Termination and complexity. IEEE Transactions on Knowledge and Data Engineering, 13(3):519-525, 2001.
  31. K.W. Ong, Y. Papakonstantinou, and R. Vernoux. The SQL++ query language: Configurable, unifying and semi-structured. arXiv:1405.3631, 2015.
  32. J. Paredaens and D. Van Gucht. Converting nested algebra expressions into flat algebra expressions. ACM Transactions on Database Systems, 17(1):65-93, 1992.
  33. F. Pezoa, J.L. Reutter, F. Suarez, M. Ugarte, and D. Vrgoč. Foundations of JSON Schema. In Proceedings 25th International Conference on World Wide Web, pages 263-273, 2016.
  34. A. Poggi et al. Linking data to ontologies. Journal on Data Semantics, 10:133-173, 2008.
  35. K. Tajima. Schemaless semistructured data revisited: Reinventing Peter Buneman's deterministic semistructured data model. In V. Tannen, L. Wong, et al., editors, In Search of Elegance in the Theory and Practice of Computation, volume 8000 of Lecture Notes in Computer Science, pages 466-482. Springer, 2013.
  36. J. Van den Bussche and J. Paredaens. The expressive power of complex values in object-based data models. Information and Computation, 120:220-236, 1995.
  37. J. Van den Bussche, D. Van Gucht, M. Andries, and M. Gyssens. On the completeness of object-creating database transformation languages. Journal of the ACM, 44(2):272-319, 1997.
  38. T.L. Veldhuizen. Leapfrog triejoin: A simple, worst-case optimal join algorithm. In Proceedings 17th International Conference on Database Theory, pages 96-106, 2014.

Related papers

J-Logic: a Logic for Querying JSON
Jan Hidders

arXiv (Cornell University), 2020

We propose a logical framework, based on Datalog, to study the foundations of querying JSON data. The main feature of our approach, which we call J-Logic, is the emphasis on paths. Paths are sequences of keys and are used to access the tree structure of nested JSON objects. J-Logic also features "packing" as a means to generate a new key from a path or subpath. J-Logic with recursion is computationally complete, but many queries can be expressed without recursion, such as deep equality. We give a necessary condition for queries to be expressible without recursion. Most of our results focus on the deterministic nature of JSON objects as partial functions from keys to values. Predicates defined by J-Logic programs may not properly describe objects, however. Nevertheless we show that every object-to-object transformation in J-Logic can be defined using only objects in intermediate results. Moreover we show that it is decidable whether a positive, nonrecursive J-Logic program always returns an object when given objects as inputs. Regarding packing, we show that packing is unnecessary if the output does not require new keys. Finally, we show the decidability of query containment for positive, nonrecursive J-Logic programs. This papter is the extended version of an earlier version published in the proceedings of SIGMOD/PODS 2017 [23].

View PDFchevron_right
Monadic Datalog and Regular Tree Pattern Queries
Filip Murlak

Lecture Notes in Computer Science, 2014

Containment of monadic datalog programs over trees is decidable. The situation is more complex when tree nodes carry labels from an infinite alphabet that can be tested for equality. Then, it matters whether descendant relation is allowed or not: descendant relation can be eliminated easily from monadic programs only when label equalities are not used. With descendant, even containment of linear monadic programs in unions of conjunctive queries is undecidable and positive results are known only for bounded-depth trees. We show that without descendant containment of connected monadic programs is decidable over ranked trees, but over unranked trees it is decidable only for linear programs. With descendant it becomes decidable over unranked trees under restriction to downward programs: in each rule we only go down from the node in the head. This restriction is motivated by the formalism of regular tree pattern queries, recently proposed in the area of ActiveXML, which we show to be equivalent to linear downward programs.

View PDFchevron_right
Disjunctive datalog with existential quantifiers: Semantics, decidability, and complexity issues
Nicola Leone

Theory and Practice of Logic Programming, 2012

Datalog is one of the best-known rule-based languages, and extensions of it are used in a wide context of applications. An important Datalog extension is Disjunctive Datalog, which significantly increases the expressivity of the basic language. Disjunctive Datalog is useful in a wide range of applications, ranging from Databases (e.g., Data Integration) to Artificial Intelligence (e.g., diagnosis and planning under incomplete knowledge). However, in recent years an important shortcoming of Datalog-based languages became evident, e.g. in the context of data-integration (consistent query-answering, ontology-based data access) and Semantic Web applications: The language does not permit any generation of and reasoning with unnamed individuals in an obvious way. In general, it is weak in supporting many cases of existential quantification. To overcome this problem, Datalog ∃ has recently been proposed, which extends traditional Datalog by existential quantification in rule heads. In this work, we propose a natural extension of Disjunctive Datalog and Datalog ∃ , called Datalog ∃,∨ , which allows both disjunctions and existential quantification in rule heads and is therefore an attractive language for knowledge representation and reasoning, especially in domains where ontology-based reasoning is needed. We formally define syntax and semantics of the language Datalog ∃,∨ , and provide a notion of instantiation, which we prove to be adequate for Datalog ∃,∨ . A main issue of Datalog ∃ and hence also of Datalog ∃,∨ is that decidability is no longer guaranteed for typical reasoning tasks. In order to address this issue, we identify many decidable fragments of the language, which extend, in a natural way, analog classes defined in the non-disjunctive case. Moreover, we carry out an in-depth complexity analysis, deriving interesting results which range from Logarithmic Space to Exponential Time.

View PDFchevron_right
Circumscribing DATALOG: Expressive Power and Complexity
Luigi Palopoli

Theoretical Computer Science, 1998

In this paper we study a generalization of DATALOG, the language of function-free definite clauses. It is known that standard DATALOG semantics (i.e., least Herbrand model semantics) can be obtained by regarding programs as theories to be circumscribed with all predicates to be minimized. The extension proposed here, called DATALOG~!~~, consists in considering the general form of circumscription, where some predicates are minimized, some predicates are fixed, and some vary. We study the complexity and the expressive power of the language thus obtained. We show that this language (and, actually, its non-recursive fragment) is capable of expressing all the queries in DB-co-m and, as such, is much more powerful than standard DATALOG, whose expressive power is limited to a strict subset of PTIME queries. Both data and combined complexities of answering DATALOGCIRC queries are studied. Data complexity is proved to be co-NP-complete. Combined complexity is shown to be in general hard for co-NE and complete for co-NE in the case of Herbrand bases containing k distinct constant symbols, where k is bounded.

View PDFchevron_right
Datalog+/-: A Family of Languages for Ontology Querying
Georg Gottlob

Datalog Reloaded, 2011

View PDFchevron_right

Related topics

  • Mathematics
  • Computer Science
  • Theoretical Computer Science

    • Cited by

    Expressiveness within Sequence Datalog
    Jan Hidders

    2021

    Motivated by old and new applications, we investigate Datalog as a language for sequence databases. We reconsider classical features of Datalog programs, such as negation, recursion, intermediate predicates, and relations of higher arities. We also consider new features that are useful for sequences, notably, equations between path expressions, and "packing". Our goal is to clarify the relative expressiveness of all these different features, in the context of sequences. Towards our goal, we establish a number of redundancy and primitivity results, showing that certain features can, or cannot, be expressed in terms of other features. These results paint a complete picture of the expressiveness relationships among all possible Sequence Datalog fragments that can be formed using the six features that we consider.

    View PDFchevron_right
    The Power of Tarski’s Relation Algebra on Trees
    Dirk Van Gucht

    Springer eBooks, 2018

    Fragments of Tarski's relation algebra form the basis of many versatile graph and tree query languages including the regular path queries, XPath, and SPARQL. Surprisingly, however, a systematic study of the relative expressive power of relation algebra fragments on trees has not yet been undertaken. Our approach is to start from a basic fragment which only allows composition and union. We then study how the expressive power of the query language changes if we add diversity, converse, projections, coprojections, intersections, and/or difference, both for path queries and Boolean queries. For path queries, we found that adding intersection and difference yields more expressive power for some fragments, while adding one of the other operators always yields more expressive power. For Boolean queries, we obtain a similar picture for the relative expressive power, except for a few fragments where adding converse or projection yields no more expressive power. One challenging problem remains open, however, for both path and Boolean queries: does adding difference yields more expressive power to fragments containing at least diversity, coprojections, and intersection?

    View PDFchevron_right
    Schema-Based JSON Data Stores in Relational Databases
    lubna irshad

    Journal of Database Management, 2019

    JSON is a simple, compact and light weighted data exchange format to communicate between web services and client applications. NoSQL document stores evolve with the popularity of JSON, which can support JSON schema-less storage, reduce cost, and facilitate quick development. However, NoSQL still lacks standard query language and supports eventually consistent BASE transaction model rather than the ACID transaction model. This is very challenging and a burden on the developer. The relational database management systems (RDBMS) support JSON in binary format with SQL functions (also known as SQL/JSON). However, these functions are not standardized yet and vary across vendors along with different limitations and complexities. More importantly, complex searches, partial updates, composite queries, and analyses are cumbersome and time consuming in SQL/JSON compared to standard SQL operations. It is essential to integrate JSON into databases that use standard SQL features, support ACID tra...

    View PDFchevron_right
    580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved