Abstract:
A system joins predicate evaluated column bitmaps having varying lengths. The system includes a column unifier for querying column values with a predicate and generating an indicator bit for each of the column values that is then joined with the respective column value. The system also includes a bitmap generator for creating a column-major linear bitmap from the column values and indicator bits. The column unifier also determines an offset between adjacent indicator bits. The system also includes a converter for multiplying the column-major linear bitmap with a multiplier to shift the indicator bits into consecutive positions in the linear bitmap.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application is a continuation of U.S. patent application Ser. No. 13/614,625, filed on Sep. 13, 2012 and entitled, “A Multiplication-Based Method for Stitching Results of Predicate Evaluation in Column Stores,” which is incorporated in its entirety herein. 
     
    
     BACKGROUND 
       [0002]    There are generally two methods used in computing for storing multidimensional arrays in linear memory: row-major ordering, and column-major ordering. Identifying the correct layout is important for processing the array because the manner in which a computer program traverses the linear array depends on the method used to generate the array. 
         [0003]    In row-major ordering, a multidimensional array is stored so that rows are positioned one after the other. For example, a simple two dimensional array such as 
         [0000]    
       
         
           
               
             
               
                 
                   1 
                 
                 
                   2 
                 
                 
                   3 
                 
               
               
                 
                   4 
                 
                 
                   5 
                 
                 
                   6 
                 
               
             
           
         
       
     
         [0000]    is stored linearly as [1 2 3 4 5 6]. Conversely, when stored in column-major ordering, the two dimensional array is stored as [1 4 2 5 3 6]. 
         [0004]    Column-major layout has emerged as a common scheme for organizing data in data warehouses because this layout results in reduced IO requirements for queries. This is because each query needs to scan only the columns that it references. However, stitching together the results of operations over individual columns is complicated by the column-major layout. 
         [0005]    For example, assume that: (1) a column A is encoded using a 10-bit dictionary code and is stored linearly as 25 values in a 256-bit word, with 6 bits of padding; and (2) a column B is encoded with a 9-bit code stored linearly as a 14 values in a 128-bit word with 2 bits of padding. If one were to run a query with conditions (predicates) of A&lt;5 and B=10, one can very efficiently compute the answers of the predicates on columns A and B separately (i.e., separately compute the list of records satisfying A&lt;5, and satisfying B=10). 
         [0006]    However, it is very inefficient to combine the results of the query on A and B. Currently methods for combining the results of the queries include either: (1) extracting the results for A and B into separate bitmaps by applying a separate shift and mask for each tuple and then forming a bitwise-AND of the results; or (2) performing Streaming SIMD Extensions (SSE) shuffle instructions to expand both columns to occupy, for example, four entries of a 128-bit word and then doing a bitwise-AND of the resultant words. A further difficulty with either of these methods is that the query results must all be bitmaps that are positionally aligned with each other. Stated differently, the i&#39;th bit of the query result of column A must be for the same record as the i&#39;th bit of the query result for column B. 
       SUMMARY 
       [0007]    Embodiments of a system are described. In one embodiment, the system joins predicate evaluated column bitmaps having varying lengths. The system may include a column unifier for querying column values with a predicate and generating an indicator bit for each of the column values that is then joined with the respective column value. The system also includes a bitmap generator for creating a column-major linear bitmap from the column values and indicator bits. The column unifier also determines an offset between adjacent indicator bits. The system also includes a converter for multiplying the column-major linear bitmap with a multiplier to shift the indicator bits into consecutive positions in the linear bitmap. Other embodiments of the system are also described. 
         [0008]    Embodiments of a method are also described. In one embodiment, the method includes querying a plurality of column values with a predicate, generating an indicator bit for each of the plurality of column values based on the predicate and joining each of the plurality of column values with the respective indicator bit, and generating a column-major linear bitmap from the plurality of column values and respective indicator bits. The method may also include determining an offset between adjacent indicator bits, and multiplying the column-major linear bitmap with a multiplier to shift the indicator bits into consecutive positions in the linear bitmap. Other embodiments of the method are also described. 
         [0009]    Other aspects and advantages of embodiments of the present invention will become apparent from the following detailed description, taken in conjunction with the accompanying drawings, illustrated by way of example of the principles of the invention. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0010]      FIG. 1  is a schematic block diagram illustrating one embodiment of predicate evaluation using a column unifier. 
           [0011]      FIG. 2  is a schematic block representation of the column unifier. 
           [0012]      FIG. 3  is a schematic flow chart diagram illustrating one embodiment of a method for column-stitching in column stores. 
           [0013]      FIG. 4  is a high level block diagram showing an information processing system  400 . 
       
    
    
     DETAILED DESCRIPTION 
       [0014]    It will be readily understood that the components of the embodiments as generally described herein and illustrated in the appended figures could be arranged and designed in a wide variety of different configurations. Thus, the following more detailed description of various embodiments, as represented in the figures, is not intended to limit the scope of the present disclosure, but is merely representative of various embodiments. While the various aspects of the embodiments are presented in drawings, the drawings are not necessarily drawn to scale unless specifically indicated. 
         [0015]    The present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by this detailed description. All changes which come within the meaning and range of equivalency of the claims are to be embraced within their scope. 
         [0016]    Reference throughout this specification to features, advantages, or similar language does not imply that all of the features and advantages that may be realized with the present invention should be or are in any single embodiment of the invention. Rather, language referring to the features and advantages is understood to mean that a specific feature, advantage, or characteristic described in connection with an embodiment is included in at least one embodiment of the present invention. Thus, discussions of the features and advantages, and similar language, throughout this specification may, but do not necessarily, refer to the same embodiment. 
         [0017]    Furthermore, the described features, advantages, and characteristics of the invention may be combined in any suitable manner in one or more embodiments. One skilled in the relevant art will recognize, in light of the description herein, that the invention can be practiced without one or more of the specific features or advantages of a particular embodiment. In other instances, additional features and advantages may be recognized in certain embodiments that may not be present in all embodiments of the invention. 
         [0018]    Reference throughout this specification to “one embodiment,” “an embodiment,” or similar language means that a particular feature, structure, or characteristic described in connection with the indicated embodiment is included in at least one embodiment of the present invention. Thus, the phrases “in one embodiment,” “in an embodiment,” and similar language throughout this specification may, but do not necessarily, all refer to the same embodiment. 
         [0019]    While many embodiments are described herein, at least some of the described embodiments coalesce bits of interest in predicate evaluated bitmaps into consecutive positions so that a bitwise AND of the bitmaps results in a combined bitmap of individually evaluated columns. Coalescing or shifting the bits of interest (or indicator bits) is a result of multiplying the bitmap with a multiplier selected according to the offset between the bits of interest and then performing a bitwise AND on the multiplied bitmap with a mask. 
         [0020]      FIG. 1  is a schematic block diagram illustrating one embodiment of predicate evaluation using a column unifier  100 . The column unifier  100  is configured to utilize multiplications to combine results from predicate evaluations on individual columns in a column store  102 . Arrows in  FIG. 1  graphically represent the flow of data from the column store  102  to the column unifier to a bitmap  106   a ,  106   b , and finally to a bitmap with indicator bits  108  in consecutive positions  112 . 
         [0021]    In a column store  102 , or column-oriented database management system, content is stored in a column-major order as compared to row-major order. Although a database management system displays the content of a database as a two-dimensional table, a computing device must store the two-dimensional table as a one-dimensional series of bytes for storage in RAM, a hard disk drive, or both. 
         [0022]    In the column store  102 , the entries are stored as linear vectors by column. For example, the column A  104  is stored as ColA={value1, value2, value3, value4, value5}. Conversely, in a row-major order system, table entries are stored linearly as Row1={value1, value100}, Row2={value2, value101}, etc. Column-major ordering has advantages for data warehouses where aggregates are computed over large numbers of similar data items. 
         [0023]    To evaluate a predicate (condition) in a query, predicates are evaluated on values in each column separately to form a query-result bit-vector or bitmap  106   a - b  for each column. The column unifier  100  generates the query-result bitmaps  106   a ,  106   b  with an indicator bit  108  for each entry in the column. In the depicted embodiment, the indicator bits  108  are represented by the letters P, Q, R, S, and T. Each indicator bit  108  may represent whether a column entry satisfies the predicate or condition of the query. For example, if the predicate is “ColA&gt;5,” the column unifier  100  evaluates the entries in column A  104  and generates the bitmap  106   a  with the indicator bits  108  representing whether each entry satisfies the predicate. In other words, if “value1” of column A  104  is greater than “5,” the indicator bit P is set to “1,” for example. It is important to note that although arrows indicate one example of how the column unifier may evaluate the columns of the column store, the computation of bitmaps  106   a ,  106   b  may be done separately. 
         [0024]    Before the column unifier  100  can combine the results of the bitmaps  106   a ,  106   b  using a bitwise operation, the bitmaps  106   a ,  106   b  must be positionally aligned. Stated differently, the bit of bitmap  106   a  must correlate to the same row entry as the i&#39;th bit of bitmap  106   b . To accomplish this, the column unifier  100  is configured to determine an offset  110  between indicator bits  108  and multiply the bitmap with a multiplier selected according to the offset  110  to shift the indicator bits  108  to consecutive positions  112 . The multipliers will be described in greater detail below with reference to  FIG. 2 . 
         [0025]      FIG. 1  illustrates a graphical representation of consecutive positions  112  with the indicator bits  108  shifted to the beginning of the bitmap  106   a  or  106   b . As used herein, the phrase “consecutive position” refers to indicator bits  108  positioned consecutively without intervening non-indicator bits. In other words, the indicator bits  108  are grouped together. The indicator bits  108  may be shifted to the beginning of the bitmap  106   a ,  106   b , to the end of the bitmap  106   a ,  106   b , or to any position within the bitmap  106   a ,  106   b.    
         [0026]      FIG. 2  is a schematic block representation of the column unifier  100  described above in  FIG. 1 . The column unifier  100  includes a bitmap generator  202 , a converter  204 , and a bitwise operator  206 . The column unifier  100 , in one embodiment, is configured to query entries in a column store. The unifier  100 , in one example, queries the entries in the column-store by evaluating columns independently of each other. The query may include a predicate or condition. The bitmap generator  202  is configured to generate a linear bitmap  106  containing the column entries and an indicator bit for each column entry. The indicator bit  108  identifies whether the column entry satisfies the query. In one example, the indicator bit is set to a value of 1 if the column entry satisfies the predicate, and a 0 otherwise. The indicator bit may be appended or prepended to the column entry. One example of a bitmap  106  is given above with reference to  FIG. 1 . 
         [0027]    The converter  204  is configured to multiply the query-result bitmap  106  with a multiplier to shift the indicator bits into consecutive positions in the linear bitmap  106 . The converter  204  accomplishes this by multiplying the query-result bitmap with a multiplier M. In a further embodiment, the multiplication is followed by the bitwise operator  206  performing a bitwise AND with a mask S. In yet another embodiment, the column unifier  100  may then combine the results of multiple query-result bitmaps by performing a bitwise AND because, despite different offsets (or column entry sizes), the indicator bits of each query-result bitmap are coalesced together into consecutive positions. 
         [0028]    The multiplier M and the mask S, in one embodiment, are equations preselected according to the offset that when applied to a query result bitmap result in indicator bits being shifted into consecutive positions. Examples of the multiplier M and mask S will now be given by way of example only and are not intended to limit the disclosure to these examples. One of skill in the art will recognize that other equations may be selected that, when performed by the converter  204 , shift the indicator bits into consecutive positions. 
         [0029]    In one embodiment, where the offset k is greater than or equal to 8, the operations performed by the column unifier  100  may be represented by the following pseudo-code: 
         [0000]    
       
         
               
               
             
           
               
                   
               
             
             
               
                 1. 
                 Inputs: 
               
               
                 2. 
                  A: query-result bitmap 
               
               
                 3. 
                  k: offset 
               
               
                 4. 
                  j: k - 1 
               
               
                 5. 
                  M = 1 + 2 j  + 2 2j  + ... 2 (floor(64/k)-1)j   
               
               
                 6. 
                  S = 2 64  − 2 floor(64/k)   
               
               
                 7. 
                   
               
               
                 8. 
                 (A * M) &amp; S 
               
               
                   
               
             
          
         
       
     
         [0030]    Where the offset is greater than or equal to 4 and less than 8, the operations performed by the column unifier may be represented by the following pseudo-code: 
         [0000]    
       
         
               
               
               
             
           
               
                   
               
             
             
               
                   
                  1. 
                 Inputs: 
               
               
                   
                  2. 
                  A: query-result bitmap 
               
               
                   
                  3. 
                  k: offset 
               
               
                   
                  4. 
                  j: k − 1 
               
               
                   
                  5. 
                  m = k 2 -k 
               
               
                   
                  6. 
                  n = k 2   
               
               
                   
                  7. 
                  M1 = 1 + 2 j  + 2 2j  + ... 2 (k-1)j   
               
               
                   
                  8. 
                  S1 = 2 64  − 2 64-k  + 2 64-n  − 2 64-n-k  + 2 64-2n  − 2 64-2n-k  + 2 64-3n  − 2 64-3n-k  + ... (until 
               
               
                   
                   
                 exponents are less than 0) 
               
               
                   
                  9. 
                  M2 = 1 + 2 m  + 2 2m  + ... 2 (ceil(64/n-1)m   
               
               
                   
                 10. 
                  S2 = 2 64  − 2 (floor(64/k))   
               
               
                   
                 11. 
                   
               
               
                   
                 12. 
                 ((( A * M1 ) &amp; S1 ) * M2 ) &amp; S2 
               
               
                   
               
             
          
         
       
     
         [0031]    Where the offset is equal to 3, the operations performed by the column unifier may be represented by the following pseudo-code: 
         [0000]    
       
         
               
               
               
             
           
               
                   
               
             
             
               
                   
                  1. 
                 Inputs: 
               
               
                   
                  2. 
                  A: query-result bitmap 
               
               
                   
                  3. 
                  k: offset 
               
               
                   
                  4. 
                  j: k − 1 
               
               
                   
                  5. 
                  m = k 2 -k 
               
               
                   
                  6. 
                  n = k 2   
               
               
                   
                  7. 
                  M1 = 1 + 2 j  + 2 2j  + ... 2 (k-1)j   
               
               
                   
                  8. 
                  S1 = 2 64  − 2 64-k  + 2 64-n  − 2 64-n-k  + 2 64-2n  − 2 64-2n-k  + 2 64-3n  − 2 64-3n-k  + ... (until 
               
               
                   
                   
                 exponents are less than 0) 
               
               
                   
                  9. 
                  M2 = 1 + 2 m  + 2 2m  + ... 2 (ceil(64/n-1)m   
               
               
                   
                 10. 
                  S2 = 2 64  − 2 (floor(64/k))   
               
               
                   
                 11. 
                  M3 = 1 + 2 18  +2 36   
               
               
                   
                 12. 
                  S3 = 2 64  − 2 64-9  + 2 64-27  − 2 64-36  + 2 64-54  − 2 64-63   
               
               
                   
                 13. 
                   
               
               
                   
                 14. 
                 ((((( A * M1 ) &amp; S1 ) * M2 ) &amp; S2) &amp; S3 ) * M3 
               
               
                   
               
             
          
         
       
     
         [0032]    Where the offset is equal to 2, the operations performed by the column unifier may be represented by the following pseudo-code: 
         [0000]    
       
         
               
               
               
             
           
               
                   
               
             
             
               
                   
                 13.  
                 Inputs: 
               
               
                   
                 14. 
                  A: query-result bitmap 
               
               
                   
                 15. 
                  k: offset 
               
               
                   
                 16. 
                  j: k − 1 
               
               
                   
                 17. 
                  m = k 2 -k 
               
               
                   
                 18. 
                  n = k 2   
               
               
                   
                 19. 
                  M1 = 1 + 2 j  + 2 2j  + ... 2 (k-1)j   
               
               
                   
                 20. 
                  S1 = 2 64  − 2 64-k  + 2 64-n  − 2 64-n-k  + 2 64-2n  − 2 64-2n-k  + 2 64-3n  − 2 64-3n-k  + ... (until 
               
               
                   
                   
                 exponents are less than 0) 
               
               
                   
                 21. 
                  M2 = 1 + 2 m  + 2 2m  + ... 2 (ceil(64/n-1)m   
               
               
                   
                 22. 
                  S2 = 2 64  − 2 (floor(64/k))   
               
               
                   
                 23. 
                  M3 = 17 
               
               
                   
                 24. 
                  S3 = 0xF0F0F0F0F0F0F0F0 
               
               
                   
                 25. 
                  M4 = 257 
               
               
                   
                 26. 
                  S4 = 0xFF00FF00FF00FF00 
               
               
                   
                 27. 
                  M5 = 65537 
               
               
                   
                 28. 
                  S5 = 0xFFFF0000FFFF0000 
               
               
                   
                 29. 
                   
               
               
                   
                 30. 
                 ((((((((( A*M1 ) &amp; S1 ) *M2 ) &amp; S2) &amp; S3 ) *M3 ) &amp; S4 ) *M4 ) &amp; S5 ) *M5 
               
               
                   
               
             
          
         
       
     
         [0033]    Where the offset is equal to 1 no multiplications are necessary. 
         [0034]      FIG. 3  is a schematic flow chart diagram illustrating one embodiment of a method for column-stitching in column stores. The method begins and, in one example, the column unifier  100  determines  302  multipliers M and masks S. Determining  302  or identifying multipliers M and masks S, in one embodiment, includes identifying or pre-selecting equations that when performed by the converter  204  shift indicator bits into consecutive positions as described above. 
         [0035]    The column unifier  100  then queries  304  a column and generates a linear bitmap having an indicator bit for each column entry. The bitmap, as described above with reference to  FIG. 1 , is a column-major bitmap  106   a ,  106   b  with indicator bits  108  separated by an offset  110 . The offset may correspond to the length of the column entry. The column unifier  100  then determines  306  an offset between the indicator bits (most significant bits). 
         [0036]    The converter  204  then multiplies  308  the bitmap with one of the multipliers M according to the identified offset. In one embodiment, the converter  204  multiplies the bitmap with a single multiplier M. In alternative embodiments, the converter  204  multiplies the bitmap with a series of multipliers M, and a bitwise AND with a mask S after each multiplication. 
         [0037]    The bitwise operator  206  then performs  310  a bitwise AND with the multiplied query-result bitmap. As described above with reference to  FIG. 3 , the application of multipliers M and masks S depends on the offset, and different combinations of multipliers M and masks S may be selected according to the offset. For example, when the offset is greater than or equal to 8, the multiplier is the equation M=1 where 2 j +2 2j + . . . 2 (floor(64/k)−1)j  where j=k−1 and the mask is the equation S=2 64 −2 floor(64/k) . The result of the multiplication of the query-result bitmap A followed by a bitwise AND with the mask S will result in a bitmap having indicator bits shifted to consecutive positions. 
         [0038]    When the offset is greater than or equal to 4 and less than 8, the column unifier  100  shifts the indicator bits into consecutive positions by: multiplying the linear bitmap with the multiplier M1=1+2 j +2 2j + . . . 2 (k−1)j ; performing the bitwise AND of the linear bitmap with the mask S1=2 64 −2 64−k +2 64−n −2 64−n−k +2 64−2n −2 64−2n−k +2 64−3n −2 64−3n−k + . . . (until exponents are less than 0); multiplying the linear bitmap with a second multiplier M2=1+2 m +2 2m + . . . 2 (ceil(64/n−1)m  and performing a bitwise AND of the linear bitmap with a second mask S2=2 64 −2 (floor(64/k)) . 
         [0039]    If the offset is equal to 3, the column unifier  100  shifts the indicator bits into consecutive positions by first performing the steps when the offset is greater than or equal to 4 and less than 8, then performing: performing a bitwise AND of the linear bitmap with a third mask S3=2 64 −2 64−9 +2 64−27 −2 64−36 +2 64−54 −2 64−63;  and multiplying the linear bitmap with a third multiplier M3=1+2 18 2 36 . 
         [0040]    If the offset is equal to 2, the column unifier  100  shifts the indicator bits into consecutive positions by first performing the steps when the offset is greater than or equal to 4 and less than 8, then performing: the operation (((((linear bitmap &amp; S3)*M3) &amp; S4)*M4) &amp; S5)*M5); where S3=0xF0F0F0F0F0F0F0F0, M3=17, S4=0xFF00FF00FF00FF00, M4=257, S5=0xFFFF0000FFFF0000u11, M5=65537, j=k−1, m=k 2−k , and n=k 2 . 
         [0041]    The above multiplications and AND operations will result in a bitmap for each column of the column store. Each bitmap will include indicator bits shifted into consecutive positions, and as such, the various bitmaps may be “stitched” together easily regardless of the length of the bitmaps because the indicator bits are aligned to consecutive positions at the beginnings, for example, of each bitmap. The multipliers M and masks S may be applied as shown, or alternatively in any order that causes the indicator bits to coalesce or shift into consecutive positions within the bitmap as a result of a multiplication. 
         [0042]      FIG. 4  is a high level block diagram showing an information processing system  400 . The system  400  includes one or more processors, such as processor  402 . The processor  402  is connected to a communication infrastructure  404  (e.g., a communications bus, cross-over bar, or network). Various software embodiments are described in terms of this exemplary computer system. After reading this description, it will become apparent to a person of ordinary skill in the relevant art(s) how to implement the invention using other computer systems and/or computer architectures. 
         [0043]    The computer system can include a display interface  406  that forwards graphics, text, and other data from the communication infrastructure  404  (or from a frame buffer not shown) for display on a display unit  408 . The computer system also includes a main memory  410 , preferably random access memory (RAM), and may also include a secondary memory  412 . The secondary memory  412  may include, for example, a hard disk drive  414  and/or a removable storage drive  416 , representing, for example, a floppy disk drive, a magnetic tape drive, or an optical disk drive. The removable storage drive  416  reads from and/or writes to a removable storage unit  418  in a manner well known to those having ordinary skill in the art. Removable storage unit  418  represents, for example, a floppy disk, a compact disc, a magnetic tape, or an optical disk, etc. which is read by and written to by removable storage drive  416 . As will be appreciated, the removable storage unit  418  includes a computer readable medium having stored therein computer software and/or data. 
         [0044]    In alternative embodiments, the secondary memory  412  may include other similar means for allowing computer programs or other instructions to be loaded into the computer system. Such means may include, for example, a removable storage unit  420  and an interface  422 . Examples of such means may include a program cartridge and cartridge interface (such as that found in video game devices), a removable memory chip (such as an EPROM, or PROM) and associated socket, and other removable storage units  420  and interfaces  422  which allow software and data to be transferred from the removable storage unit  420  to the computer system. 
         [0045]    The computer system may also include a communications interface  424 . Communications interface  424  allows software and data to be transferred between the computer system and external devices. Examples of communications interface  424  may include a modem, a network interface (such as an Ethernet card), a communications port, or a PCMCIA slot and card, etc. Software and data transferred via communications interface  424  are in the form of signals which may be, for example, electronic, electromagnetic, optical, or other signals capable of being received by communications interface  424 . These signals are provided to communications interface  424  via a communications path (i.e., channel). This communications path carries signals and may be implemented using wire or cable, fiber optics, a phone line, a cellular phone link, an RF link, and/or other communications channels. 
         [0046]    In this document, the terms “computer program medium,” “computer usable medium,” and “computer readable medium” are used to generally refer to media such as main memory  410  and secondary memory  412 , removable storage drive  416 , and a hard disk installed in hard disk drive  414 . 
         [0047]    Computer programs (also called computer control logic) are stored in main memory  410  and/or secondary memory  412 . Computer programs may also be received via communications interface  424 . Such computer programs, when executed, enable the computer system to perform the features of the present invention as discussed herein. In particular, the computer programs, when executed, enable the processor  402  to perform the features of the column unifier  100 . Accordingly, such computer programs represent controllers of the computer system. 
         [0048]    In the above description, specific details of various embodiments are provided. However, some embodiments may be practiced with less than all of these specific details. In other instances, certain methods, procedures, components, structures, and/or functions are described in no more detail than to enable the various embodiments of the invention, for the sake of brevity and clarity. 
         [0049]    Although specific embodiments of the invention have been described and illustrated, the invention is not to be limited to the specific forms or arrangements of parts so described and illustrated. The scope of the invention is to be defined by the claims appended hereto and their equivalents. 
         [0050]    An embodiment of a system includes at least one column unifier  100  coupled directly or indirectly to memory elements through a system bus such as a data, address, and/or control bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution. 
         [0051]    It should also be noted that at least some of the operations for the methods may be implemented using software instructions stored on a computer useable storage medium for execution by a computer. As an example, an embodiment of a computer program product includes a computer useable storage medium to store a computer readable program that, when executed on a computer, causes the computer to perform operations, including an operation to join query-result bitmaps in a column-major column store. 
         [0052]    Although the operations of the method(s) herein are shown and described in a particular order, the order of the operations of each method may be altered so that certain operations may be performed in an inverse order or so that certain operations may be performed, at least in part, concurrently with other operations. In another embodiment, instructions or sub-operations of distinct operations may be implemented in an intermittent and/or alternating manner. 
         [0053]    Embodiments of the invention can take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment containing both hardware and software elements. In one embodiment, the invention is implemented in software, which includes but is not limited to firmware, resident software, microcode, etc. 
         [0054]    Furthermore, embodiments of the invention can take the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer readable medium can be any apparatus that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device. 
         [0055]    The computer-useable or computer-readable medium can be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device), or a propagation medium. Examples of a computer-readable medium include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk, and an optical disk. Current examples of optical disks include a compact disk with read only memory (CD-ROM), a compact disk with read/write (CD-R/W), and a digital video disk (DVD). 
         [0056]    Input/output or I/O devices (including but not limited to keyboards, displays, pointing devices, etc.) can be coupled to the system either directly or through intervening I/O controllers. Additionally, network adapters also may be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modems, and Ethernet cards are just a few of the currently available types of network adapters.