Parallel random sampling

[0001] Relational databases are used for storage and retrieval of information. The information is structured in the database as two-dimensional tables of rows and columns. A column heading designates the type of data stored in each column.

[0002] Users are able to access the database information typically by using database management software. The database storage media, management software, and other hardware and software components together make up a database management system, or DBMS. The database management software provides specialized commands for accessing and manipulating the database information. Such commands are according to a standard database-query language, such as a Structured Query Language (SQL).

[0003] Traditionally, a DBMS processes queries in batch mode. In other words, a user wanting to extract information from the database would submit a query, wait some amount of time during which no feedback is provided, and then receive an answer.

[0004] It is increasingly common for a DBMS to present progressively refined intermediate results to a query during processing of the query. The intermediate results are displayed typically along with a “confidence” factor. For accurate intermediate results, random sampling is used. However, in a parallel DBMS having multiple nodes, randomness may be lost if one node produces a result (in response to a query) faster than another node. This may lead to a skewing of results so that intermediate results are more likely to have a low confidence factor.

[0005] In general, an improved method and apparatus of performing parallel random sampling (such as parallel simple random sampling) in a parallel database system is provided. For example, a database system comprises a plurality of nodes, with each node having a storage for storing tuples of a relation. Each node also includes a controller adapted to generate random numbers, with the controller adapted to further determine a number of random samples to generate using the random numbers.

[0006] Other or alternative features will become apparent from the following description, from the drawings, and from the claims.

[0013] In the following description, numerous details are set forth to provide an understanding of the present invention. However, it will be understood by those skilled in the art that the present invention may be practiced without these details and that numerous variations or modifications from the described embodiments may be possible.

[0014] According to some embodiments, a parallel simple random sampling algorithm is implemented that fully utilizes the parallelism of a relational database management system (RDBMS). The parallel simple random sampling algorithm is performed by a random sampling routine, which uses a first random number generator and a second random number generator. The first random number generator generates the seeds for the second random number generator. In a parallel database system having a plurality of data server nodes, the second random number generator is executed at each data server node. In this way, the random numbers used to obtain random sample tuples are generated on all data server nodes in parallel, which leads to efficient generation of random sample tuples from tables in the database.

[0015] Random sampling is used in a variety of database applications. For many query operations, processing an entire data set is either unnecessary or too expensive to perform. By randomly sampling data elements in the data set, response time and resource usage may be lessened. In one example, random samples are used to obtain more accurate intermediate results for display in response to a query. However, random sampling can be used in other applications.

[0016] A population may be sampled according to different sampling principles. In a simple random sample, each member of the population being sampled has an equal chance of being selected. In a stratified random sample, the population is divided into groups and random samples are taken from each group. The following discussion refers to simple random samples. However, principles described herein for simple random sample techniques may be applied to other types of random sampling techniques.

[0017] A shared-nothing parallel RDBMS 100 with L (L being an integer number) data server nodes 10 is depicted in FIG. 1, according to one example. Each of the nodes 10 includes a processor (or plural processors) 26 for executing programs such as database management software. In general, the database management software is responsible for managing access to and manipulation of data (stored in one or more tables).

[0018] One of the programs executable by each processor 26 is a random sampling routine 16. In one embodiment, the random sampling routine 16 is executed on each node 10 of the system 100. The random sampling routine 16 produces random sample tuples that may be used during query processing. FIG. 1 shows the random sampling routine 16 running in each of the plural nodes 10. In another embodiment, the random sampling routine 16 can run in some (two or more) of the plural nodes 10.

[0019] Each node 10 further includes a storage module 24 for storing tuples, or rows, of relations, or tables, within the parallel RDBMS 100. A “storage module” refers to one or plural storage devices. The storage modules 24 in one arrangement are part of a storage subsystem, such as a disk array system. Alternatively, the storage modules 24 are part of multiple storage subsystems. A relation 20 including N₁+N₂+ . . . +N_L tuples 14 is depicted in FIG. 1. Variable N_i represents the number of tuples of the relation 20 stored on each node i.

[0020] In one embodiment, the relation 20 that is stored on all the nodes 10 has a total of $N=\sum _{i=1}^L{N}_i$
tuples. For each 1<i<L, node i stores N_i tuples of the relation 20. The random sampling routines 16 obtain a total of M randomly sampled tuples from the N tuples of the relation 20.

[0021] In one embodiment, the random sampling routines 16 use respective arrays 12, as depicted in FIG. 1, to obtain the M random sample tuples. For each 1≦i≦L, an array A_i of L elements is stored in the respective storage module 24 in each node i. For example, array A_i includes elements A_i1, A_i2, . . . , A_iL. The initial value for each array element is 0.

[0022] In one embodiment, the random sampling routine 16 includes two random number generators G₁ and G₂, as shown in FIG. 2. G₂ is different from G₁. The random number generators G₁ and G₂ are actually pseudo-random number generators. The random number generator G₁ generates L random numbers S₁, S₂, . . . s_L, one for each node i (1≦i≦L). The random number generator G₂ that is executed in each of the nodes 10 uses the respective one of s₁, s₂, . . . s_L as a seed to generate M_i random numbers at each node i. Thus, at node i, random number generator G₂ receive random number s_i to generate random numbers r₁, r₂, . . . , r_Mi.

