Relevant bibliographies by topics / SQL recursive query / Journal articles
To see the other types of publications on this topic, follow the link: SQL recursive query.

Journal articles on the topic 'SQL recursive query'

Author: Grafiati
Published: 4 June 2025
Last updated: 6 July 2025

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the top 17 journal articles for your research on the topic 'SQL recursive query.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.

1

Eiter, Thomas, Magdalena Ortiz, Mantas Simkus, Trung-Kien Tran, and Guohui Xiao. "Query Rewriting for Horn-SHIQ Plus Rules." Proceedings of the AAAI Conference on Artificial Intelligence 26, no. 1 (2021): 726–33. http://dx.doi.org/10.1609/aaai.v26i1.8219.

Full text
Abstract:
Query answering over Description Logic (DL) ontologies has become a vibrant field of research. Efficient realizations often exploit database technology and rewrite a given query to an equivalent SQL or Datalog query over a database associated with the ontology. This approach has been intensively studied for conjunctive query answering in the DL-Lite and EL families, but is much less explored for more expressive DLs and queries. We present a rewriting-based algorithm for conjunctive query answering over Horn-SHIQ ontologies, possibly extended with recursive rules under limited recursion as in DL+log. This setting not only subsumes both DL-Lite and EL, but also yields an algorithm for answering (limited) recursive queries over Horn-SHIQ ontologies (an undecidable problem for full recursive queries). A prototype implementation shows its potential for applications, as experiments exhibit efficient query answering over full Horn-SHIQ ontologies and benign downscaling to DL-Lite, where it is competitive with comparable state of the art systems.
APA, Harvard, Vancouver, ISO, and other styles
2

Fischer, Tim, Denis Hirn, and Torsten Grust. "SQL Engines Excel at the Execution of Imperative Programs." Proceedings of the VLDB Endowment 17, no. 13 (2024): 4696–708. https://doi.org/10.14778/3704965.3704976.

Full text
Abstract:
SQL query engines can act as efficient runtime environments for the execution of imperative programs over database-resident tabular data. To make this point, we lay out the details of a compilation strategy that maps the basic blocks of arbitrarily branching and looping control flow graphs into plain---possibly recursive---SQL:1999 common table expressions. The compiler does not stumble when faced with imperative programs of several hundred lines and emits SQL code that can execute such programs over entire batches of input arguments. These batches create opportunities for parallel program evaluation which contemporary query decorrelation techniques exploit automatically. SQL engines that already support UDFs may find the present program execution approach to outperform their native implementation---SQL engines without such support may gain UDF capabilities without the need to build a dedicated interpreter.
APA, Harvard, Vancouver, ISO, and other styles
3

Nguyen, Tran Quoc Vinh, Thanh Hao Dang, Duong Thu Hang Pham, Alsadoon Abeer, Chandana Prasad PW, and Viet Anh Nguyen. "A SOLUTION FOR SYNCHRONOUS INCREMENTAL MAINTENANCE OF MATERIALIZED VIEWS BASED ON SQL RECURSIVE QUERY." Eastern-European Journal of Enterprise Technologies 5, no. 2 (101) (2019): 6–17. https://doi.org/10.15587/1729-4061.2019.180226.

Full text
Abstract:
Materialized views are excessively stored query execution results in the database. They can be used to partially or completely answer queries which will be further appeared instead of re-executing query from the scratch. There is a large number of published works that address the maintenance, especially incremental update, of materialized views and query rewriting for using those ones. Some of them support materialized views based on recursive query in datalog language. Although most of datalog queries can be transferred into SQL queries and vise versa but it is not the case for recursive queries. Recursive queries in the data log try to find all possible transitive closures. Recursive queries in SQL (Common Table Expression – CTE) return direct links but not transitive closures. In this paper, we propose efficient methods for incremental update of materialized views based on CTE; and then propose an algorithm for generating source codes in C language for any input SQL recursive queries. The synthesized source codes implement our proposed incremental update algorithms according to inserted/deleted/updated record set in the base tables. This paper focuses mainly on the recursive queries whose execution results are directed tree-structured data. The two cases of tree node are considered. In the first case, a child node has only one parent node and in the second case, a child node can have many parent nodes. Those two cases represent the two types of relationships between entities in real world, that are one–to–many and many–to–many, respectively. For the one–to–many relationships, the relationship data is accompanied with the records describing the child using some fields. Those fields are set as null in deleting a concrete relationship. For the many–to–many relationships, it is stored in a separate table and the concrete relationships are removed by deleting describing records from that table. Considering of enforcing referential integrity may help to reduce the searching space and therefore, help to improve the performance. However, the set of tree nodes or tree edges can be manipulated. All those combinations lead to different algorithms. The experimental results are provided and discussed to confirm the effectiveness of our proposed methods
APA, Harvard, Vancouver, ISO, and other styles
4

