Results 1  10
of
17
Static Checking of Dynamically Generated Queries in Database Applications
, 2004
"... Many dataintensive applications dynamically construct queries in response to client requests and execute them. Java servlets, e.g., can create string representations of SQL queries and then send the queries, using JDBC, to a database server for execution. The servlet programmer enjoys static checki ..."
Abstract

Cited by 72 (5 self)
 Add to MetaCart
Many dataintensive applications dynamically construct queries in response to client requests and execute them. Java servlets, e.g., can create string representations of SQL queries and then send the queries, using JDBC, to a database server for execution. The servlet programmer enjoys static checking via Java's strong type system. However, the Java type system does little to check for possible errors in the dynamically generated SQL query strings. Thus, a type error in a generated selection query (e.g., comparing a string attribute with an integer) can result in an SQL runtime exception. Currently, such defects must be rooted out through careful testing, or (worse) might be found by customers at runtime. In this paper, we present a sound, static, program analysis technique to verify the correctness of dynamically generated query strings. We describe our analysis technique and provide soundness results for our static analysis algorithm. We also describe the details of a prototype tool based on the algorithm and present several illustrative defects found in senior softwareengineering studentteam projects, online tutorial examples, and a realworld purchase order system written by one of the authors.
A Fully Dynamic Algorithm for Maintaining the Transitive Closure
 In Proc. 31st ACM Symposium on Theory of Computing (STOC'99
, 1999
"... This paper presents an efficient fully dynamic graph algorithm for maintaining the transitive closure of a directed graph. The algorithm updates the adjacency matrix of the transitive closure with each update to the graph. Hence, each reachability query of the form "Is there a directed path from i t ..."
Abstract

Cited by 43 (1 self)
 Add to MetaCart
This paper presents an efficient fully dynamic graph algorithm for maintaining the transitive closure of a directed graph. The algorithm updates the adjacency matrix of the transitive closure with each update to the graph. Hence, each reachability query of the form "Is there a directed path from i to j?" can be answered in O(1) time. The algorithm is randomized; it is correct when answering yes, but has O(1/n^c) probability of error when answering no, for any constant c. In acyclic graphs, worst case update time is O(n^2). In general graphs, update time is O(n^(2+alpha)), where alpha = min {.26, maximum size of a strongly connected component}. The space complexity of the algorithm is O(n^2).
Fully Dynamic Transitive Closure: Breaking Through The O(n²) Barrier
 IN PROC. IEEE SYMPOSIUM ON FOUNDATIONS OF COMPUTER SCIENCE
, 2000
"... In this paper we introduce a general framework for casting fully dynamic transitive closure into the problem of reevaluating polynomials over matrices. With this technique, we improve the best known bounds for fully dynamic transitive closure. In particular, we devise a deterministic algorithm for g ..."
Abstract

Cited by 41 (7 self)
 Add to MetaCart
In this paper we introduce a general framework for casting fully dynamic transitive closure into the problem of reevaluating polynomials over matrices. With this technique, we improve the best known bounds for fully dynamic transitive closure. In particular, we devise a deterministic algorithm for general directed graphs that achieves O(n²) amortized time for updates, while preserving unit worstcase cost for queries. In case of deletions only, our algorithm performs updates faster in O(n) amortized time. Our
Deriving incremental programs
, 1993
"... A systematic approach i s g i v en for deriving incremental programs from nonincremental programs written in a standard functional programming language. We exploit a number of program analysis and transformation techniques and domainspeci c knowledge, centered around e ective utilization of cachin ..."
Abstract

Cited by 39 (21 self)
 Add to MetaCart
A systematic approach i s g i v en for deriving incremental programs from nonincremental programs written in a standard functional programming language. We exploit a number of program analysis and transformation techniques and domainspeci c knowledge, centered around e ective utilization of caching, in order to provide a degree of incrementality not otherwise achievable by a generic incremental evaluator. 1
Dynamic shortest paths and transitive closure: algorithmic techniques and data structures
 J. Discr. Algor
, 2006
"... In this paper, we survey fully dynamic algorithms for path problems on general directed graphs. In particular, we consider two fundamental problems: dynamic transitive closure and dynamic shortest paths. Although research on these problems spans over more than three decades, in the last couple of ye ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
In this paper, we survey fully dynamic algorithms for path problems on general directed graphs. In particular, we consider two fundamental problems: dynamic transitive closure and dynamic shortest paths. Although research on these problems spans over more than three decades, in the last couple of years many novel algorithmic techniques have been proposed. In this survey, we will make a special effort to abstract some combinatorial and algebraic properties, and some common datastructural tools that are at the base of those techniques. This will help us try to present some of the newest results in a unifying framework so that they can be better understood and deployed also by nonspecialists.
An Experimental Study of Dynamic Algorithms for Transitive Closure
 ACM JOURNAL OF EXPERIMENTAL ALGORITHMICS
, 2000
"... We perform an extensive experimental study of several dynamic algorithms for transitive closure. In particular, we implemented algorithms given by Italiano, Yellin, Cicerone et al., and two recent randomized algorithms by Henzinger and King. We propose a netuned version of Italiano's algorithms ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
We perform an extensive experimental study of several dynamic algorithms for transitive closure. In particular, we implemented algorithms given by Italiano, Yellin, Cicerone et al., and two recent randomized algorithms by Henzinger and King. We propose a netuned version of Italiano's algorithms as well as a new variant of them, both of which were always faster than any of the other implementations of the dynamic algorithms. We also considered simpleminded algorithms that were easy to implement and likely to be fast in practice. We tested and compared the above implementations on random inputs, on nonrandom inputs that are worstcase inputs for the dynamic algorithms, and on an input motivated by a realworld graph.
Tradeoffs for fully dynamic transitive closure on DAGs: breaking through the O(n²) barrier
 J. ACM
, 2005
"... We present an algorithm for directed acyclic graphs that breaks through the O(n²) barrier on the singleoperation complexity of fully dynamic transitive closure, where n is the number of edges in the graph. We can answer queries in O(n ɛ) worstcase time and perform updates in O(n ω(1,ɛ,1)−ɛ + n 1+ɛ ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
We present an algorithm for directed acyclic graphs that breaks through the O(n²) barrier on the singleoperation complexity of fully dynamic transitive closure, where n is the number of edges in the graph. We can answer queries in O(n ɛ) worstcase time and perform updates in O(n ω(1,ɛ,1)−ɛ + n 1+ɛ) worstcase time, for any ɛ ∈ [0,1], where ω(1,ɛ,1) is the exponent of the multiplication of an n ×n ɛ matrix by an n ɛ ×n matrix. The current best bounds on ω(1,ɛ,1) imply an O(n 0.575) query time and an O(n 1.575) update time in the worst case. Our subquadratic algorithm is randomized, and has onesided error. As an application of this result, we show how to solve singlesource reachability in O(n 1.575) time per update and constant time per query.
A Software Library of Dynamic Graph Algorithms
, 1998
"... We report on a software library of dynamic graph algorithms. It was written in C++ as an extension of LEDA, the library of efficient data types and algorithms. It contains implementations of simple data structures as well as of sophisticated data structures for dynamic connectivity, dynamic minimum ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
We report on a software library of dynamic graph algorithms. It was written in C++ as an extension of LEDA, the library of efficient data types and algorithms. It contains implementations of simple data structures as well as of sophisticated data structures for dynamic connectivity, dynamic minimum spanning trees, dynamic single source shortest paths, and dynamic transitive closure. All data structures are implemented by classes derived from a common base class, thus they have a common interface. Additionally, the base class is in charge of keeping all dynamic data structures working on the same graph consistent. It is possible to change the structure of a graph by a procedure which is not aware of the dynamic data structures initialized for this graph. The library is easily extendible. 1 Introduction Traditional graph algorithms operate on static graphs. A fixed graph is given, and an algorithmic problem (e.g., "Is the graph planar?") is solved on the graph. Dynamic graphs are not fi...
Static Checking of Dynamically Generated Queries in Database Applications
, 2007
"... Many dataintensive applications dynamically construct queries in response to client requests and execute them. Java servlets, for example, can create strings that represent SQL queries and then send the queries, using JDBC, to a database server for execution. The servlet programmer enjoys static ch ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
Many dataintensive applications dynamically construct queries in response to client requests and execute them. Java servlets, for example, can create strings that represent SQL queries and then send the queries, using JDBC, to a database server for execution. The servlet programmer enjoys static checking via Java’s strong type system. However, the Java type system does little to check for possible errors in the dynamically generated SQL query strings. Thus, a type error in a generated selection query (e.g., comparing a string attribute with an integer) can result in an SQL runtime exception. Currently, such defects must be rooted out through careful testing, or (worse) might be found by customers at runtime. In this article, we present a sound, static program analysis technique to verify that dynamically generated query strings do not contain type errors. We describe our analysis technique and provide soundness results for our static analysis algorithm. We also describe the details of a prototype tool based on the algorithm and present several illustrative defects found in senior softwareengineering studentteam projects, online tutorial examples, and a realworld purchase order system written by one of the authors.