[0023] In one embodiment, the random number generator G₁ is executed in one node of the parallel RDBMS. The random number generator G₂, however, is executed on all N nodes i of the parallel RDBMS (1≦i≦L).

[0024] In the example of FIG. 3, the random number generator G₁ is executed on node h (1≦h≦L), to produce random numbers s₁, s₂, . . . , s_L. These random numbers are sent to respective ones of the L nodes. Thus, random number s, is sent to node 1, s₂ is sent to node 2, . . . , and s_L is sent to node L. At each node i, Mi random numbers are generated. Thus, a total M random numbers are generated, where M=M₁+M₂+ . . . +M_L.

[0025] The total number of random numbers M to be generated are determined in a number of ways. For example, an arbitrary number of random numbers may be obtained. Alternatively, the number of random numbers to be generated may be a percentage of the total number of tuples in the parallel RDBMS 100.

[0026] In one embodiment, the number of random numbers sought (M) is divided by the number of nodes in the parallel RDBMS, such that the generation of random numbers is distributed across all nodes, not just generated by a single or a few nodes. If the total number is not evenly divided among the number of nodes, some nodes may generate more random numbers than others. The distributed generation of random numbers is illustrated in FIG. 3, where in node i, the random number generator G₂ receives seed s_i to generate M_i random numbers.

[0027] In one embodiment, at each node i, Mi random numbers are obtained using the following formula: $M_i=\left\{\begin{array}{cc}t+1& \left(1\le i\le k\right)\\ t& \left(k+1\le i\le L\right)\end{array}\right\},$
given M=tL+k (0≦k≦L−1), such that $M=\sum _{i=1}^L{M}_i.$

[0028] In one embodiment, once the M random numbers from the second random number generator G₂ are obtained, each node i uses its array A_i to “characterize” the random numbers. The array A has elements whose values are set based on the random numbers r from the second random number generator G₂. The random numbers obtained each have a value between 1 and N, where N is the total number of tuples of the relation 20 in the parallel RDBMS 100.

[0029] One procedure for characterizing the random numbers M_i at a node i is depicted in FIG. 4. According to one embodiment, at each node i, M_i random numbers are counted. The elements of array Ai are incremented to count the occurrences of random numbers within predetermined ranges. The elements of each array Ai are named A_i1, A_i2, . . . , A_iL. For example, array A₁, shown in node 1, includes elements A₁₁, A₁₂ , . . . , A_1L.

[0030] At each node i, a count of the random numbers between a first range is maintained in A_i1, a count of the random numbers between a second range is maintained in A_i2, and so on until all random numbers with values between 1 and N are counted.

[0031] In one embodiment, the predetermined ranges of values for the random numbers is defined as follows:

• • [0032] for each 1≦i≦L, define $B_i=\sum _{j=1}^i{N}_j.$
    Define B₀=0.

[0033] In FIG. 4, for example, the range is partitioned into portions 1 to B₁, B₁ to B₂, B₂ to B₃, and . . . , B_L-1 to N. If a value of a random number is between 1 and B₁, array element A_i1 is incremented by one. If the random number is between B₁ and B₂, array element A_i2 is incremented by one, and so forth. Generally, if a random number r is between B_j-1 and B_j, array element A_ij is incremented by one.

[0034] Thus, as a random number is generated, an element A_ij of array A_i is incremented. Because M may be large, storing M random numbers places a relatively heavy burden on the DBMS. By incrementing an array element A_ij immediately upon generating a random number, the random number may be discarded so that permanent storage of the random number can be avoided. Instead of storing the M random numbers, a count of the random numbers occurring in each node is stored instead, which can greatly reduce the amount of fit data to store.

[0035] Once the array elements A_ij have been incremented in response to the generated random numbers R, the elements A_ij are distributed among the nodes 10 of the parallel RDBMS 100, as depicted in FIG. 5. Array element A_ij is sent from node i to node j. Thus, at node 1, array element A₁₁ stays in node 1, array element A₁₂ is sent to node 2 and array element A_1L is sent to node L. At node 2, array element A₂₁ is sent to node 1, array element A₂₂ stays in node 2, and array element A_2L is sent to L. This procedure is implemented independently at all L nodes.

[0036] Once all the array elements have been redistributed among the nodes, a sum P_i is created to represent a sum of all the array elements received at node i. The sum P_i is a sum of array elements A_1i+A_2i+ . . . +A_Li. Sums P₁, P₂, . . . and P_L are shown in FIG. 5.