Wiśniewski, Piotr, Marta Burzańska, and Przemysław Krukowski. "Extending DQL with Recursive Facilities." Annales Universitatis Mariae Curie-Sklodowska, sectio AI – Informatica 16, no. 1 (2016): 12. http://dx.doi.org/10.17951/ai.2016.16.1.12.

Full text
Abstract:
<p class="artSummaryshort">Object Relational Mappings reduce a gap between Relational Databases and programming languages. However, only the simplest operations are covered by the ORM frameworks. Most facilities provided by DBMSs are not usable via ORM. Among such features are recursive queries, introduced in SQL:99 standard. This paper presents integration of Recursive Common Table Expressions with Doctrine Query Language - a part of Doctrine ORM framework for PHP.</p>
APA, Harvard, Vancouver, ISO, and other styles
5

Markitan, Volodymyr, Mykola Vozniak, Lesia Bulatetska, and Vitalii Bulatetskyi. "PRESERVATION OF HIERARCHY STRUCTURES IN RELATIVE DATABASES." Cybersecurity: Education, Science, Technique 16, no. 4 (2022): 85–97. http://dx.doi.org/10.28925/2663-4023.2022.16.8597.

Full text
Abstract:
Relational database management systems and the SQL language itself do not have any built-in mechanisms for storing and managing hierarchical structures. There are several different ways to represent trees in relational databases. This paper considers the method of modeling hierarchical data structures in the form of Adjacency Lists and Closure Tables. For each method, there are examples of writing queries to solve typical problems encountered when working with tree structures: finding all descendant leaves, all descendants and ancestors of a given leaf, moving a leaf to another ancestor leaf, and deleting leaves with all its descendants. The possibility of using recursive queries when displaying the entire tree in the Adjacency List model is considered. If the depth of the tree is not known, or it is not known at what level the specified element is, the query can not be built by standard means of the SELECT statement, then you need to create a recursive procedure, or write a recursive query. In order to avoid recursion when outputting the whole tree, all nodes of the subtree, and finding the path from a certain place to the root, the modeling of hierarchical data structures is performed in the form of a connection table (Closure Table). This complicates the process of adding a new leaf and moving the leaf to another ancestor leaf. In this case, to simplify the writing of queries, it is suggested to create triggers that will build or rebuild the links. Given the fact that sometimes there is a need to preserve dependent, in particular hierarchical structures in a relational database, you need to be able to plow the model of preservation of such data. The choice of method for solving a specific problem is influenced by the speed of basic operations with trees. Exploring different options for organizing SQL tree structures will allow you to understand and choose the best way to build such a structure in a relational database for a specific task. All SQL queries in this paper were created and tested for Oracle relational databases.
APA, Harvard, Vancouver, ISO, and other styles
6

Ares, Gonzalo, César Castañón Fernández, and Isidro Diego Álvarez. "Ultimate Pit-Limit Optimization Algorithm Enhancement Using Structured Query Language." Minerals 13, no. 7 (2023): 966. http://dx.doi.org/10.3390/min13070966.

