System and method for providing user defined aggregates in a database system

• US 7,376,656 B2
• Filed: 02/10/2004
• Issued: 05/20/2008
• Est. Priority Date: 02/10/2004
• Status: Expired due to Fees

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Boukouvalas, Alexios, Zhang, Hongang, Galindo-Legaria, Cesar A., Sezgin, Beysim, Venkatesh, Ramachandran, Blakeley, Jose A., Rathakrishnan, Balaji, Carlin, Peter A.
• Primary Examiner(s): Vo; Tim
• Assistant Examiner(s): Morrison; Jay A
• Application Number:
  US10/775,982
• Publication Number:
  US 20050177579A1
• Time in Patent Office: 1,561 Days
• Field of Search: 707/100, 707/103.R, 717/108, 717/165
• US Class Current: 717/108
• CPC Class Codes: G06F 16/244 Grouping and aggregation
• CPC Class Codes: G06F 16/2448 for particular applications; for extensibility, e.g. user defined types
• CPC Class Codes: G06F 16/289 Object oriented databases
• CPC Class Codes: Y10S 707/955 Object-oriented
• CPC Class Codes: Y10S 707/99944 Object-oriented database structure

Abstract

A database system and method allows a user to write program code in a high-level programming language that implements a class that defines the structure of a user-defined aggregate and methods that can be invoked on instances of the user-defined aggregate. The class is then registered with the database system, which enforces a specific contract for user-defined aggregates against the class. The contract comprises the following requirements. First, the class must specify one of a plurality of different formats for persisting instances of the user-defined aggregate in a database store. Second, the class must comprise certain specified methods that can be invoked on an instance of the class. Once these requirements are satisfied, the database system enables instances of the user-defined aggregate to be created. Preferably, the database system stores metadata about the user-defined aggregate for subsequent use in creating instances of the aggregate.

Claims

1. A method for allowing users to define new aggregates in a database system, comprising:

receiving code that instantiates an object of a class defining the structure of a user-defined aggregate and methods that can be invoked on instances of the user-defined aggregate; and

enforcing a contract against the class so that the code, when executed at runtime, satisfies requirements of the contract to ensure desired execution thereof, the contract requiring that the class comprise a first method that is invoked to initialize the computation of an instance of the user-defined aggregate, a second method that is invoked to accumulate a plurality of values to be aggregated, and a third method that is invoked to compute a final result of the instance of the user-defined aggregate, the contract further comprising a requirement that the class specify one of a plurality of different formats which describes how instances of the user-defined aggregate are to be persisted in a database store, wherein the plurality of different formats which describe how instances of the user-defined aggregate are to be persisted in the database store comprises;

a first format in which an instance of the user-defined aggregate is automatically serialized in accordance with a native format of the database system; and

a second format in which an instance of the user-defined aggregate is serialized in a manner defined by the class.

2. The method of claim 1, wherein the contract further comprises a requirement that the class comprise a fourth method that is invoked to merge an instance of the user-defined aggregate with another partial aggregation.

3. The method of claim 1, wherein the contract further comprises a requirement that the class comprise a public constructor having no arguments.

4. The method of claim 1, further comprising storing metadata about the user-defined aggregate for subsequent use by the database system in creating instances of the user-defined aggregate.

5. The method of claim 1, wherein the plurality of different formats which describe how instances of the user-defined aggregate are to be persisted in the database store further comprises a third format in which an instance of the user-defined aggregate is serialized in accordance with a method provided by a managed code programming model.

6. The method of claim 1, wherein the code that implements the class comprises managed code.

7. The method of claim 1, further comprising:

receiving a query that requires evaluation of the user-defined aggregate over a group of elements;

instantiating an instance of the class that defines the structure of the user-defined aggregate;

invoking said first method to initializing the instance of the user-defined aggregate;

for each element of the group, invoking said second method on the instance of the user-defined aggregate to accumulate each element; and

invoking said fourth method to return a value of the user-defined aggregate.

8. The method of claim 7, further comprising deserializing the instance of the user-defined aggregate prior to invoking said second method for an element of the group and then serializing the instance after invoking said second method for the element.

9. The method of claim 7, further comprising:

deserializing the instance of the user-defined aggregate prior to invoking said second method for a first element of the group;

