Sum Queries Research Articles

Bucket‐based authentication for outsourced databases

AbstractWhen outsourced database owners delegate their data to service providers, which might be untrusted or compromised, two issues of data security emerge, including data confidentiality and data integrity. Most of the previous research focuses on only one issue and the solution to integrate two approaches is expensive. In this paper, we propose bucket‐based authentication that can keep data confidentiality and meanwhile guarantee data integrity. Specifically, we first propose a new approach based on bucket checksum, which can be used for the authentication of multiple tuples at one time. We then apply bucket checksum to the authentication of various types of queries in static scenarios, including range queries and aggregation queries, such as MIN, MAX, SUM and COUNT queries. In the authentication of aggregation queries, several pruning rules have been proposed to improve performance further. We also extend our approach to dynamic scenarios based on incremental hash. Cost analysis shows the advantages of our approach over previous ones in terms of construction and verification cost. Experimental results show that our approach is both efficient and effective. Copyright © 2010 John Wiley & Sons, Ltd.

Supporting asynchronous update for distributed data cubes

Fast and simultaneous retrieval of aggregate SUMs (or AVERAGEs) from multiple regions in a wireless sensor network can be achieved by constructing a distributed data cube (DDC). However, the prior work focused on maintaining a DDC by a globally synchronous protocol, which is not flexible for a large-scale sensor network. In this paper, we propose a more general DDC (GDDC), which supports asynchronous DDC updates. By using the proposed GDDC, only O ( n ) nodes need to be visited to compute an aggregate SUM (or AVERAGE) query over a rectangular region with n nodes. First, we develop the fundamental semantics for aggregate queries in a system model without a synchronized clock. Second, we define the concept of consistency and derive a set of theorems to guarantee correct query results. Third, we design new distributed algorithms to implement a GDDC. Finally, we evaluate the proposed techniques by extensive experiments. Many interesting impact factors of query accuracy have also been analyzed.

Path Maximum Query and Path Maximum Sum Query in a Tree

Let T be a node-weighted tree with n nodes, and let π(u, v) denote the path between two nodes u and v in T. We address two problems: (i) Path Maximum Query: Preprocess T so that, for a query pair of nodes u and v, the maximum weight on π(u, v) can be found quickly. (ii) Path Maximum Sum Query: Preprocess T so that, for a query pair of nodes u and v, the maximum weight sum subpath of π(u, v) can be found quickly. For the problems we present solutions with O(1) query time and O(n log n) preprocessing time.

Computational complexity of auditing finite attributes in statistical databases

We study the computational complexity of auditing finite attributes in databases allowing statistical queries. Given a database that supports statistical queries, the auditing problem is to check whether an attribute can be completely determined or not from a given set of statistical information. Some restricted cases of this problem have been investigated earlier, e.g. the complexity of statistical sum queries is known by the work of Kleinberg et al. (J. Comput. System Sci. 66 (2003) 244–253). We characterize all classes of statistical queries such that the auditing problem is polynomial-time solvable. We also prove that the problem is coNP-complete in all other cases under a plausible conjecture on the complexity of constraint satisfaction problems (CSP). The characterization is based on the complexity of certain CSP problems; the exact complexity for such problems is known in many cases. This result is obtained by exploiting connections between auditing and constraint satisfaction, and using certain algebraic techniques. We also study a generalization of the auditing problem where one asks if a set of statistical information imply that an attribute is restricted to K or less different values. We characterize all classes of polynomial-time solvable problems in this case, too.

Succinct indexable dictionaries with applications to encoding k -ary trees, prefix sums and multisets

We consider the indexable dictionary problem, which consists of storing a set S ⊆ {0,…, m − 1} for some integer m while supporting the operations of rank( x ), which returns the number of elements in S that are less than x if x ∈ S , and −1 otherwise; and select( i ), which returns the i th smallest element in S . We give a data structure that supports both operations in O (1) time on the RAM model and requires B( n, m ) + o ( n ) + O (lg lg m ) bits to store a set of size n , where B( n, m ) = ⌊lg ( m / n )⌋ is the minimum number of bits required to store any n -element subset from a universe of size m . Previous dictionaries taking this space only supported (yes/no) membership queries in O (1) time. In the cell probe model we can remove the O (lg lg m ) additive term in the space bound, answering a question raised by Fich and Miltersen [1995] and Pagh [2001]. We present extensions and applications of our indexable dictionary data structure, including: —an information-theoretically optimal representation of a k -ary cardinal tree that supports standard operations in constant time; —a representation of a multiset of size n from {0,…, m − 1} in B( n, m + n ) + o ( n ) bits that supports (appropriate generalizations of) rank and select operations in constant time; and + O (lg lg m ) —a representation of a sequence of n nonnegative integers summing up to m in B( n, m + n ) + o ( n ) bits that supports prefix sum queries in constant time.