Full text
Abstract:
Three-dimensional block models are the most widely used tool for the study and evaluation of ore deposits, the calculation and design of economical pits, mine production planning, and physical and numerical simulations of ore deposits. The way these algorithms and computational techniques are programmed is usually through complex C++, C# or Python libraries. Database programming languages such as SQL (Structured Query Language) have traditionally been restricted to drillhole sample data operation. However, major advances in the management and processing of large databases have opened up the possibility of changing the way in which block model calculations are related to the database. Thanks to programming languages designed to manage databases, such as SQL, the traditional recursive traversal of database records is replaced by a system of database queries. In this way, with a simple SQL, numerous lines of code are eliminated from the different loops, thus achieving a greater calculation speed. In this paper, a floating cone optimization algorithm is adapted to SQL, describing how economical cones can be generated, related and calculated, all in a simple way and with few lines of code. Finally, to test this methodology, a case study is developed and shown.
APA, Harvard, Vancouver, ISO, and other styles
7

Fan, Wenfei, Jeffrey Xu Yu, Jianzhong Li, Bolin Ding, and Lu Qin. "Query translation from XPath to SQL in the presence of recursive DTDs." VLDB Journal 18, no. 4 (2009): 857–83. http://dx.doi.org/10.1007/s00778-008-0131-0.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Gu, Binbin, Juncheng Fang, and Faisal Nawab. "PoneglyphDB: Efficient Non-interactive Zero-Knowledge Proofs for Arbitrary SQL-Query Verification." Proceedings of the ACM on Management of Data 3, no. 1 (2025): 1–27. https://doi.org/10.1145/3709713.

Full text
Abstract:
In database applications involving sensitive data, the dual imperatives of data confidentiality and provable (verifiable) query processing are important. This paper introduces PoneglyphDB, a database system that leverages non-interactive zero-knowledge proofs (ZKP) to support both confidentiality and provability. Unlike traditional databases, PoneglyphDB enhances confidentiality by ensuring that raw data remains exclusively with the host, while also enabling verifying the correctness of query responses by providing proofs to clients. The main innovation in this paper is proposing efficient ZKP designs (called circuits) for basic operations in SQL query processing. These basic operation circuits are then combined to form ZKP circuits for larger, more complex queries. PoneglyphDB's circuits are carefully designed to be efficient by utilizing advances in cryptography such as PLONKish-based circuits, recursive proof composition techniques, and designing with low-order polynomial constraints. We demonstrate the performance of PoneglyphDB with the standard TPC-H benchmark. Our experimental results show that PoneglyphDB can efficiently achieve both confidentiality and provability, outperforming existing state-of-the-art ZKP methods.
APA, Harvard, Vancouver, ISO, and other styles
9

Xiong, Xiao Mei. "A Buffer Pool Optimization Algorithm Based on Max-Heap." Advanced Materials Research 945-949 (June 2014): 2439–42. http://dx.doi.org/10.4028/www.scientific.net/amr.945-949.2439.

Full text
Abstract:
To reduce the number of requests to the database connection, this paper designed the max-heap in buffer pool. We use the buffer pool maintenance algorithm to manage SQL data query request when database access intensive. When we update the max-heap, the structure of the buffer pool will be updated and the heap will be balance through the heap of recursive sequence, it got good performance in database access request. Experiment results show that this algorithm can improve the operation efficiency of system effectively.
APA, Harvard, Vancouver, ISO, and other styles
10

Vinh, Nguyen Tran Quoc, Dang Thanh Hao, Pham Duong Thu Hang, Abeer Alsadoon, PW Chandana Prasad, and Nguyen Viet Anh. "A solution for synchronous incremental maintenance of materialized views based on SQL recursive query." Eastern-European Journal of Enterprise Technologies 5, no. 2 (101) (2019): 6–17. http://dx.doi.org/10.15587/1729-4061.2019.180226.

Full text
APA, Harvard, Vancouver, ISO, and other styles
11

De Giacomo, Giuseppe, Xavier Oriol, Riccardo Rosati, and Domenico Fabio Savo. "Instance-Level Update in DL-Lite Ontologies through First-Order Rewriting." Journal of Artificial Intelligence Research 70 (April 10, 2021): 1335–71. http://dx.doi.org/10.1613/jair.1.12414.

