as noted above , the present invention relates to a system and method for duplicate elimination during the execution of mda or multiple distinct aggregate type queries . for clarity , the term “ counting bloom filter ” or “ cbf ” is now defined . a cbf as described in “ summary cache : a scalable wide - area web cache sharing protocol ”, ieee trans on networking 2000 by l . fan et . al . is an extension of the bloom filter data structure described in “ space / time trade - offs in hash coding with allowable errors ”, communications of the acm 1978 by burton h . bloom , where each bit of the bit - vector is substituted by a bit - counter . these documents are incorporated by reference herein in their entirety . more generally , the cbf consists of a sequence of c 1 , c 2 , . . . , c m bit - counters , which represents a total of n distinct values allowing for multiplicities . the total number of values represented is m = n . μ , where μ is the average multiplicity factor . similar to the original bloom filter , each time a new data element s has to be inserted in the set , d hash functions are used to update , at most , d entries or bit counters of the filter . while in the bloom filter the entries would be simply set to one , in cbf the counter in each of the d entries is incremented by one . in an analogous way , whenever a data element s is removed from the set , the counters in the same d entries of the filter are decremented by one . if all data elements in the set were inserted at once , the addition of all the counters would be equivalent to : σ j = 1 . . . m c j = d × m . the usual representation of a cbf is a data structure where counters have a fixed size over time . such a representation is the one used in an embodiment of the present invention . the invention may be practiced in various embodiments . a suitably configured data processing system , and associated communications networks , devices , software and firmware may provide a platform for enabling one or more embodiments . by way of example , fig1 shows a generic data processing system 100 that may include a central processing unit (“ cpu ”) 102 connected to a storage unit 104 and to a random access memory 106 . the cpu 102 may process an operating system 101 , application program 103 , and data 123 . the operating system 101 , application program 103 , and data 123 may be stored in storage unit 104 and loaded into memory 106 , as may be required . an operator 107 may interact with the data processing system 100 using a video display 108 connected by a video interface 105 , and various input / output devices such as a keyboard 110 , mouse 112 , and disk drive 114 connected by an i / o interface 109 . in known manner , the mouse 112 may be configured to control movement of a cursor in the video display 108 , and to operate various graphical user interface ( gui ) controls appearing in the video display 108 with a mouse button . the disk drive 114 may be configured to accept data processing system readable media 116 . the data processing system 100 may form part of a network via a network interface 111 , allowing the data processing system 100 to communicate with other suitably configured data processing systems ( not shown ). the particular configurations shown by way of example in this specification are not meant to be limiting . the problem of duplicate elimination in an mda type query is now explained in more detail . when a sql statement has mda functions , then duplicate elimination turns into multiple sort operations , one per each distinct column . these sort operations cannot be executed in a pipelined manner since the lower sort operators in the query execution plan may eliminate values needed by the upper sort operators . therefore , these type of queries have been handled by replicating the source stream of data into as many plan paths as there are distinct columns ( i . e . splitting vertically ), and then sorting each separate stream of data for duplicate removal . as an illustrative example of this , fig2 a shows the way ibm db2 udb ™ processes mda queries today : ( i ) either replicate the stream of data 202 a for each distinct column 204 a ( i . e . c1 , c2 , c4 ), for a separate group by operation 206 a for each column , with a subsequent union 208 a as shown in fig2 a ; or ( ii ) repeat the initial query processing itself once for each distinct column such that there are different independent streams of data . ( see , for example , us patent application publication no . 20040117356 entitled “ method and system for executing a query having multiple distinct key columns ” by chen , yao - ching et al ., which is incorporated by reference herein in its entirety .) still referring to fig2 a , the “ rest of the plan ” 201 a refers to a sub plan , or a sub tree containing the operations that generate the stream of data to be grouped by the group by column , or the stream of data to remove duplicates . as another example as shown in fig2 b , in parallel environments , each replica of the original stream of data 202 b can be executed in parallel , with each distinct column 204 b undergoing a separate group by operation 206 b , with a subsequent union 208 b , alleviating some of the performance overhead with having multiple flows of data . the “ rest of the plan ” 201 b again refers to a sub plan , or a sub tree containing the operations that generate the stream of data to be grouped by the group by column , or the stream of data to remove duplicates . u . s . patent application ser . no . 09 / 455 , 004 entitled “ parallel distinct aggregates ” by leo et . al . proposes a parallel method for mdas . the method proposed in leo et al . can be mapped to the type of processing from fig2 a . mda queries are handled by sending the rows to be processed by as much process as there are distinct aggregates in the query . this first set of slave processes group the row pieces based on the & lt ; group - by value , distinct column & gt ;, and they perform a first stage of partial duplicate elimination . then , rows are distributed to a second set of slave processes that complete the duplicate elimination and performs partial set function aggregation . a third stage completes the set aggregation to produce the results of the distinct aggregation operation . this method in leo et al . improves parallelism and allows for scalability in parallel environments . however , replicating the source data stream , and doing similar processing of the same data stream , turns into very expensive query executions plans , causing mda type queries to consume a large amount of resources in terms of cpu , i / o , and memory usage . based on the foregoing , it is desirable to provide a mechanism and technique for executing multiple distinct aggregate operations in a more efficient manner than currently available techniques . to address the above identified problem , what is proposed is a new system and method for executing mda type queries using a “ group by ” process . more generally , the method proposed is based on ( 1 ) a distinct hash operator that remove duplicates without the need for replicating the source data stream , and ( 2 ) a monitoring data structure such as counting bloom filters that minimizes the processing in the distinct hash operator ( e . g . as described in “ summary cache : a scalable wide - area web cache sharing protocol ”, above ). the main advantages of the above describe approach are that the input data stream is not replicated , reducing the number of records to be processed proportionally to the number of distinct aggregates in the mda query . also , the use of counting bloom filters for monitoring data streams allow an early duplicate removal of the input stream of data . hence , we save computation time and memory resources . the method will now be described in more detail . now referring to fig3 , shown is a schematic block diagram of a process for performing duplicate removal in accordance with an embodiment . as shown , a set of count bloom filters ( cbf ) 306 may be built while performing a group by operation 304 of data stream 302 . more specifically , one cbf per distinct column is created per each group created during the group by operation at 304 . each cbf gives a succinct representation of the number of appearances of each value in the distinct columns for each group of tuples . thus , for each group of tuples , its respective cbfs may detect unique values which are automatically passed on directly to the aggregate operator 310 , bypassing the distinct hash operator 308 . for other values for which respective entries in the cbf show that there may be a duplicate value , they are processed by the distinct hash operator at 308 prior to passing to the aggregate operator 310 . this distinct hash operator 308 will remove the remaining duplicates , and send out the distinct values to the aggregate operator 310 . this technique is now explained in more detail using a specific example . given a stream of data s , we give the following definitions : dc ={ c 1 , . . . , c n }, n columns to apply the distinct operations within each group . g 1 , . . . , g g , g groups of tuples result of grouping the stream s by the cg columns . using a process in accordance with the present invention , the solution consists of two steps , as described below . first , in a build phase , during a group by operation , for each group of tuples g j , a counting bloom filter ( cbf ) is created for each distinct column in dc . thus , there are g × n cbfs , each cbf consisting of a set of counters , with 2 bits per counter . two bits per entry in the cbf is used to represent three states , namely : ( a ) the initial x ‘ 00 ’ or 0 state indicating that if we hash to this location and the bits are x ‘ 00 ’ this value is seen for the first time ( b ) a value of x ‘ 01 ’ or 1 that is set when we have only one value hashed to this cbf location ( c ) a value of x ‘ 10 ’ or 2 that indicates that there could be duplicates for the values that hash to this location . then , when executing the group by operation , for each tuple in a group gj , we hash the values of each distinct column c i into their respective cbf , and increment the bit setting in the appropriate locations . as explained above , inserting a value in a cbf consists of applying d hash functions that map to , at most , d counters in the cbf that are incremented by one . second , in a probe phase , once the group by or a group within the stream is finished , then , for each group of tuples gj , the appropriate values may be sent to the aggregation operator for each distinct column after discarding duplicate values . this is done by first looking at the information in the corresponding cbfs and using the distinct hash operator if necessary . the distinct hash operator consists of n hash tables , one per each distinct column c i , hence , when necessary , the first appearance of a value of each distinct column is inserted within a group of tuples . ( a ) first query the values of the distinct columns in their respective cbfs . this way , if the lowest of the d counters for a given value is ‘ 01 ’, then it can be determined that the value is unique , and the value may be passed to the aggregate operator bypassing the distinct hash operator phase . otherwise the value may be probed in its respective hash table . ( b ) to probe a value into the hash table turns into an insertion , only , if a match is not found . in case a match is found , the value is discarded . when finished the processing of a group of tuple g j , then traverse the hash tables , and flow the distinct values up to the aggregate operator . as used in the present disclosure , a distinct hash operator may be a set of hash tables , one per distinct column . each hash table may be sized depending on the estimated number of distinct values per group , per distinct column , that are not bypassed to the aggregate operator . this estimation can be given either by an optimizer , or by counting the number of entries in the respective cbf that are greater than 1 . thus , when the processing of a group is finished , if the estimated number of incoming distinct values for the next group is different , then the hash table may need to be resized . for a clearer understanding , taking the sql query in the example of section 1 , and given the following input data stream s : a1 c1 c2 c3 a 1 2 1 a 1 3 2 c 2 1 2 c 20 7 1 b 3 1 2 b 4 5 2 fig4 a shows the result of the build phase for the set s defined above . for simplicity we only use one hash function d = 1 . as shown in fig4 a , there are three cbfs for each group of tuples , one for each distinct column ( c1 , c2 , c3 ). as the first row in g1 is read , the c1 value is hashed to the second location in cbf ( c1 ), and the value is incremented from x ‘ 00 ’ to x ‘ 01 ’. similarly cbf ( c2 ) and cbf ( c3 ) are updated . when the second row in g1 is considered , the value in c1 also hashes to the same location in cbf ( c1 ) and increments the counter in cbf to x ‘ 10 ’. note that once a state of x ‘ 10 ’ is reached , it is not necessary to increment further . notice that in set g3 a case of false positive for c1 is shown . in this case , 2 and 20 map the same position of the cbf which , for this case won &# 39 ; t be able to detect they are unique values . now referring to fig4 b , during the probe phase for the set s defined above , it is possible to pass directly to the corresponding aggregate function all the values that have an entry of x ‘ 01 ’ in the corresponding cbf location . it is only necessary to send values to be resolved by the hash distinct operator those entries that have x ‘ 10 ’. in this example , 1 is inserted from g1 in hash table ( c1 ), 2 from g2 into hash table ( c3 ), and { 2 , 20 } from g3 in hash table ( c1 ). the methodology explained above requires a stop condition in the query execution plan in order to pass through all the input data stream and perform the build phase . in the present example , the stop condition was an already existing “ group by ” operation , thus additional work was not incurred . however it could be that either we do not have the “ group by ” condition , or that the grouping columns are already sorted , thus the stop condition does not exist anymore . in those cases , the algorithm can make a cost decision based on estimations made by an optimizer , including avoiding the build phase such that all values are processed by the hash distinct operator , and introducing an additional stop condition in the query execution plan such that we pass over all the input stream where we perform the build phase . while various illustrative embodiments of the invention have been described above , it will be appreciated by those skilled in the art that variations and modifications may be made . for example , although the above description has focused on mda type queries , the proposed invention is also beneficial for queries with only one distinct aggregate operation . in this case , compared to previous approaches , the main benefit resides in the early duplicate removal because of the use of counting bloom filters .