Parity-based inference control for multi-dimensional range sum queries

This paper studies the inference control of multi-dimensional range (MDR) sum queries. We show that existing inference control methods are usually inefficient for MDR queries. We then consider parity-based inference control that restricts users to queries involving an even number of sensitive values. Such a restriction renders inferences significantly more difficult, because an even number is closed under addition and subtraction, whereas inferences target at one value. However, more sophisticated inferences are still possible with only even MDR queries. We show that the collection of all even MDR queries causes inferences if and only if a special collection of sum-two queries (that is, the summation of exactly two values) does so. The result leads to an inference control method with an improved computational complexity O(mn) (over the previous result of O(m 2n)) for m MDR queries over n values. We show that no odd MDR queries can be answered without causing inferences. We show how to check non-MDR queries for inferences in linear time. We also show how to find large inference-free subsets of even MDR queries when they do cause inferences.

Approximate range–sum query answering on data cubes with probabilistic guarantees

Approximate range aggregate queries are one of the most frequent and useful kinds of queries for Decision Support Systems (DSS), as they are widely used in many data analysis tasks. Traditionally, sampling-based techniques have been proposed to tackle this problem. However, their effectiveness degrade when the underlying data distribution is skewed. Another approach based on the outlier management can limit the effect of data skews but fails to address other requirements of approximate range aggregate queries, such as error guarantees and query processing efficiency. In this paper, we present a technique that provides approximate answers to range aggregate queries on OLAP data cubes efficiently, with theoretical guarantees on the errors. Our basic idea is to build different data structures to manage outliers and the rest of the data. Carefully chosen outliers are organized in a quad-tree based indexing data structure to provide efficient access for query processing. A query-workload adaptive, tree-like synopsis data structure, called T unable P artition-Tree (TP-Tree), is proposed to organize samples extracted from non-outlier data. Our experiments clearly demonstrate the merits of our technique, by comparing with previous well-known techniques.

Indexing range sum queries in spatio-temporal databases

Although spatio-temporal databases have received considerable attention recently, there has been little work on processing range sum queries on the historical records of moving objects despite their importance. Since the direct access to a huge amount of data to answer range sum queries incurs prohibitive computation cost, materialization techniques based on existing index structures are suggested. A simple but effective solution is to apply the materialization technique to the MVR-tree known as the most efficient structure for window queries with spatio-temporal conditions. Aggregate structures based on other index structures such as the HR-tree and the 3DR-tree do not provide satisfactory query performance. In this paper, we propose a new index structure called the Adaptively Partitioned Aggregate R-Tree (APART) and query processing algorithms to efficiently process range sum queries in many situations. Our experimental results show that the performance of the APART is typically 1.3 times better than that of its competitor for a wide range of scenarios.

Opportunistic data structures for range queries

In this paper, we study the problem of supporting range sum queries on a compressed sequence of values. For a sequence of n k-bit integers, k ≤ O(log n), our data structures require asymptotically the same amount of storage as the compressed sequence if compressed using the Lempel-Ziv algorithm. The basic structure supports range sum queries in O(log n) time. With an increase by a constant factor in the storage complexity, the query time can be improved to O(log log n + k).

On the security of individual data