Full text
Abstract:
In this paper we study instance-level update in DL-LiteA , a well-known description logic that influenced the OWL 2 QL standard. Instance-level update regards insertions and deletions in the ABox of an ontology. In particular we focus on formula-based approaches to instance-level update. We show that DL-LiteA , which is well-known for enjoying first-order rewritability of query answering, enjoys a first-order rewritability property also for instance-level update. That is, every update can be reformulated into a set of insertion and deletion instructions computable through a non-recursive Datalog program with negation. Such a program is readily translatable into a first-order query over the ABox considered as a database, and hence into SQL. By exploiting this result, we implement an update component for DL-LiteA-based systems and perform some experiments showing that the approach works in practice.
APA, Harvard, Vancouver, ISO, and other styles
12

Benecke, Klaus. "On the Development of Table Oriented Programming with o++o." WSEAS TRANSACTIONS ON COMPUTERS 23 (December 31, 2024): 270–81. https://doi.org/10.37394/23205.2024.23.27.

Full text
Abstract:
The paper describes the essential steps in the so-far development of o++o. It started with some papers on the Relational data model, SQL, and CONVERT. Further, it was based on my PhD on a powerful algebraic specification language. The objects of our data model o++o will be described in detail. The operations of the data model were designed step by step, often redesigned, when other operations were introduced or changed. This holds also for the objects. The essential redefinition of tabments was influenced by XML and XQuery. It is demonstrated that a lot of problems can be formulated very compactly. The next-recursion is not as powerful as general recursive functions, but this kind of recursion seems to be easier to understand because all intermediated steps are gathered in a table. The bill of the material problem is solved in a new way with o++o-numbers and a slightly changed recursive operation nextonr. o++o allows querying and visualizing not only fact- but also (structured) text data in combination. Further, an example in a few lines, which requires in EXCEL more than 6 working sheets is presented. Then a very simple to use operation cross is introduced. It allows to creation of structured pivot tables. Small companies often don’t like to use database systems, because of their high complexity in usage. Finally, an example is presented that a query on many files can be formulated also in a compact way.
APA, Harvard, Vancouver, ISO, and other styles
13

Riedewald, Mirek. "Technical Perspective: Relational Diagrams and the Pattern Expressiveness of Relational Languages." ACM SIGMOD Record 54, no. 1 (2025): 79. https://doi.org/10.1145/3733620.3733636.

Full text
Abstract:
When a database researcher or user hears the word ''expressiveness,'' they most likely think about what kind of query some language or formalism supports. For instance, can a given version of SQL express recursion or computation of the transitive closure of a graph? For what fragment of relational calculus can we decide query containment? Can relational algebra express every relational-calculus query and vice versa? The following paper by Gatterbauer and Dunne may forever change the discourse on expressiveness in the context of relational languages by prompting the follow-up question: ''Do you mean logical expressiveness or pattern expressiveness?''
APA, Harvard, Vancouver, ISO, and other styles
14

Budiu, Mihai, Tej Chajed, Frank McSherry, Leonid Ryzhyk, and Val Tannen. "DBSP: Automatic Incremental View Maintenance for Rich Query Languages." Proceedings of the VLDB Endowment 16, no. 7 (2023): 1601–14. http://dx.doi.org/10.14778/3587136.3587137.

Full text
Abstract:
Incremental view maintenance (IVM) has long been a central problem in database theory. Many solutions have been proposed for restricted classes of database languages, such as the relational algebra, or Datalog. These techniques do not naturally generalize to richer languages. In this paper we give a general, heuristic-free solution to this problem in 3 steps: (1) we describe a simple but expressive language called DBSP for describing computations over data streams; (2) we give a new mathematical definition of IVM and a general algorithm for solving IVM for arbitrary DBSP programs, and (3) we show how to model many rich database query languages using DBSP (including the full relational algebra, queries over sets and multisets, arbitrarily nested relations, aggregation, flatmap (unnest), monotonic and non-monotonic recursion, streaming aggregation, and arbitrary compositions of all of these). SQL and Datalog can both be implemented in DBSP. As a consequence, we obtain efficient incremental view maintenance algorithms for queries written in all these languages.
APA, Harvard, Vancouver, ISO, and other styles
15

