Full predicate coverage for testing SQL database queries

Tuya, Javier; Suárez-Cabal, María José; Riva, Claudio de la

doi:10.1002/stvr.424

Cited by 42 publications

(47 citation statements)

References 48 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…On a related but complementary level, a substantial amount of work (e.g. [44,45,46,47,33,48,49,50,51,52,20,53,54,55,56]) has been done on how to generate test database content exhibiting some desirable properties, given only the database schema and possibly some queries to be executed over the database. The main difference between our work and these approaches is that they essentially work without considering the control flow of the programs manipulating the database.…”

Section: Other Related Workmentioning

confidence: 99%

Relational symbolic execution of SQL code for unit testing of database programs

Marcozzi

Vanhoof

Hainaut

2015

Science of Computer Programming

View full text Add to dashboard Cite

Symbolic execution is a technique enabling the automatic generation of test inputs that exercise a set of execution paths within a code unit to be tested. If the paths cover a sufficient part of the code under test, the test data offer a representative view of the actual behaviour of this code. This notably enables detecting errors and correcting faults. Relational databases are ubiquitous in software, but symbolic execution of code units that manipulate them remains a non-trivial problem, particularly because of the complex structure of such databases and the complex behaviour of SQL statements. Finding errors in such code units is yet critical, as it can avoid corrupting important data. In this work, we define a symbolic execution translating database manipulation code directly into constraints and integrate it with a more traditional symbolic execution of normal program code. The database tables are represented by relational symbols and the SQL statements by relational constraints over these symbols. An algorithm based on these principles is presented for the symbolic execution of simple Java methods that implement transactional use cases by reading and writing in a relational database, the latter subject to data integrity constraints. The algorithm is integrated in a test generation tool and experimented over sample code. The target language for the constraints produced by the tool is the SMT-Lib standard and the used solver is Microsoft Z3. The results show that the proposed approach enables generating meaningful test data, including valid database content, in reasonable time. In particular, the Z3 solver is shown to be more scalable than the Alloy solver, used in our previous work, for solving relational constraints.

show abstract

Section: Other Related Workmentioning

confidence: 99%

Relational symbolic execution of SQL code for unit testing of database programs

Marcozzi

Vanhoof

Hainaut

2015

Science of Computer Programming

View full text Add to dashboard Cite

show abstract

“…de la Riva et al [11] show how to generate test cases to kill SQL query mutants, generating constraints based on SQL coverage rules ( [28]) and solving them using a constraint solver called Alloy. Our work was done independently of theirs.…”

Section: Space Of Queries and Mutants Consideredmentioning

confidence: 99%

“…In addition if the domain has only value > 0, or only values < 0, the results of each of the above aggregate operations (other than COUNT/COUNT(DISTINCT) will be different; otherwise we can add constraints to force all values to be on one side of 0, as long as this is compatible with the domain/query constraints. The idea of having two duplicate and another distinct value is independently presented in [28].…”

Section: F Killing Unconstrained Aggregation Mutationsmentioning

confidence: 99%

Generating test data for killing SQL mutants: A constraint-based approach

Shah

Sudarshan

Kajbaje

et al. 2011

2011 IEEE 27th International Conference on Data Engineering

View full text Add to dashboard Cite

Abstract-Complex SQL queries are widely used today, but it is rather difficult to check if a complex query has been written correctly. Formal verification based on comparing a specification with an implementation is not applicable, since SQL queries are essentially a specification without any implementation. Queries are usually checked by running them on sample datasets and checking that the correct result is returned; there is no guarantee that all possible errors are detected.In this paper, we address the problem of test data generation for checking correctness of SQL queries, based on the query mutation approach for modeling errors. Our presentation focuses in particular on a class of join/outer-join mutations, comparison operator mutations, and aggregation operation mutations, which are a common cause of error. To minimize human effort in testing, our techniques generate a test suite containing small and intuitive test datasets. The number of datasets generated, is linear in the size of the query, although the number of mutations in the class we consider is exponential. Under certain assumptions on constraints and query constructs, the test suite we generate is complete for a subclass of mutations that we define, i.e., it kills all non-equivalent mutations in this subclass.

show abstract

“…A complete description of the coverage rules and the procedure for automatically obtaining them is detailed elsewhere [19] . The scope of this paper is the use of the coverage rules to reduce a previously populated database with the goal of preserving the same coverage as the original.…”

Section: Coverage Rulesmentioning

confidence: 99%

Query-aware shrinking test databases

Tuya

Suárez-Cabal

Riva

2009

Proceedings of the Second International Workshop on Testing Database Systems

Self Cite

View full text Add to dashboard Cite

Keeping the test databases as small as possible leads to faster execution of tests and facilitates the task of completing the test cases and evaluating the actual outputs against the expected. In this paper we present an automated approach to database reduction that considers an initial database that may be a copy of a production database and the set of queries that are executed against it. The database is reduced in order to preserve the coverage of the data with respect to the queries attaining large reductions with very similar fault detection ability.

show abstract

Full predicate coverage for testing SQL database queries

Cited by 42 publications

References 48 publications

Relational symbolic execution of SQL code for unit testing of database programs

Relational symbolic execution of SQL code for unit testing of database programs

Generating test data for killing SQL mutants: A constraint-based approach

Query-aware shrinking test databases

Contact Info

Product

Resources

About