US 7765221 B2 Abstract Methods and apparatus, including computer systems and program products, for normalizing computer-represented collections of objects. A first minimum value can be normalized based on a second minimum value of a universal set object that corresponds to the first set object. The second minimum value is both a minimum value supported by a data type (e.g., 1-byte integer) and a minimum value defined to be in the universal set object (e.g., 0 for a universal set of all natural numbers). Similarly, a first maximum value can be normalized based on a second maximum value of the universal set object where the second maximum value is both a maximum value supported by a data type and in the universal set object. Intervals can be normalized, which can involve replacing half-open intervals with equivalent half-closed intervals. Also, a consecutively ordered, uninterrupted, sequence of values of a set object can be normalized.
Claims(11) 1. A computer program product, tangibly embodied in a machine-readable storage device, the computer program product comprising instructions operative to cause data processing apparatus to:
normalize a first value of a partition vector, a last value of the partition vector, or both the first minimum and maximum values of the partition vector of a first set object in accordance with a first process to produce a normalized version of the first set object, the partition vector comprising ordered values from the first value to the last value and further comprising a set of knot values ordered from a first knot value to a last knot value, wherein:
normalizing the first value comprises keeping the first value or removing the first value to make a second value of the partition vector the first value when the first knot value of the partition vector is a second minimum value of a universal set object corresponding to the first set object, the second minimum value being both a minimum value supported by a data type and defined to be in the universal set object; and
normalizing the last value comprises keeping the last value or removing the last value to make a penultimate value of the partition vector the last value when the last knot value of the partition vector is a second maximum value of the universal set object, the second maximum value being both a maximum value supported by a data type and defined to be in the universal set object; and
perform a set operation on the normalized version of the first set object to generate a result, wherein, the normalized version of the first set object has the normalized first value, the normalized last value, or both the normalized first and normalized last values normalized in accordance with the first process.
2. The computer program product of
3. The computer program product of
4. The computer program product of
5. The computer program product of
normalize consecutively-ordered elements of the first set object in accordance with the second process, wherein a first element is in a first ordered sequence before the second element and the universal set object includes the first and second elements as an uninterrupted second ordered sequence of elements.
6. The computer program product of
normalize one or more representations of one or more intervals in the first set object in accordance with the second process, the intervals representing a span of objects in the first set object; and
normalize consecutively-ordered elements of the first set object in accordance with the third process, wherein a first element is in a first ordered sequence before the second element and the universal set object includes the first and second elements as an uninterrupted second ordered sequence of elements.
7. The computer program product of
normalize one or more representations of one or more intervals in a first set object in accordance with the second process, the intervals representing a span of objects in the first set object.
8. A computer program product, tangibly embodied in a machine-readable storage device, the computer program product comprising instructions that cause one or more data processing apparatus to:
receive a set object representing a collection of objects using a knot vector and a partition vector, the knot vector comprising knot values ordered from a first knot value to a last knot value and defining a partition of a universal set, the partition vector comprising sets partition vector elements ordered from a first set of set of partition vector elements to a last set of partition vector elements, each set of partition vector elements corresponding to one of the knot values or to a link representing a gap between two consecutive knot values, each link comprising a range of values between the two consecutive knot values, each set of partition vector elements that corresponds to one of the knot values representing whether the set object represents values in the collection of objects that are below, at, or above the corresponding knot value;
remove the first set of partition vector elements if the first knot value is a minimum technical value and if a minimum value of the universal set is the same as the first knot value, the minimum technical value being a minimum value representable by the data processing apparatus or chosen to be supported for a for a data type corresponding to the knot value,
remove the last set of partition vector elements if the last knot value is a maximum technical value and if a maximum value of the universal set exists and is equal to the last knot value, the maximum technical value being a maximum value representable by the data processing apparatus or chosen to be supported for a for the data type corresponding to the knot value;
returning a normalized version of the set object; and
perform a set operation on the normalized version of the set object to generate a result.
9. A computer program product as in
determine whether a universal set value exists between each two consecutive knot values, thereby indicating that the link representing the gap between the two consecutive knot values is a redundant link; and
deriving a new link to replace the redundant link from two surrounding sets of partition vector elements.
10. A computer program product as in
normalizing intervals by replacing open intervals with closed intervals.
11. A computer program product as in
define temporary variables comprising a temporary index that is used to iterate through the knot values, a temporary knot vector, and a temporary partition set vector which are used to return the normalized version of the set object.
Description This application in a continuation-in-part of, and claims the priority to, U.S. application Ser. No. 10/955,749, filed Sep. 30, 2004, now U.S. Pat. No. 7,415,473 entitled MULTI-DIMENSIONAL SET OBJECT. The following description relates to systems, techniques, and computer program products for machine-implemented representations of a collection of objects. Set theory is the mathematical theory of sets, which represent collections of objects. It has an important role in modem mathematical theory, providing a way to express much of mathematics. Basic concepts of set theory include set and membership. A set is thought of as any collection of objects, called members (or elements) of the set. In mathematics, members of sets are any mathematical objects, and in particular can themselves be sets. Thus, the following can be referred to as sets: the set N of natural numbers {0,1,2,3,4, . . . }, the set of real numbers, and the set of functions from the natural numbers to the natural numbers; but also, for example, the set {0,2,N} which has as members the numbers 0 and 2, and the set N. Some fundamental sets include the empty set, the universal set, and the power set. The empty set represents that no members exist in the set, the universal set represents all sets in a given context, and the power set of a set U (i.e., P(U)) represents the collection of all subsets of a given universal set U. For two sets, a Cartesian Product set can be defined as a set of all ordered pairs whose first component is an element of a first set and whose second component is an element of a second set. Some set operations, i.e., operations that are performed on sets, include equality, containedness, complement, union, and intersection. Equality is an operation used to determine if two sets are equal (i.e., all members of one set are in another set and vice versa); containedness is an operation used to determine if one set is within the bounds of another set; complement is an operation used to determine in a given context of a universal set the set of members that do not belong to a given set; union is an operation used to determine a set including members of two sets; and intersection is an operation used to determine a set including members that are common to two sets. Described herein are systems, techniques, and computer program products for machine-implemented representations of a collection of objects. In one general aspect, the techniques feature a method of representing a collection of objects in a computer system. The method includes providing data structure definitions that define a set object to represent the collection of objects; and generating, with a computer-implemented constructor using the one or more data structure definitions, a set object representing the collection of objects. Implementations may include one or more of the following features. The data structure definitions may define the set object to be a one-dimensional set object including one or more ranges of elements. The data structure definitions may define the set object to be a one-dimensional set object including a first list of knot elements, a second list representing the knot elements that the one-dimensional set includes, and a third list representing elements, other than the knot elements, that are included in the one-dimensional set. The first list may be a one-dimensional vector of values corresponding to the knot elements of a one-dimensional set. The second and third lists may be defined to be alternating elements of a one-dimensional bit vector where the third list is defined to indicate whether the one-dimensional set includes a range that is bound by one or more knot elements. The second list and the third lists may be separate one-dimensional bit vectors where the third list is defined to indicate whether the one-dimensional set includes a range that is bound by one or more knot elements. The data structure definitions may define the set object to be a multi-dimensional set object including a union of blocks of a partition, where each block defines a disjoint collection of the objects. The multi-dimensional set object may be defined to include a first list of knot elements, a second list representing blocks corresponding to the knot elements that the multi-dimensional set includes, and a third list representing blocks corresponding to elements, other than the knot elements, that are included in the multi-dimensional set. A multi-dimensional set object may be defined to include a Cartesian Product of two or more dimensions of the collection of the objects. The Cartesian Product may be defined to include two references to set objects, where a first reference corresponds to a first Cartesian Factor and a second reference corresponds to a second Cartesian Factor. In that case, the references are ordered such that the references define a Cartesian Product of the collection of the objects. A multi-dimensional set object may include set objects nested within the multi-dimensional set object. A multi-dimensional set object may be defined to include a union set. In that case, the union set includes blocks of a partition such that each block defines a disjoint collection of the objects and each block is a reference referring to a one-dimensional set, a union set, an empty set, a universal set, or a Cartesian Product set. In that case, the Cartesian Product set includes a Cartesian Product of a first Cartesian Factor being a one-dimensional set and a second Cartesian Factor being a reference referring to a union set, a Cartesian Product Set, or a one-dimensional set. A multi-dimensional set object may be defined to include a Cartesian Product set, including a Cartesian Product of a first Cartesian Factor being a one-dimensional set and a second Cartesian Factor being a reference referring to a union set, a Cartesian Product Set, or a one-dimensional set. In that case, the union set includes blocks of a partition such that each block defines a disjoint collection of objects and is a reference to a one-dimensional set, a union set, an empty set, a universal set, or a Cartesian Product set. The one or more data structure definitions may define the set objects as normalized sets. The generated set object may represent data on a storage medium. In that case, the method further includes receiving a query; and computing the result to the query, such that computing the result to the query includes determining whether to access the data in the storage medium based on the generated set object. The one or more definitions may define operations for set objects, including, an operation to determine an intersection of two or more set objects, an operation to determine a union of two or more set objects, an operation to determine whether a set object includes a range, and an operation to determine a complement of a set object. In another aspect, a computer program product tangibly embodied in an information carrier includes one or more data structure definitions including a constructor method for generating a set object. In that product, the set object represents sets in a computer system. Implementations may include one or more of the following features. The data structure definitions may define a one-dimensional set object as one or more ranges of elements. The data structure definitions may define a one-dimensional set object to include a first list of knot elements, a second list representing the knot elements that the one-dimensional set includes, and a third list representing elements, other than the knot elements, that are included in the one-dimensional set. The data structure definitions may define the set object to be a multi-dimensional set object that includes a union of blocks of a partition, where each block defines a disjoint collection of the objects. The multi-dimensional set object may be defined to include a first list of knot elements, a second list representing blocks corresponding to the knot elements that the multi-dimensional set includes, and a third list representing blocks corresponding to elements, other than the knot elements, that are included in the multi-dimensional set. The data structure definitions may define a multi-dimensional set object to include a Cartesian Product of two or more dimensions of a collection of objects. The multi-dimensional set object may be defined to include two references to set objects. In that case, a first reference corresponds to a first Cartesian Factor and a second reference corresponds to a second Cartesian Factor, and the references are ordered such that the references define a Cartesian Product of the collection of the objects. The generated set object may represent data on a storage medium. In that case, the computer program product includes instruction to cause data processing apparatus to perform operations including receiving a query; and computing the result to the query, such that computing the result to the query includes determining whether to access the data in the storage medium based on the generated set object. The one or more definitions may define operations for the set object to include an operation to determine an intersection of two or more set objects, an operation to determine a union of two or more set objects, an operation to determine whether the set object includes a range, and an operation to determine a complement of the set object. In another aspect, a computer program product, tangibly embodied in an information carrier, includes instructions to normalize a first minimum value, a first maximum value, or both the first minimum and maximum values of a first set object in accordance with a first process, and perform a set operation on a normalized version of the first set object that was normalized in accordance with the first process. In that product, the first minimum value is normalized based on a second minimum value of a universal set object that corresponds to the first set object, and the second minimum value is both a minimum value supported by a data type (e.g., 1-byte integer) and a minimum value defined to be in the universal set object (e.g., 0 for a universal set of all natural numbers). Similarly, the first maximum value is normalized based on a second maximum value of the universal set object, where the second maximum value is both a maximum value supported by a data type and in the universal set object. Implementations may include one or more of the following features. The first minimum value of the first set object may be modified if the first minimum value is the same as the second minimum value. The first set object may use a combination of knot elements and partition entries to represent a collection of objects. The first minimum value may be a minimum knot element of the first set object and the instructions to modify the first minimum value may include instructions to modify the first set object to include a value of a second partition entry in a first partition entry, where the first and second partition entries are in an ordered sequence of partition entries with the first partition entry being before the second partition entry. The partition entry may be a partition bit or partition set. The first maximum value may be a maximum knot element of the first set object, and the first maximum value of the first set object may be modified if the first maximum value is the same as the second maximum value. The instructions to modify the first maximum value may include instructions to modify the first set object to include the value of a penultimate partition entry in a last partition entry. The normalized version of the first set object may be further normalized in accordance with a second process. Normalizing in accordance with a second process may include normalizing consecutively-ordered elements of the first set object in accordance with the second process, where a first element is in a first ordered sequence before the second element and the universal set object includes the first and second elements as an uninterrupted second ordered sequence of elements. The normalized version of the first set object may be further normalized in accordance with a third process. Normalizing in accordance with the third process may include normalizing representations of intervals in a first set object. The intervals may represent a span of objects in the first set object. Both he second and third processes may be used individually, or in any combination with the each other or the first process to normalize the first set object. Normalizing consecutively-ordered knot elements of the first set object may include removing one of the first element or the second element. The first and second elements are knot elements that have corresponding partition entries, and removing one of the first element or the second element may include removing the first element and a corresponding partition entry representing inclusion of the first element in the first set object. The intervals may be normalized to generate a single representation of a same span of objects across different set objects, and normalizing the representations may include replacing a half-open interval with an equivalent half-closed interval. Replacing a half-open interval with an equivalent half-closed interval may include removing a knot element and corresponding partition entry of the first set object. The systems, techniques, and computer program products for machine-implemented representations of a collection of objects described here may provide one or more of the following advantages. A set object may be provided that approximates and models real world collections of objects. To generate approximations, a certain completeness may be provided; in other words, operations on objects of a model will not lead to objects that cannot be represented by the model; otherwise, problems may occur like the approximation of numbers in a computer system that may lead to rounding problems, underflow exceptions, and overflow exceptions. To achieve completeness in the sense that set operations such as complement, intersection and union within the model will not lead to sets that the model cannot represent, the set object may be adapted. For example, sets may be normalized under certain conditions. Efficient algorithms for basic set operations, such as intersection, complement, and union, may also be provided. The set object may improve the efficiency and/or provide an intelligent way to express collections of objects for techniques and/or systems that involve near-line storage, planning, and authorization. The set objects may be normalized to provide a consistent representation of objects in a set. One or more types of processes can be used to generate different types of normalization. The processes for normalizing set objects may be optimized such that consistent, reproducible results are generated when operations are performed on normalized set objects. As an example, for a universal set being the set of all integers, the sets i<4 and i≦3 represent the same integer values; however, they could each have different representations in a computer. By providing a method of normalizing set objects, different representations of these sets might be changed to one type of representation. Advantageously, a consistent representation might ensure consistent results and ease the implementation of operations on set objects. For example, if one desired to implement an operation to determine if two sets were identical, it might be easiest to simply check to see if their representations are identical. However, if the representations differ, there might be inaccurate results (e.g., a determination that two sets are not equal, although only their representations differ) or the operation might require a much more complex implementation that takes into account inconsistencies between representations of sets. Advantageously, a combination of processes for normalizing set objects might be used as a practical approach to achieving consistently normalized set objects. For example, normalizing a set object can include normalizing maximum and minimum values, removing redundant values, consistently representing intervals, and consistently representing consecutive values. In addition, normalization may simplify user input when a set is defined by a user. For example, a user of a software application can enter different selection conditions to define a same set of objects, and the resultant sets objects can be normalized so that the set objects are consistently defined within the computer. For example, a user could enter, for the universal set of integer values n, the condition “n BETWEEN 6 AND 9.” Yet, the computer might generate a normalized set object and interpret that set object as being equivalent to the conditions “n IN (6,7,8,9),” “n>=6 AND n<10,” or any other variant. Details of one or more implementations are set forth in the accompanying drawings and the description below. Other features and advantages may be apparent from the description and drawings, and from the claims. These and other aspects will now be described in detail with reference to the following drawings. Like reference numbers and designations in the various drawings indicate like elements. The systems and techniques described here relate to machine-implemented representations of a collection of objects. Overview A model for representing sets as set objects may be described in the following pages in accordance with the following chain of subsets in an arbitrary universal set U:
In that chain of subsets, U is a given universal set that need not be finite and is not necessarily completely representable on a computer system (e.g., U could be the set of real numbers); however, the elements of U are ordered. T will be an approximation of U that has a representation in a certain programming language and on a certain hardware platform (e.g., T could be the set of all different values which can be stored in a variable of data type float). S can be the set of all values that are allowed by an application, developed with the programming language, as possible input. The elements of S need not be stored and enumerated until the first time they are used. Finally, C is the set of all values that are in current use at a certain time (e.g., persistently or transiently) by the application. Data structures that represent sets within the chain of subsets can be described as representations of a closed subset M of the power set of P(U). “Closed” means that for each element of M, the complement with respect to U is also an element of M. In addition, for two arbitrary elements of M, their intersection and their union are elements of M. The four kinds of sets (C, S, T, and U) can also be described with how they typically can change over time. For the universal set U, there is an assumption that the elements of U are fixed in time. The set T can change in time when the data type of T is replaced by a new one which includes all values of the previous one and which is still a subset of the universal set U (e.g., changing the data type of a certain domain from 4-byte integer to 8-byte integer, or from float (single-precision) to double, or increasing the length of a character domain (the data type of a character domain and the concept of domains are concepts from Advanced Business Application Programming (ABAP); ABAP specification available from SAP AG of Walldorf (Baden), Germany). The set S can also change over time, and can change more frequently than T. For example, the set S can change when an application's logic for checking user input is changed (e.g., if an application accepts a larger range of input). In such a scenario, a change of S must not exclude values of C. C can be the most frequently changed set (e.g., elements (or values) can be added to C whenever new values are entered into the system as input). Representation of Sets In general, if all possible subsets for a given universal set U are to be included in a computer representation of sets, all elements of the power set P(U) of U should be considered. If U cannot be represented on a computer system, then P(U) cannot be represented as well. A certain subset of P(U) should be defined such that the subset can be represented on a computer system and the subset can have the property of being complete, as described earlier. This should also be the case when there exists one subset of P(U) which has the property of completeness and has the same property of completeness for all universal sets U (i.e., all types of universal sets, where each set may have a different context). An example of a subset of P(U) for an arbitrary universal set where U is complete with respect to basic set operations is the set that includes the empty set Ø and the universal set U (e.g., a set A={U, Ø} (i.e., in general, a representation should be a subset of P(U) such that the representation still forms a proper Boolean Algebraic representation with respect to intersection and union operations). In developing a representation of sets, the above model can be used as a basis for a one-dimensional representation of a set and a multi-dimensional representation of a set can include nested sets. An initial model may include simply the empty set Ø and the universal set U. Within this, the basic set operations are well defined and complete for a subset of the power set. Each set is the complement of the other; the intersection is the universal set U if the operands are the universal set and the empty set; and the union is the empty set if the operands are the empty set and the universal set. The public boolean methods isEmpty( ) The model also includes basic set operations, including, equality, complement, intersection, union, and containedness. The equality operation is represented by the public method isEqual( ) Representation of a One-Dimensional Set A second model may be developed based on the initial model discussed above. The second model includes a set object for a multi-dimensional universal set U that is defined as the Cartesian Product of multiple one-dimensional universal sets U Although multiple dimensions are defined, the empty set and the universal set might not be assigned to a specific dimension. Instead, they may be defined to be members of a dimension with a positive infinite order. Thus, the dimension of any sets other than those represented by the empty or universal set is less than the dimension of the empty set and the universal set. Dimensions in the second model are identified in the following by a unique index number running from 1 to the maximum number of dimensions. In the case where each set object represents one-dimensional sets, arbitrary universal sets U The description of the second model will be restricted to the subset M where Θ( ) represents a function which maps a value t within T Other relations can be derived from the following functions, such as
u≧t}=\Θ(t, ≧),Θ( t, >):={u ε U _{d} |u>t}={u ε U _{d} | u≦t}=\Θ(t, ≦),Θ( t, =):={u ε U _{d} |u=t}={u ε U _{d} |u≧t Λ u≦t}=Θ(t, ≧)∩Θ(t, ≦), andΘ( t, ≠):={u ε U_{d} |u≠t}={u ε U _{d} | u=t}=\(θ(t, ≧)∩Θ(t, ≦));where ‘\’ denotes the complement of a set with respect to the universal set U To represent these objects, the ranges table The SQL expression The graphical representation The set object The entries included in the vector To represent sets in a consistent fashion, such that elements in a set would have the same representation in any two set objects, the set object As will be discussed in further detail later, the set object Set Object Data Structure: One-Dimensional Set Referring back to the second model discussed above, a one-dimensional set S can be a true subset of a dimension's universal set U In the model In the array p[ ] Thus, the knot value array t[ ] where n is the size of the set, S.t(i) is a method that returns the value of the i-th knot (i.e., S.t(i):=S.t[i]), each S. Π( ) represents a block of the partition, and u is a value within a multi-dimensional universal set U In the description of blocks, the blocks obey the partition rules: S.Π(i)∩S.Π(j)=Ø, i≠j (i.e., no blocks overlap); and If a method S.P(i) is introduced such that:
where the method returns either an empty set or a universal set for an i-th block depending on whether an entry in the partition array p[ ] 325 for the set S includes 1 or 0, a one-dimensional set S can be expressed as:
Accordingly, the class DimensionSet Representation of a Multi-Dimensional Set A multi-dimensional set object, in general (i.e. where there exists more than one dimension in a model of a collection of objects), is either a Cartesian Product of two sets, or an ordered conjunction (i.e., a union) of sets. In A union set is a union of disjoint Cartesian Products. Each Cartesian Product consists of a block of a partition and another set (e.g., knot value The following model may be used to describe the representation of a multi-dimensional set object. It can be assumed that the multi-dimensional universal set U is a Cartesian Product of a set of one-dimensional universal sets U In that model, each dimension should be represented by a data type that can be ordered. For example, each dimension can be approximated in a computer system by an elementary data type, or a complex data if a complex data is can be ordered (i.e., an order can be defined among values represented by the data type; e.g., the elementary data type integer is ordered because the values of variables can be ordered, for example, in increasing number, such as 0, 1, 2, and so on). In addition, each dimension should be uniquely identifiable by, for example, a name. As an example, a column name of a relational database table may be used to uniquely identify a dimension. The model may use a combination of one-dimensional sets to represent a multi-dimensional set. For example, the model may embed one-dimensional sets in a multi-dimensional set. A one-dimensional set S
In other words, a multi-dimensional set S should be representable as the Cartesian Product (represented by ‘x’ above) of (1) all one-dimensional universal sets U To represent this property, values of a one-dimensional set can be stored, without explicitly storing all the universal sets of the other dimensions in the Cartesian Product, such that using the dimension information for the dimension defined by U To provide for completeness of representation for multi-dimensional sets, two additional types of sets, other than the one-dimensional set, may be used: a Cartesian Product set and a union set. A Cartesian Product set C can represent a simple Cartesian Product of a one-dimensional set D, referred to as a first Cartesian Factor, and an arbitrary set F (i.e., arbitrary in the sense it may be a one-dimensional set, or another type of set, such as a Cartesian Product set or a union set) which will be referred to as a second Cartesian Factor. The representation will store references of these two objects as private components C.D and C.F. For normalization of the Cartesian Product set, the components of a Cartesian Product set should fulfill the constraints:
where CD.dim( ) represents the order of the dimension (i.e., whether a dimension is of a higher or lower order than another dimension; the order of dimensions may be defined arbitrarily or otherwise) of the Cartesian Factor D and CF.dim( ) represents the order of the dimension of the Cartesian Factor F, such that the order of the dimension of the Cartesian Factor D should be less than the order of the dimension of the Cartesian Factor F; and the Cartesian Factor F should not represent the empty set or the multi-dimensional universal set U. The model of a Cartesian Product set may further include the definition of the dimensions of a Cartesian Product set and the definition of knot values and partition sets that represent the collection of objects of a Cartesian Product set. To define the dimension order of a Cartesian Product set, the dimension order of a Cartesian Product set C can be defined by the dimension order of its component D: C.dim( ):=C.D.dim( ). The model of a Cartesian Product set may represent a collection of objects similarly to the representation provided by a one-dimensional set defined above, by using a collection of knot values and a partition set. The knot values of a Cartesian Product set may be defined by a vector of knot values represented by t and knot values may be retrieved by a method C.t( ). A partition set may be a vector of references to sets and values of partitions in the partition set may be retrieved by a method C.P( ). The knot values and the partition sets, respectively, may be defined in accordance with:
In other words, the Cartesian Product set may inherit knot values from a one-dimensional set that represents the Cartesian Factor D, and a value of the partition set C.P(i) of a Cartesian Product set is the empty set if a corresponding bit C.D.p[i] (i.e., an i-th bit in the partition bit vector of the Cartesian Factor D) of the dimension set is “0”, otherwise it is the Cartesian Factor C.F. The size of a Cartesian Product set C may be defined by the size of its Cartesian Factor D (i.e., C.size( ):=C.D.size( )). According to this model of the Cartesian Product set, arbitrary intersections of one-dimensional sets and Cartesian Product sets can be calculated and the result will be the empty set, a one-dimensional set, or a Cartesian Product set. The model may further define a union set (with the set types introduced thus far it is not reasonably possible to represent the union of two arbitrary sets). An unnormalized representation of a union set U may be defined by a knot value collection U. t[ ] and a partition set collection S.P[ ]. The knot value collection may be a sorted array U.t[ ]of size n distinct values of the dimension's data type (i.e., U.t[i] being elements of T, as defined in the one-dimensional case). The partition set P[ ] may be a partition set array of size 2n+1, where n is the size of a set S (which may be retrieved by, for example, a method called S.size( )). Like a one-dimensional set (defined as DimensionSet The classes Dimension Set As mentioned earlier, each of the classes Dimension Set The class Cartesian Product Set The class Union Set A model of a one-dimensional set, a two dimensional set and an n-dimension multi-dimensional set can include several different types of set objects, including: an empty set object, a universal set object, a one-dimensional set object, a Cartesian Product set object, and/or a union set object. A one-dimensional universal set (which can be an ordered list of distinct values, which might be also be tuples if an order for these tuples is defined) can be defined with reference to the first three types of set objects (i.e., the empty set object, the universal set object, and one-dimensional sets having a sorted array of distinct values from a subset (all technically representable values) of the universal set and a normalized partition bit array (see normalization conditions for one-dimensional sets). In a two-dimensional universal set (i.e. the set of all ordered pairs (2-tuples) where a first component is an element of a first universal set that belongs to a first dimension and a second component is an element of a second universal set which belongs to a second dimension) the following set objects can exist and describe the model: an empty set object; a universal set object; one-dimensional set objects belonging to the first dimension (see the description of how a one-dimensional set can be embedded in a multi-dimensional space by adding a reference to a dimension abstraction); one-dimensional set objects belonging to the second dimension (i.e., one-dimensional set objects that define the second dimension and can be defined by a same data structure as the one-dimensional set objects that define the first dimension), Cartesian Product set objects having a one-dimensional set object of the first dimension as a first Cartesian factor and a one-dimensional set object of a second dimension as a second Cartesian factor; and union set objects. The Cartesian Product set objects might all belong to the first dimension per each construction. In a two-dimensional space no normalized Cartesian Product set objects might exist that belong to the second dimension. This can be true because normalization conditions can define that the dimensions have to be ordered in a Cartesian Product set object and that the second Cartesian factor must not be a reference to the empty set object or the universal set object. Union set objects can define all other set objects belonging to the first dimension (i.e. having knot values from the first universal set and a partition set array which consists of references to the empty set object, to the universal set object, and/or to one-dimensional set objects of the second dimension; for normalization reasons there can be at least one reference to a one-dimensional set object in the partition set array). An n-dimensional universal set might be defined as the Cartesian Product of a (one-dimensional) universal set (referred to as the first dimension) with a (n−1)-dimensional universal set (referring to the second up to the n-th dimension) having the following set objects: an empty set object; a universal set object; (n−1)-dimensional set objects from the 2nd to the n-th dimension (excluding trivial set objects such as the union set object and the empty set object); Cartesian Product set objects that can be built by combinations of a one-dimensional set object belonging the first dimension as the first Cartesian factor and non-trivial (n−1)-dimensional set objects belonging to the 2nd up to the n-th dimension as the second Cartesian factor; and union set objects belonging to the first dimension having a sorted knot value array of distinct knot values from a subset of the first universal set and having all combinations of all (n−1)-dimensional set objects belonging to the second up to the n-th dimension, where the empty set object and the universal set object can be elements of the partition set array. As in the two-dimensional case, there can be at least one reference to a non-trivial set object in the partition set array for normalization reasons; otherwise the set object is not regarded as normalized and may be converted to an equivalent one-dimensional set object belonging to the first dimension. Although the model Normalized Sets: Overview Both one-dimensional sets and multi-dimensional sets can be normalized. Normalization should ensure that whenever two representations represent the same set within M (N1) The boolean expression (S.p[2i]=S.p[2i-1])Λ(S.p[2i]=Sp[2i+1]) is false for all i between 1 and S.size( ). (N2) Two subsequent elements of S.t[ ] are distinct. I.e., S.t[i]<St[i+1] is true for all i between 1 and S.size( )−1. (N3) There must exist at least one knot value. I.e., S.size( )>0 must be true. Where, S.p[ ] represents a partition vector as described earlier, S.t[ ] represents a knot vector as described earlier, and S.size( ) is a method representing the size of the knot vector of the set S. If the first constraint (N1) or the second constraint (N2) is not fulfilled a knot is redundant. To normalize such a set, all redundant knots can be removed from a representation (e.g., a data structure) of the set S. If the third constraint (N3) does not hold, a set S can be normalized by replacing the set S with the empty set (i.e., Set.EmptySet) if S.p[1]=0 and by the universal set (i.e., Set. UniversalSet) otherwise. Normalization constraints (N1), (N2), and (N3) may be referred to as, in combination, “standard normalization”. Beyond standard normalization, normalization conditions could be enforced depending on further properties of U=U (O1) The minimum element of T (if it exists) is also a minimum element of U:∀ u ε U(u≧min(T)); (O2) The maximum element of T (if it exists) is also a maximum element of U:∀ u ε U (u≦max(T)); (O3) Each element of U has either a unique successor (predecessor) or is (if exists) the maximum (minimum) element of U:∀ u ε U (∃u_{succ }ε U (∀νεU(u≦ν≦u_{succ} ν=u ν=u_{succ}))∀ νε U(ν≦u)); and T must be a well-ordered subset of U.
Satisfying further normalization assists in performing basic set operations that will be described later. Depending on a data type that represents a universal set U
To uniquely represent an arbitrary set, in a multi-dimensional set environment (i.e., where the universal set has multiple dimensions), as either the empty set, the universal set, a dimension set (i.e., a one-dimensional set), a Cartesian Product set, or a union set, normalization conditions may be defined. In a multi-dimensional set environment, one-dimensional sets may follow the normalization conditions discussed above. For a union set U of size n, the normalization conditions may include the following conditions (N1) through (N5): (N1) For the partition sets the condition:
must be false for every knot (i=1 . . . n), where n is the size of the set U and the method isEqual( ) determines whether a partition set is equal to another partition set. In other words, no 2i-th partition sets can be equal to each (2i−1)-th partition set, where a 2i-th partition set is equal to a (2i+1)-th partition set. If the N1 condition is not fulfilled for the i-th knot, the i-th knot is redundant and can be removed, as was discussed in the one-dimensional case. (N2) Two subsequent elements of the knot value array U.t[ ] should be distinct (i.e., U.t[i]<U t[i+1] is true for all i between 1 and n−1, where n is the size of the set U). (N3) There should exist at least one knot (i.e., n>0 must be true). If a knot does not exist (i.e., if n=0), U could be replaced by a solely remaining partition set U.P(1) (i.e., this could be any set which belongs to a dimension of higher order). (N4) Every partition set should belong to a “higher” dimension than the dimension of the union set. In other words, U.dim( )<U.P[i].dim( ) must be fulfilled for all i between 1 and 2n+1, where n is the size of the set U and the dimensions of all sets in the multi-dimensional model are ordered. (N5) The logical expression: ∃i, j(1≦i≦2n+1Λ1≦j≦2n+1ΛU.P[i]≠ØΛU.P[j]≠ØΛ U.P[i]isEqual(U.P[j]) must be true. In other words, all partition sets in the set U that are not the empty set should not be equal all together. If this condition is false, a non-empty set can be factored out from the array of partition sets and the whole set U can be either represented as a Cartesian Product set (if the factor is not the universal set) or a dimension set (if the factor is the universal set). In either case, the knot array should be the same as the knot array of the unnormalized union set and a partition bit array should be derived from the partition set array U.P[ ] by setting a bit to “0” for every empty set and a bit to “1” otherwise.To uniquely represent sets in a multi-dimensional set environment, general normalization conditions may apply. In general, normalized sets in a multi-dimensional set environment include the empty set, the universal set, a one-dimensional set, a Cartesian Product set, or a union set. Although these different set types have different attributes, common normalization conditions should include (N1) through (N4) as follows. (N1) Each set should be uniquely assigned to a dimension. To follow this condition, the empty set and the universal set may be assigned to an artificial dimension of infinite order; one-dimensional sets and union sets may be explicitly assigned to a dimension (i.e., a dimension to which knot values belong is an explicit attribute of this kind); and a dimension of a Cartesian Product set may be derived from the dimension of its first Cartesian Factor (which may be defined to be always a one-dimensional set). (N2) Each set has a sorted collection of unique knot values belonging to the set's dimension. Under that condition, the empty set and the universal set may have an empty knot value collection; one-dimensional sets and union sets may have an explicit knot value array; and, the knot value collection of a Cartesian Product set may be the knot value array of its first Cartesian Factor. (N3) Each set has a size. The size should be the number of knot values. (N4) Each set has an indexed collection of partition sets. Under that condition, the size of the partition set collection is always two times the number of the knot values plus 1 (i.e., 2n+1). For the empty set and the universal set there may exist only one partition set, which is the set itself. For a one-dimensional set, the partition set at index i may be the empty set if the bit at index i of its partition bit array is 0, and the partition set at index i may be the universal set otherwise. For a Cartesian Product set, the partition set at index i may be the empty set if the bit at index i of the partition bit array of its first Cartesian Factor is 0, and the partition set at index i may be the second Cartesian Factor otherwise. Extended Normalization of Set Objects As discussed above, when representing a collection of objects in a computer, as a set, two set objects may represent the identical collection of objects, but they may have different representations (e.g., by not being set objects that contain the same values, such as knot values in a one-dimensional set object). For example, for a universal set being the set of all integers, the sets i<4 and i≦3 ate the same (as they include the same integers); however, the different expressions may result in different set objects. Following that example, a first set object representing the first expression may have a knot array having a single knot value of 4 and a partition vector that indicates elements below four, but not including 4, and the numbers above four are in the set object (e.g., 1, 0, 0). In contrast to that representation, a second set object representing the second expression may have a knot array with the knot value 3 and a partition vector indicating that the numbers below 3 and at 3 are in the set object, but not the numbers above 3 (e.g., 1, 1, 0). Although normalization of set objects need not be performed and a certain amount of non-uniqueness may be acceptable, having a degree of consistency across set objects representing a same collection of objects may be desirable. Thus, in addition to, or instead of, any of the standard normalizations discussed above, other types of normalization, also referred to as “extended” normalization, may be performed. The extended normalization may take into account scenarios not covered by standard normalization such that consistency is ensured across set objects that represent a same collection of objects for those scenarios (e.g., a consistent representation of consecutive, uninterrupted sequences of values). The extended normalization may assist in implementing operations on set objects and those operations may result in consistent results (e.g., operations on multiple set objects representing a same collection of objects would have consistent results). For example, if an operation that determined whether two set objects were identical was to be implemented, an implementation might include iterating through the knot values and partition values, one-by-one, in a simple fashion, to see if the representations are the same. However, if the representations differ such that the set objects differ, implementing the operation might be much more complex, or have inaccurate results (e.g., a result determining that two set objects are not equal, although their corresponding collection of objects is identical). The flow chart Setting-up a system (e.g., a computer) to generate a normalized set object ( A first element (first in the sense of ordering) of a partition vector is normalized because there can be an ambiguity for a first partition set (which defines the inclusion or exclusion of all values less than a first knot value). This can occur if a first knot value is equal to the technical minimum value and the technical value is also the minimum value of the universal set (U) that can be represented by the technical data type (T). In the case that those conditions are true, the set {u in U|u<min(T)} would be the empty set. Thus, rather than having multiple set objects represent an empty set differently, normalizing a first partition set to an empty set may be advantageous. For example, were U would be the (infinite) set of all integer numbers and T the set of all 4-byte integer numbers, the minimum of T may be −2 As another example, were U to be a set of all natural numbers (including ‘0’) and T a set of all unsigned 1-byte integers, the minimum of T may be ‘0’ which is also the minimum of U. In this example, the set S might be defined such that {u in U|u=>0} is equal to the universal set. Thus, an unnormalized representation of S might be defined by a knot array (0) of size 1, which contains the minimum technical value and a partition bit array (0,1,1) of size 3. The first partition bit might represent the set {u in U|u<0}, which is equal to the empty set. Thus, the first partition bit might be redundant. To resolve the ambiguity, a partition bit could be set as the same value as the second partition bit. Following the example, this would result in a partition bit array (1, 1, 1). According to the standard normalization conditions, a redundant knot can be indicated and that redundancy might be removed. Were the only knot value to be removed, an empty knot value array might remain and a bit array (1) of size 1 might result. That could represent the universal set, such that, the example would be normalized to the universal set. Referring back to the flow chart If the first element is a minimum technical value, a determination is made as to whether a minimum value of the universal set is the same as the minimum knot value (e.g., the first knot value k[1]) ( If the first knot value is not a minimum technical value or the first knot value is not the same as the minimum value of the universal set, the set object is not modified, and the set object is considered normalized with respect to an ambiguity that can occur with the first element of the set object. Normalizing a last partition set ( Normalizing redundant links ( If the knot values are in the in the collection of objects, the succeeding partition set is set to the current partition set ( The standard normalization discussed above assumes that, for every two knot values, there always exists an element of U which is located between the two knot values, even if the second knot value is the direct successor of a first knot vector according to the technical data type. However, if no element of U exists between two successive knot values, the link bit between two knots can be considered redundant (as it is a redundant representation of the consecutive nature of the knot values). Ambiguity may be removed by deriving a link value from two surrounding partition entries: If the surrounding partition entries are both equal, the link would be set to either of them; otherwise, the link entry would be set to the empty set. As an example (using one-dimensional set objects; e.g., in accordance with the substitution of partition entries with partition bits, and the like discussed above and the example one-dimensional set objects discussed above), were U to be the set of all integer numbers and T the set of all 4-byte integers, a representation of the set S {u in U|u>2 and u<=3} could be defined by the knot array (2, 3) of size 2 and the partition bit array (0, 0, 1, 1, 0). In that example, the third partition bit The remaining sub-processes ( In general, intervals are normalized in the flow chart Normalizing a set object may also be important to improve the extensibility of a system (e.g., the ability to upgrade data to a new data type that offers a greater range of values and ensure results of operations are consistent across upgraded and non-upgraded data). For example, for a dimension D that is built with a decimal data type with five digits and two decimal places, the technical minimum and maximum values may be −999.99 and +999.99, respectively. If a set object is generated based on an expression d>=−999.99, and that set object is not normalized according to the extended normalization, that set object could include all values of the data type. Thus, the generated set object may have the same representation as a universal set object. However, if the dimension were to be extended such that the number of digits were increased (e.g., to six decimals), ambiguity between the representations of the generated set object and the universal set object might be resolved. Because of the inconsistent ambiguity across different data types, inconsistent results could be computed when performing operations on set objects across the same data (e.g., different results could be computed when operations are performed on the five digit set object and the six digit set object). However, were the set objects to be normalized in accordance with the extended normalization, the set object in the five digit data type might not have an equivalent representation as a universal set object, such that transferring the same data to a system using the six decimal data type could have representations that allow for consistent results when operations are performed on those set objects. Thus, normalization can have a relationship to the extensibility of a system. As an example, a set object representing an open interval defined by an expression d>0.00 and d<0.01 might not include any value of a data type (e.g., a decimal data type having two decimal places such that no value exists between 0.00 and 0.01). However, if the data type were to be extended such that the number of decimals were increased (e.g., from two decimal places to three decimal places), the set object could be uniquely represented with respect to an empty set object (e.g., as the set object would include a value, such as 0.001). Redundant knot values are removed by determining whether a current partition set is the same as a preceding and succeeding partition set ( If the preceding partition set is equivalent to the empty set, the process of normalizing the set object continues with processing the current partition set ( Processing the current knot value ( Processing of the succeeding partition set ( If the knot value is not less than the technical maximum, and the current partition set is not the empty set or equal to the succeeding partition set, the current partition set is retained ( Were the current knot value to be less than the technical maximum, a check is made to determine whether the current and succeeding partition set represent a left-open interval ( When process of normalizing the intervals has iterated through the set object (by going through all but the last element of the set object), the last partition set is retained ( As discussed above, an altered version of the flow chart 1100 could be used to generate a normalized one-dimensional set object. In any case, the flow chart 1100 could be more generally described as involving, normalizing a minimum value of the set object ( Although the flow chart Normalizing a set object need not be limited to the standard and extended normalizations discussed above. Also, the “standard” normalization processes need not be default normalizations that are performed, and the extended normalizations need not be normalization processes performed in addition to any other normalization processes. To normalize set objects any combination of processes can be used. For example, normalization of a set object that is implemented using a float data type might involve normalizing the first and last values, yet, the intervals need not be normalized. Also, normalizing need not be limited to normalizing a set object with integer values. As examples, the values may be calendar dates or names of persons that are ordered according to an inherent rank. However, the data types that can be normalized using the extended normalization processes might be limited. For example, floats and strings might not be suitable for the extended normalization processes. The normalization might be applicable to only certain set objects. For example, for a Cartesian Product set object the normalization process of the flow chart The normalization process in the flow chart Basic Set Operations on a Set Object Basic set operations on a set object include complement, union, intersection, equality and containedness. To provide for basic set operations, some fundamental properties may be required of a set. For example, this may include being able to determine the dimension order of a set. As described earlier, the dimension information of a one-dimensional set may be retrieved from a set object with a method dim( ) providing the possibility to determine the dimension order of two one-dimensional sets (i.e., checking A.dim( )<B.dim( ), if A and B are two one-dimensional set objects). Complement If a one-dimensional set is defined, as described earlier, to include a partition set collection represented by a partition bit array (or bit vector), the complement of a one-dimensional set can be calculated by calculating the bit-complement of the partition bit array (or bit vector) (i.e., a “0” becomes a “1”, and vice versa). This operation should not violate the standard normalization property of a set (i.e., if a one-dimensional set is normalized its complement is also normalized). For a multi-dimensional set defined as combination of empty sets, universal sets, union sets, Cartesian Product sets, and one-dimensional sets, where the one-dimensional sets are represented by a partition bit array (or bit vector), the complement can be calculated in accordance with the following. The complement of a Cartesian Product set C can be calculated by using De Morgan's laws: C.complement( ):=C.D.complement( ).unite(C.F.complement( )). In other words, the complement of a data structure representing a Cartesian Product can be calculated iteratively as the union of (1) the complement of the first Cartesian Factor D and (2) the complement of the second Cartesian Factor F. For example, because the Cartesian Factor D may always be a one-dimensional set, the complement of D may be calculated as defined above, for partition bit arrays (or vectors). If the Cartesian Factor F is a one-dimensional set, the Cartesian Factor F can be calculated likewise, otherwise, it may be calculated by nested calculations using the techniques for calculating the complement of a Cartesian Product, a one-dimensional set, and/or union set. At At At Referring back to A union set can be calculated using the following model. With the definitions Π
where the sets Π Calculating the complement of this expression, according to De Morgan's laws, may be according to the expression:
This is because, according to De Morgan's laws the complement of a union set is the union of the complement of all partitions and partition values, such that,
Using the identity U=
Using the absorption rule A=A∪(A∩B) this expression can be simplified to:
Because the sets Π
where the first term of this expression evaluates to the empty set because it is the complement of the partitioning condition
can be used to simplify the whole expression to:
Provided that the original union set is already normalized as defined by in the description of normalization conditions for union sets, either a normalized Cartesian Product set or a normalized union set should be the result of the complement of a union set. At At At If the result of the determination at Referring to the processes at If, at If, at If, at Intersection To perform the intersection of two one-dimensional sets, the two sets should belong to the same dimension. At At Referring back to the processes at If the result of the process at If the result of the process at Referring back to At If the temporary knot value was not redundant, at To calculate the intersection of two multi-dimensional sets, each multi-dimensional set should exist in the same multi-dimensional universal set U. A generalized version of the processes discussed in reference to The process of At The process of Additional and/or different processes may be added to the process of As another example, the intersection of a Cartesian Product set as the first operand (i.e., set object A) with an arbitrary set as the second operand (i.e., set object B) that is of a higher dimension may be a special case. In that case, the result can be the empty set if the intersection of the second Cartesian Factor of the first operand (i.e., the Cartesian Factor F of set object A, A.F) with the second operand (i.e., set object B) is the empty set. Otherwise, the result can be a Cartesian Product set having the same first Cartesian Factor as the first operand (i.e., the Cartesian Factor D of set object A, A.D), and the second Cartesian Factor as the intersection of the second Cartesian Factor of the first operand (i.e., the Cartesian Factor F of the set object A, A.F) with the second operand (i.e., the set object B). Union Calculating the union of two one-dimensional sets can directly be derived from the algorithm for the intersection given before by making usage of the identity
Using this identity (based in general on the duality of the two operators in Boolean Algebra), the replacements (marked in italics in (R1) Replace (bit-) and-operations with (bit-) or-operations, and (R2) Replace the empty set with the universal set. As per calculating the union of multi-dimensional sets, calculation of the union of two multi-dimensional set objects is complementary to calculating the intersection, as described herein. The process of calculating the union can be derived by performing the replacements (R1) and (R2) to the process illustrated in (R1) Replace operation intersect with unite. (R2) Replace the empty set object with the universal set object, and vice versa. Equality For the set operations described earlier, it may be necessary to check if two set objects are equal (i.e., having the same normalized representation and same values) or not. For two typically trivial cases, the empty set and the universal set, a comparison of the identity (i.e., comparison of object references) might be sufficient. Other sets that may require a more involved check of equality include the one-dimensional set, the Cartesian Product set, and the union set. In a data structure representation for each type of set, a method isEqual( ) may be defined differently to implement the differences of the checks of equality. At At At At At Containedness In order to check if a certain element c of a set C In the case of a multi-dimensional universal set U, the check of containedness has to be extended from a single scalar value as input to a tuple as input. If U is the Cartesian Product of n one-dimensional universal sets, the elements of U can be described as n-tuples where a component at the i-th position of a tuple is an element of the universal set of the i-th dimension. The check of containedness that is performed can depend on the object type. The following techniques (C1) through (C4) may be implemented to perform a check of containedness. (C1) The empty set returns false and the universal set returns true as a result. (C2) For the dimension set (e.g., DimensionSet (C3) For the Cartesian Product set, checking for containedness may be delegated to the Cartesian Factors (i.e., the two components C.D and C.F). Then, boolean results from the check of containedness of each of those Cartesian Factors can be combined by an “and” operation, and returned as the result of the Cartesian Product set (i.e., the tuple must exist in each Cartesian Factor of a Cartesian Product set). (C4) The check for the union set is similar to the check for the dimension set described at (C2). The appropriate component of a tuple is determined according to the union set's dimension and the value v of the component is used to find the minimum m with ν≦U.t[m]. If such a minimum does not exit ν>U.t[n] is true and m is set to n+1 with n=U.size( ). If m≦nΛν=U.t[m] the check is delegated to the (knot) partition set U.P[2m] otherwise a check is performed for the (link) partition set U.P[2m−1]. The corresponding result of the delegated check can be returned as the result of the union set. Each check of containedness reduces the level of complexity of the problem at least by one, by removing a dimension order. Thus, a final result will be generated after n checks where n is the number of dimensions of the universal set U. In that scenario, each individual “dimension” check will take asymptotically O(log(m)) operations where m is the complexity (i.e., the size of a corresponding knot value array) of a set object on which a check of containedness is being performed. Application to Data Aging Many of today's enterprise applications and services are based on relational data models and are using relational databases to store their (consistent) states persistently. Relational data models are based on mathematical set theory. Set objects could be used to improve the efficiency of a relational data model. Set-based conditions using dimensions that are meaningful for queries, and are related to the age of data that is frequently used, could be used to define a series of archive partitions. A data store is always partitioned in an online partition O An archiving process could be defined by a series of disjoint sets R
The new set describing the archive partition can be defined as the union of the previous archive set with the request set; i.e.,
Thus, a new online partition set can be defined as the complement of the new archive partition set. If a query is to access data transparently from a whole data store (including frequently used data in an online store and less frequently used data in an archive, such as near-line storage), a selection condition of the query or the query's navigation step can be converted to a multi-dimensional set object Q. Calculating the intersection between Q and the current archive partition set A Application to Multi-Dimensional Planning Typical planning and budgeting processes read a certain subset of records according to a selection condition from a database table, modify these records, add new records within the specified selection condition, delete some records, and write the result back to the database such that a whole subset of selected records is replaced. In a multi-user environment the data range that can be manipulated is generally exclusively locked for a single user or process in order to avoid data inconsistencies. In some instances, it might not be sufficient to lock selected records, and a whole selected data range might be locked. Using set objects in planning and budgeting applications may provide an exact multi-dimensional locking of data ranges, thus minimizing the resources that are locked, which may improve overall performance by avoiding bottlenecks associated with locked resources. The process of using set objects may be roughly explained as follows. All currently locked data ranges can be stored as a multi-dimensional set (called a lock set) by a central lock service. On system startup the lock set can be set as the empty set (i.e., nothing is locked). If a process (or user) is to create new records or change existing records for a certain non-empty data range (e.g., expressed by a SQL-like condition for key columns of the affected database table) (e.g., if a process is to require locked records), the process (or user) can pass a condition indicating the data range (or the records to be locked) to the central lock service. At the central lock service, a condition passed from a process or user can be converted to a multi-dimensional set representation and that intersection of the multi-dimensional set representation and the current lock set can be calculated (i.e., the data to be locked can be calculated as an intersection of the current lock set and the passed condition). If the intersection is not the empty set, a lock request must be refused (i.e., there is common data so common access should not be allowed). If the intersection is the empty set (i.e., data is not common and is available for locking), the central lock service can store a union of the passed set and the current lock set as a new lock set (i.e., the lock set is updated). In addition, the service may store the complement of the passed set in a directory of open lock requests and return a unique handle to a lock requestor (i.e., a process or user requesting to lock data). The lock requestor, which may be the lock holder (if a lock is not refused) can keep the handle for unlocking the data range. To unlock a data range, a lock holder can pass a handle to a central lock service. In response, the central lock service can identify a set corresponding to the handle. The intersection of this set (which is the complement of the original passed condition) and the current lock set can be calculated and stored as the new lock set. In addition, the handle and its associated set can be removed from the directory of open lock requests. To improve reliability, each of the actions from converting a condition to a set to creating the new lock set when a data range is unlocked, can be exclusive in the system. Application to Authorization Today's implementations for authorization-checks define authorizations positively. Authorizations can be (inclusively) added to a referenced authorization profile but cannot be (exclusively) subtracted from it. If a role authorization was expressed on a multi-dimensional set, it may be possible to derive user authorizations from the role authorization by simply including (union) and/or excluding (intersection with the complement) a user-specific authorization set from a referenced role authorization set. For example, a multi-dimensional set object may represent roles corresponding to resources. In that example, a first dimension may represent available roles and a second dimension may represent resources. If a user requests access to a resource, a check of containedness can be performed for the role corresponding to the user and the resource. If the combination of the role and the resource, as a tuple, are included in the multi-dimensional set object, the user may be granted access; otherwise, the user may be denied access. The disclosed subject matter and all of the functional operations described herein can be implemented in digital electronic circuitry, or in computer software, firmware, or hardware, including the structural means disclosed in this specification and structural equivalents thereof, or in combinations of them. The disclosed subject matter can be implemented as one or more computer program products, i.e., one or more computer programs tangibly embodied in an information carrier, e.g., in a machine-readable storage device or in a propagated signal, for execution by, or to control the operation of, data processing apparatus, e.g., a programmable processor, a computer, or multiple computers. A computer program (also known as a program, software, software application, or code) can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. One type of programming language, known as an object oriented programming language, may use classes to define data structures. A class defines the members of an object. Objects are reusable software components. Each object is an instance of a class. Members of a class may include methods, variables, and references. Methods, also known as procedures, functions, and the like, include a series of statements that are compiled and/or executed by a processor and/or virtual machine. Methods may generate a return value, also known as output. Methods can use mechanisms and techniques other than return values to produce output, including mechanisms that cause information to be written to a file, displayed on a display device, or sent over a network. Methods are invoked by a function call. A function call specifies the method name and may provide arguments that a called method can manipulate. Constructors are a special type of method that initializes an object and/or generates an instance of an object. Variables, also known as parameters, attributes, and the like, can be assigned a value. Variables may be constant, such that the assigned value need not change during the execution of a program, or dynamic, such that the assigned value may change during the execution of a program. Variables can be of any data type, including character, integer, float, packed integer, and user-defined class. Variables can also be in the form of a reference-type variable, known as a pointer. A reference need not be a variable, and can be used to reference a variable. In other programming languages, or types of programming languages, programming constructs other than a class may represent data structures. A computer program does not necessarily correspond to a file. A program can be stored in a portion of a file that holds other programs or data, in a single file dedicated to the program in question, or in multiple coordinated files (e.g., files that store one or more modules, sub-programs, or portions of code). A computer program can be deployed to be executed on one computer or on multiple computers at one site or distributed across multiple sites and interconnected by a communication network. The processes and logic flows described herein, including the method steps of the disclosed subject matter, can be performed by one or more programmable processors executing one or more computer programs to perform functions of the disclosed subject matter by operating on input data and generating output. The processes and logic flows can also be performed by, and apparatus of the disclosed subject matter can be implemented as, special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application-specific integrated circuit). Processors suitable for the execution of a computer program include, by way of example, both general and special purpose microprocessors, and any one or more processors of any kind of digital computer. Generally, a processor will receive instructions and data from a read-only memory or a random access memory or both. The essential elements of a computer are a processor for executing instructions and one or more memory devices for storing instructions and data. Generally, a computer will also include, or be operatively coupled to receive data from or transfer data to, or both, one or more mass storage devices for storing data, e.g., magnetic, magneto-optical disks, or optical disks. Information carriers suitable for embodying computer program instructions and data include all forms of non-volatile memory, including by way of example semiconductor memory devices, e.g., EPROM, EEPROM, and flash memory devices; magnetic disks, e.g., internal hard disks or removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The processor and the memory can be supplemented by, or incorporated in special purpose logic circuitry. To provide for interaction with a user, the disclosed subject matter can be implemented on a computer having a display device, e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor, for displaying information to the user and a keyboard and a pointing device, e.g., a mouse or a trackball, by which the user can provide input to the computer. Other kinds of devices can be used to provide for interaction with a user as well; for example, feedback provided to the user can be any form of sensory feedback, e.g., visual feedback, auditory feedback, or tactile feedback; and input from the user can be received in any form, including acoustic, speech, or tactile input. The disclosed subject matter can be implemented in a computing system that includes a back-end component (e.g., a data server), a middleware component (e.g., an application server), or a front-end component (e.g., a client computer having a graphical user interface or a Web browser through which a user can interact with an implementation of the disclosed subject matter), or any combination of such back-end, middleware, and front-end components. The components of the system can be interconnected by any form or medium of digital data communication, e.g., a communication network. Examples of communication networks include a local area network (“LAN”) and a wide area network (“WAN”), e.g., the Internet. The computing system can include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. Although the methods of Although a few implementations have been described in detail above, other modifications are possible. For example, although a certain representation of sets as set objects has been illustrated, modifications can be made to the representations. As another example, although bit vectors and bit arrays are used throughout the description to describe the data structure that may represent set objects, similar structures may be used to store partition sets. For example, the bit data type of a programming need not be used and a vector of integers may be used where a scheme for interpreting those integers appropriately may be devised. Other implementations may be within the scope of the following claims. Patent Citations
Non-Patent Citations
Referenced by
Classifications
Rotate |