caching the deserialized instance of the user-defined aggregate;

for each element of the group, invoking said second method on the cached instance of the user-defined type; and

, thereafter,

serializing the cached instance of the user-defined type.

10. The method of claim 1, wherein the class defining the user-defined aggregate is annotated to specify one of:

an attribute that indicates whether the user-defined aggregate is invariant to duplicates;

an attribute that indicates whether the user-defined aggregate is invariant to NULL values;

an attribute that indicates whether the user-defined aggregate is invariant to order; and

an attribute that indicates whether the user-defined aggregate returns NULL if the group on which the user-defined aggregate is to be computed is empty.

11. The method of claim 10, further comprising determining a method of computation of an instance of the user-defined aggregate based at least in part upon a value of said one of said attributes.

23. A computer storage medium having program code stored thereon for allowing users to define new aggregates in a database system, the program code, when executed by a computer, causing the computer to perform the method recited in claim 1.

12. A database system that allows users to define new aggregates, comprising:

a processing unit to perform the following;

a runtime that provides code execution within the database system; and

a database server that receives code that instantiates an object of a class defining the structure of a user-defined aggregate and methods that can be invoked on instances of the user-defined aggregate and that enforces a contract against the class so that the code, when executed at runtime, satisfies requirements of the contract to ensure desired execution thereof, the contract requiring that the class comprise a first method that is invoked to initialize the computation of an instance of the user-defined aggregate, a second method that is invoked to accumulate a plurality of values to be aggregated, and a third method that is invoked to compute a final result of the instance of the user-defined aggregate, the contract further comprising a requirement that the class specify one of a plurality of different formats which describes how instances of the user-defined aggregate are to be persisted in a database store, wherein the plurality of different formats which describe how instances of the user-defined aggregate are to be persisted in the database store comprises;

a first format in which an instance of the user-defined aggregate is automatically serialized in accordance with a native format of the database system; and

a second format in which an instance of the user-defined aggregate is serialized in a manner defined by the class.

13. The system of claim 12, wherein the contract further comprises a requirement that the class comprise a fourth method that is invoked to merge an instance of the user-defined aggregate with another partial aggregation.

14. The system of claim 12, wherein the contract further comprises a requirement that the class comprise a public constructor having no arguments.

15. The system of claim 12, wherein the database server stores metadata about the user-defined aggregate for subsequent use by the database system in creating instances of the user-defined aggregate.

16. The system of claim 12, wherein the plurality of different formats which describe how instances of the user-defined aggregate are to be persisted in the database store further comprises a third format in which an instance of the user-defined aggregate is serialized in accordance with a method provided by a managed code programming model.

17. The system of claim 12, wherein the code that implements the class comprises managed code.

18. The system of claim 12, wherein the database server (i) receives a query that requires evaluation of the user-defined aggregate over a group of elements;

(ii) instantiates an instance of the class that defines the user-defined aggregate;

(iii) invoking said first method to initializing the instance of the user-defined aggregate;

(iv) for each element of the group, invokes said second method on the instance of the user-defined aggregate to accumulate each element; and

(iv) invokes said fourth method to return a value of the user-defined aggregate.

19. The system of claim 18, wherein the database server deserializes the instance of the user-defined aggregate prior to invoking said second method for an element of the group and then serializes the instance after invoking said second method for the element.

20. The system of claim 18, wherein the database server (i) deserializes the instance of the user-defined aggregate prior to invoking said second method for a first element of the group;

(ii) caches the deserialized instance of the user-defined aggregate;

(iii) for each element of the group, invokes said second method on the cached instance of the user-defined type; and

(iv) thereafter, serializes the cached instance of the user-defined type.

21. The system of claim 12, wherein the class defining the user-defined aggregate is annotated to specify one of:

an attribute that indicates whether the user-defined aggregate is invariant to duplicates;

an attribute that indicates whether the user-defined aggregate is invariant to NULL values;

an attribute that indicates whether the user-defined aggregate is invariant to order; and

an attribute that indicates whether the user-defined aggregate returns NULL if the group on which the user-defined aggregate is to be computed is empty.

22. The system of claim 21, further comprising a query processor that determines a method of computation of an instance of the user-defined aggregate based at least in part upon a value of said one of said attributes.