[0037] In one embodiment, the sum P_i of the array elements A_ij determines the number of random sample tuples to be obtained from the relation 20 at node i. Recall that node i includes N_i tuples of the relation 20. In one embodiment, P_i random sample tuples are obtained from the N_i tuples. The sum of all the P_is in the parallel RDBMS 100 equals M. This may be shown by the following equation: $P_j=\sum _{i=1}^L{A}_{\mathrm{ij}}.$
From there, the following is derived: $\sum _{j=1}^L{P}_j=\sum _{j=1}^L\sum _{l=1}^L{A}_{\mathrm{ij}}=\sum _{i=1}^L\sum _{j=1}^L{A}_{\mathrm{ij}}=\sum _{i=1}^L{M}_i=M.$

[0038] A process of generating random numbers according to an embodiment is shown in FIG. 6. From the N available tuples, a portion or percentage M of random sample tuples is sought. This number M is divided by the number of nodes (L) in the parallel RDBMS 100 (block 302). In one embodiment, a nearly equal number of random numbers is generated at each node of the parallel RDBMS 100. Where L does not divide evenly into M, some nodes may generate more random numbers than others.

[0039] At one of the nodes of the parallel RDBMS 100, the random number generator G₁ is used to generate L random numbers s₁, S₂, . . . , and s_L (block 304). As noted above, the random number generator G₁ is actually a pseudo-random number generator, in which a predetermined sequence of random numbers is generated. This predetermined sequence may be modified by changing the seed of the random number generator G₁.

[0040] In one embodiment, each random number seed s_i is sent to node i (block 306). Thus, each node of the parallel RDBMS 100 receives one of the random number seeds. Subsequent operations in FIG. 6 are performed at each node in parallel.

[0041] At each node i, using seed s_i, the second random number generator G₂ (which is also a pseudo-random number generator) is used to obtain more random numbers with values between 1 and N, where N equals the total number of tuples in the parallel a RDBMS 100. At node i, in one embodiment, M_i random numbers are generated (block 308), where $M=\sum _{i=1}^L{M}_i.$

[0042] As described above and as shown in FIGS. 4 and 5, each of the random numbers is evaluated or classified according to where in the range of 1 to N the random number falls. Accordingly, elements of the array A_i at each node are incremented based upon the value of each random number (block 310). Once all the random numbers have been evaluated, the array elements are distributed among the nodes of the parallel RDBMS, as in FIG. 5 (block 312). A sum, P_i, is generated at each node i, where P_i equals the sum of the incoming array elements (block 314) at each node i.

[0043] In one embodiment, the sum P_i is the number of random sample tuples to be obtained from the node i. Accordingly, P_i random sample tuples are obtained from the N_i tuples that are stored in the relation 20 at node i (block 316).

[0044] The following describes one example technique of obtaining P_i random sample tuples in node i, which stores N_i tuples. Assume the N_i tuples are made up of tuples x to x+(Ni−1). A random number generator (separate from G₁ or G₂) is used to generate P_i random numbers in the range between x and x+(N_i−1). The Pi random numbers are used as indices to select P_i random samples from the N_i tuples.

[0045] Generally, the parallel random sampling mechanism discussed herein includes using random number generators to generate, in parallel, random numbers in each of the plural nodes in a parallel database system, and using the random numbers to determine how many random samples from a table portion in each node to provide. In one arrangement, a plurality of ranges are defined, and the number of occurrences of random numbers in each of the ranges is counted. This is then used to determine the number of random samples to provide in each node. By distributing the work across plural nodes, a more efficient random sampling mechanism is provided.

[0046] The various devices and systems discussed each includes various software routines or modules, such as the random sampling routines 16. Such software routines or modules are executable on corresponding control units or processors. Each control unit or processor includes a microprocessor, a microcontroller, a processor module or subsystem (including one or more microprocessors or microcontrollers), or other control or computing devices. As used here, a “controller” refers to a hardware component, software component, or a combination of the two. Although used in the singular sense, a “controller” can also refer to plural hardware components, plural software components, or a combination thereof.

[0047] Instructions of the software routines or modules are stored in storage units, which include one or more machine-readable storage media for storing data and instructions. The storage media include different forms of memory including semiconductor memory devices such as dynamic or static random access memories (DRAMs or SRAMs), erasable and programmable read-only memories (EPROMs), electrically erasable and programmable read-only memories (EEPROMs) and flash memories; magnetic disks such as fixed, floppy and removable disks; other magnetic media including tape; and optical media such as compact disks (CDs) or digital video disks (DVDs). The instructions when executed by a respective control unit or processor cause a corresponding device or system to perform programmed acts.

[0048] The instructions of the software routines or modules are loaded or transported to each device or system in one of many different ways. For example, code segments including instructions stored on floppy disks, CD or DVD media, a hard disk, or transported through a network interface card, modem, or other interface device are loaded into the device or system and executed as corresponding software routines or modules. In the loading or transport process, data signals that are embodied in carrier waves (transmitted over telephone lines, network lines, wireless links, cables, and the like) communicate the code segments, including instructions, to the device or system. Such a carrier waves are in the form of electrical, optical, acoustical, electromagnetic, or other types of signals.

[0049] While the invention has been disclosed with respect to a limited number of embodiments, those skilled in the art will appreciate numerous modifications and variations therefrom. It is intended that the appended claims cover such modifications and variations as fall within the true spirit and scope of the invention.