We will consider the following problem in this paper: Assume that there are $$n$$ numerical data $$\{x_1,x_2,\ldots,x_n\}$$ (like salaries of $$n$$ individuals) stored in a database and some subsums of these numbers are made public or just available for persons not eligible to learn the original data. Our motivating question is: At most how many of these subsums may be disclosed such that none of the numbers $$x_1,x_2,\ldots,x_n$$ can be uniquely determined from these sums. These types of problems arise in the cases when certain tasks concerning a database are done by subcontractors who are not eligible to learn the elements of the database, but naturally should be given some data to fulfill there task. In database theory such examples are called statistical databases as they are used for statistical purposes and no individual data are supposed to be obtained using a restricted list of SUM queries. This problem was originally introduced by [1], originally solved by Miller et al. [7] and revisited by Griggs [4, 5]. It was shown in [7] that no more than $${n\choose n/2}$$ subsums of a given set of secure data may be disclosed without disclosing at least one of the data, which upper bound is sharp as well. To calculate a subsum, it might need some operations whose number is limited. This is why it is natural to assume that the disclosed subsums of the original elements of the database will contain only a limited number of elements, say at most $$k$$ . The goal of the present paper is to determine the maximum number of subsums of size at most $$k$$ which can be disclosed without making possible to calculate any of the individual data $$x_i$$ . The maximum is exactly determined for the case when the number of data is much larger than the size restriction $$k$$ .

Parallel Data Cube Storage Structure for Range Sum Queries and Dynamic Updates

I/O parallelism is considered to be a promising approach to achieving high performance in parallel data warehousing systems where huge amounts of data and complex analytical queries have to be processed. This paper proposes a parallel secondary data cube storage structure (PHC for short) to efficiently support the processing of range sum queries and dynamic updates on data cube using parallel computing systems. Based on PHC, two parallel algorithms for processing range sum queries and updates are proposed also. Both the algorithms have the same time complexity, O(logd n/P). The analytical and experimental results show that PHC and the parallel algorithms have high performance and achieve optimum speedup.

Auditing Boolean attributes

We study the problem of auditing databases which support statistical sum queries to protect the security of sensitive information; we focus on the special case in which the sensitive information is Boolean. Principles and techniques developed for the security of statistical databases in the case of continuous attributes do not apply here. We prove certain strong complexity results suggesting that there is no general efficient solution for the auditing problem in this case. We propose two efficient algorithms: The first is applicable when the sum queries are one-dimensional range queries (we prove that the problem is NP-hard even in the two-dimensional case). The second is an approximate algorithm that maintains security, although it may be too restrictive. Finally, we consider a “dual” variant, with continuous data but an aggregate function that is combinatorial in nature. Specifically, we provide algorithms for two natural definitions of the auditing condition when the aggregate function is max.

An efficient algorithm for solving the partial sum query problem

We address the problem: given n data values, how many partial sums must be stored so that partial sums of any other combination of these n values can be calculated in one arithmetic operation from the stored values. This problem has application in online analytical processing (OLAP) databases [Gray et al., Proc. 12th Int. Conf. Data Eng. (1996)] where it is called the partial sum aggregation query. It can also be used to generate the entire power set of n values efficiently. In this paper, we derive lower bounds for this problem, devise an efficient algorithm to solve it and show that our heuristic comes reasonably close to the lower bound.

Range queries in dynamic OLAP data cubes

A range query applies an aggregation operation (e.g., SUM) over all selected cells of an OLAP data cube where the selection is specified by providing ranges of values for numeric dimensions. Range sum queries on data cubes are a powerful analysis tool. Many application domains require that data cubes are updated often and the information provided by analysis tools are current or “near current”. Existing techniques for range sum queries on data cubes, however, can incur update costs in the order of the size of the data cube. Since the size of a data cube is exponential in the number of its dimensions, rebuilding the entire data cube can be very costly and is not realistic. To cope with this dynamic data cube problem, a new approach has been introduced recently, which achieves constant time per range sum query while constraining each update cost within O( n d/2 ), where d is the number of dimensions of the data cube and n is the number of distinct values of the domain at each dimension. In this paper, we provide a new algorithm for the problem which requires O( n 1/3) time for each range sum query and O( n d/3 ) time for each update. Our algorithm improves the update time by a factor of O( n d/6 ) in contrast to the current one for the problem O( n d/2 ). Like all existing techniques, our approach to answering range sum queries is also based on some precomputed auxiliary information (prefix sums) that is used to answer ad hoc queries at run time. Under both the product model and a new model introduced in this paper, the total cost for updates and range queries of the proposed algorithm is smallest compared with the cost by all known algorithms. Therefore our algorithm reduces the overall time complexity for range sum queries significantly.

On Estimators for Aggregate Relational Algebra Queries

CASE-DB is a relational database management system that allows users to specify time constraints in queries. For an aggregate query AGG(E) where AGG is one of COUNT, SUM and AVERAGE, and E is a relational algebra expression, CASE-DB uses statistical estimators to approximate the query. This paper extends our earlier work on statistical estimators of CASE-DB with the following features: (a) new statistical estimators for COUNT queries with projection, (b) extending the methodology for SUM and AVERAGE aggregate queries, (c) new sampling plans based on systematic sampling and stratified sampling. We also present performance evaluation experiments of the estimators with the above extensions using correlated and uncorrelated database instances.

On inference control in semantic data models for statistical databases

A statistical database (SDB) is a database that is used to provide simple. summary statistics about populations stored in the database and that supports statistical data analysis. When SDB users infer protected information in the SDB from responses to queries, we say that the SDB is compromised. The security problem of SDB is to allow simple summary statistics about protected information in the SDB while preventing compromise. In this paper, we consider the SDB security problem in the context of the Data Abstraction (D-A) model, and investigate the effectiveness of rounding SUM and COUNT query responses for preventing compromise due to structural, dynamic and pre-knowledge inferences in the generalization hierarchy of the D-A model. We first round only SUM query responses, permit updates in a single population, and investigate the effect of users' a priori knowledge of a single protected value. It is shown that compromise is possible, and a necessary and sufficient condition for compromise is given. We then round both SUM and COUNT query responses, and introduce techniques of choosing rounding bases for populations in tree-organized hierarchies that either eliminate or restrict structural and dynamic inferences. Finally, we propose the range response technique which eliminates structural and dynamic inferences in general generalization hierarchies.

Security problems on inference control for SUM, MAX, and MIN queries

The basic inference problem is defined as follows: For a finite set X = { x i , … , x n }, we wish to infer properties of elements of X on the basis of sets of "queries" regarding subsets of X . By restricting these queries to statistical queries, the statistical database (SDB) security problem is obtained. The security problem for the SDB is to limit the use of the SDB so that only statistical information is available and no sequence of queries is sufficient to infer protected information about any individual. When such information is obtained the SDB is said to be compromised. In this paper, two applications concerning the security of the SDB are considered: On-line application . The queries are answered one by one in sequence and it is necessary to determine whether the SDB is compromised if a new query is answered. Off-line application . All queries are available at the same time and it is necessary to determine the maximum subset of queries to be answered without compromising the SDB. The complexity of these two applications, when the set of queries consists of (a) a single type of SUM query, (b) a single type of MAX/MIN query, (c) mixed types of MAX and MIN queries, (d) mixed types of SUM and MAX/MIN queries, and (e) mixed types of SUM, MAX, and MIN queries, is studied. Efficient algorithms are designed for some of these situations while others are shown to be NP-hard.

Efficient inference control for range Sum queries

The inference control technique called Auditing is discussed in this paper. Auditing is in many ways better than the previously known techniques. Auditing would log all answered queries, and use this information to decide whether answering a new query could lead to compromise. Unfortunately, expect for small databases, auditing may not be readily usable in practice because of its excessive time and space complexity in processing a new query. In this paper we restrict our study to Sum queries, if there are n records in the database, the problem of determining whether or not answering a new Sum query could lead to compromise may take O( n 2) time and space. Furthermore, it is unrealistic to assume that the user can obtain statistical information of any subset of the records in the database; we assume that statistical information is only available for those subsets of records in which one of their attribute values lies within a certain range (range query). With the proper data structure, the time and space complexity for checking if a new range query could be answered can be reduced to O( n) time and space, or O( t log n) time with O( n 2) space for t new range queries with t⩾ n.

Compromising statistical databases responding to queries about means

This paper describes how to compromise a statistical database which only answers queries about arithmetic means for query sets whose cardinality falls in the range [ k, N - k ], for some k > 0, where N ≥ 2 k is the number of records in the database. The compromise is shown to be easy and to require only a little preknowledge; knowing the cardinality of just one nonempty query set is usually sufficient. This means that not only count and sum queries, but also queries for arithmetic means can be extremely dangerous for the security of a statistical database, and that this threat must be taken into account explicitly by protective measures. This seems quite important from a practical standpoint: while arithmetic means were known for some time to be not altogether harmless, the (perhaps surprising) extent of the threat is now shown.