Karamyan, Davit. "Cardinality Estimation of an SQL Query Using Recursive Neural Networks." Mathematical Problems of Computer Science, December 25, 2020, 41–52. http://dx.doi.org/10.51408/1963-0058.

Full text
Abstract:
To learn complex interactions between predicates and accurately estimate the cardinality of an SQL query, we develop a novel framework based on recursive tree-structured neural networks, which take into account the natural properties of logical expressions: compositionality and n-ary associativity. The proposed architecture is an extension of MSCN (multi-set convolutional network) for queries containing both conjunction and disjunction operators. The goal is to represent an arbitrary logical expression in a continuous vector space by combining sub-expression vectors according to the operator type. We compared the proposed approach with the histogram-based approach on the real-world dataset and showed that our approach significantly outperforms histograms with a large margin.
APA, Harvard, Vancouver, ISO, and other styles
16

Schiavio, Filippo, Daniele Bonetta, and Walter Binder. "DynQ: a dynamic query engine with query-reuse capabilities embedded in a polyglot runtime." VLDB Journal, March 13, 2023. http://dx.doi.org/10.1007/s00778-023-00784-2.

Full text
Abstract:
AbstractLanguage-integrated query (LINQ) frameworks offer a convenient programming abstraction for processing in-memory collections of data, allowing developers to concisely express declarative queries using popular programming languages. Existing LINQ frameworks rely on the type system of statically typed languages such as C$$^\sharp $$ ♯ or Java to perform query compilation and execution. As a consequence of this design, they do not support dynamic languages such as Python, R, or JavaScript. Such languages are however very popular among data scientists, who would certainly benefit from LINQ frameworks in data-analytics applications. The gap between dynamic languages and LINQ frameworks has been partially bridged by the recent work DynQ, a novel query engine designed for dynamic languages. DynQ is language-agnostic, since it is able to execute SQL queries on all languages supported by the GraalVM platform. Moreover, DynQ can execute queries combining data from multiple sources, namely in-memory object collections as well as on-file data and external database systems. The evaluation of DynQ shows performance comparable with equivalent hand-optimized code, and in line with common data-processing libraries and embedded databases, making DynQ an appealing query engine for standalone analytics applications and for data-intensive server-side workloads. In this work, we extend DynQ addressing the problem of optimizing high-throughput workloads in the context of fluent APIs. In particular, we focus on applications which make use of data-processing libraries mostly for executing many queries on small batches of datasets, e.g., in micro-services, as well as applications which make use of data-processing libraries within recursive functions. For this purpose, we present reusable compiled queries, a novel approach to query execution which allows reusing the same dynamically compiled code for different queries. As we show in our evaluation, thanks to reusable compiled queries, DynQ can also speed up applications that heavily use data-processing libraries on small datasets using a typical fluent API.
APA, Harvard, Vancouver, ISO, and other styles
17

Choi, DongHyun, Myeong Cheol Shin, EungGyun Kim, and Dong Ryeol Shin. "RYANSQL: Recursively Applying Sketch-based Slot Fillings for Complex Text-to-SQL in Cross-Domain Databases." Computational Linguistics, May 20, 2021, 1–24. http://dx.doi.org/10.1162/coli_a_00403.

Full text
Abstract:
Abstract Text-to-SQL is the problem of converting a user question into an SQL query, when the question and database are given. In this article, we present a neural network approach called RYANSQL (Recursively Yielding Annotation Network for SQL) to solve complex Text-to-SQL tasks for cross-domain databases. Statement Position Code (SPC) is defined to transform a nested SQL query into a set of non-nested SELECT statements; a sketch-based slot filling approach is proposed to synthesize each SELECT statement for its corresponding SPC. Additionally, two input manipulation methods are presented to improve generation performance further. RYANSQL achieved competitive result of 58.2% accuracy on the challenging Spider benchmark. At the time of submission (April 2020), RYANSQL v2, a variant of original RYANSQL, is positioned at 3rd place among all systems and 1st place among the systems not using database content with 60.6% exact matching accuracy. The source code is available at https://github.com/kakaoenterprise/RYANSQL.
APA, Harvard, Vancouver, ISO, and other styles
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography