System and method for performing query operations on run length encoded data

Abstract

A method, computer program product, and computing system for processing query operations on run length coded (RLE) data in a parallel processing computing system. Receiving, at the parallel processing computing system, data for query execution, at least a portion of the data being compressed according to the RLE, thereby forming RLE data; and under the condition that the decompression operation is not executed on the RLE data, the query operation is executed on the RLE data.

Description

Systems and methods for performing query operations on run-length encoded data Background Technology

[0001] Graphics Processing Units (GPUs) are highly parallel processors designed to handle thousands of tasks simultaneously. This makes them particularly well-suited for tasks that can be parallelized, such as graphics rendering, scientific simulations, and certain types of machine learning computations. GPUs have become crucial in the fields of deep learning and artificial intelligence (AI). Many deep learning frameworks leverage the parallel processing capabilities of GPUs to accelerate the training of neural networks. In some situations, GPUs are superior to Central Processing Units (CPUs) due to their parallel processing capabilities, where complex tasks can be broken down into smaller, more manageable parts that can be processed simultaneously, while CPUs, with their more general-purpose architecture, are suitable for a wide variety of tasks but may be less efficient in highly parallel computing.

[0002] Compared to CPUs, GPUs have significantly limited device memory, which in turn limits the amount of data they can process simultaneously. Furthermore, when data for query operations is transferred from the CPU to the GPU for processing, it is typically done via the PCIe bus, which has limited bandwidth and can become a bottleneck in the transfer between the CPU and GPU. These limitations restrict the amount of data a GPU can process when performing query operations on large datasets. Attached Figure Description

[0003] Figure 1 is a diagram illustrating the conversion of raw uncompressed data runs into RLE data runs;

[0004] Figure 2 is a diagram illustrating the conversion of raw, uncompressed data runs into hybrid raw / indexed data runs;

[0005] Figure 3 illustrates the conversion of raw, uncompressed data runs into hybrid RLE / indexed data runs;

[0006] Figure 4 is a graphical representation of converting several raw uncompressed data runs into a corresponding number of hybrid RLE / indexed data runs;

[0007] Figure 5 is a depiction of the RLE format portion of column 120b in Figure 4;

[0008] Figure 6 is a depiction of the index format portion of column 120b in Figure 4;

[0009] Figure 7 is a flowchart illustrating the process of performing a query operation on RLE data without decompressing the data;

[0010] Figure 8 is a depiction of the execution of the function according to the implementation of this disclosure;

[0011] Figure 9 is a depiction of the execution of the function according to the implementation of this disclosure;

[0012] Figure 10 is a depiction of the execution of a function according to an implementation of this disclosure;

[0013] Figure 11 is a depiction of the execution of the group-by function according to the implementation of this disclosure;

[0014] Figure 12 is another depiction of the execution of a function according to an implementation of this disclosure; and

[0015] Figure 13 depicts the deentanglement process of a computer system coupled with a distributed computing network and an audio signal.

[0016] The same reference numerals in the accompanying drawings indicate the same elements. Detailed Implementation

[0017] As will be discussed in more detail below, the implementation of this disclosure is designed to accelerate query operations on compressed data in a GPU. However, it should be understood that the implementation is also applicable to operations supporting computational backends that support massively parallel processing, such as GPUs, tensor processors, CPUs with hundreds or even dozens of cores, etc. As discussed below, the data on which the query operation is performed is compressed before being transmitted to the GPU. In the implementation of this disclosure, run-length encoding (RLE) is used to compress the data. Due to its high compression ratio, RLE data is smaller than the original representation size, which not only saves space but also speeds up processing. This helps alleviate the PCIe bottleneck mentioned above, thereby contributing to improved processing speed. Furthermore, the query is performed while the data is still in a compressed state. Because the data is not decompressed before the query operation, the GPU is able to process larger datasets given the GPU's memory constraints compared to if the data needed to be decompressed before processing.

[0018] Structured Query Language (SQL) is a domain-specific language used to manage and manipulate relational databases. SQL is widely used to interact with relational databases, and its syntax is standardized, but specific database management systems (DBMS) may vary.

[0019] In the implementation of this disclosure, run-length encoding (RLE) is used to compress the data. RLE is a form of data compression in which a sequence of identical elements (runs) is replaced with a single element and the number of times that element is repeated or the start and end positions of that element within the run. This technique is often used to reduce the size of data with repeating patterns and is particularly efficient when long sequences of identical values ​​exist. By using RLE to compress data, the implementation of this disclosure can process larger datasets at a much faster speed than previously possible.

[0020] Figure 1 shows examples of the uncompressed “raw” form of a query data run (at 10) and the same data run compressed in RLE form (at 12). As shown at 10, the data run comprises 7 positions (0-6) in a tensor, where the value “1” occupies positions 0-3 and the value “2” occupies positions 4-6. A tensor is an array or vector of values ​​that can also be labeled with other attributes, such as the device in which the tensor resides. While the tensor examples discussed herein are one-dimensional, it is understood that multi-dimensional tensors can be handled in the described implementation. When compressed using run-length encoding (RLE) (as shown at 12), repeated values ​​are represented in a single position in the “value” tensor, and the start and end positions are represented in the “start” and “end” tensors, respectively. As shown at position 12, the first position of the value tensor includes the value "1", the first position of the start tensor includes position "0" (where the value "1" begins), and the first position of the end tensor includes position "3" (where the value "1" ends). This indicates that the value "1" occupies the run from position "0" to position "3". Similarly, the second position of the value tensor includes the value "2", the second position of the start tensor includes position "4" (where the value "2" begins), and the second position of the end tensor includes position "6" (where the value "2" ends). This indicates that the value "2" occupies the run from position "4" to position "6".

[0021] To enable efficient GPU operation, it is preferable to convert data to a compressed form whenever possible. However, in some cases, simply following a compression scheme (such as RLE) without considering the actual values ​​being compressed can result in data runs being computationally more expensive than necessary. For example, if a data run consists of many consecutive, non-repeating values, compression with RLE will not provide any memory or speed advantage for that part of the run. Examples of methods for converting such data to a more computationally efficient format will be described below.

[0022] Figure 2 shows an example of the query data run in its uncompressed raw form at position 14 and an example of the same data run in a mixed raw and indexed form at position 16. As shown at position 14, this data run comprises 6 positions (0-5) in a tensor, where the value "1" occupies position 0, the value "2" occupies position 1, the value "3" occupies position 2, the value "1" occupies position 3, and the value "10" occupies position 4. 10 "Occupies position 4 and has a value of 9" 10"Occupies position 5. Because the values ​​of the data in positions 4 and 5 are very large (called "outliers" due to their disproportionately large size), the entire run requires a 64-bit integer (int64), which will increase processing overhead (increase memory and processing time) when the query is executed."

[0023] A hybrid representation of the original form of run 14 is shown at position 16. In this representation, the low-order values ​​"1", "2", "3", and "1" at positions 0, 1, 2, and 3 remain in their original form. This allows the run to require only 8-bit integers. The values ​​previously at positions 4 and 5 are stored in index form, which includes a value tensor and an index tensor. As shown, the first position of the value tensor includes the value "10". 10 The second position includes the value "9". 10 The first position of the index tensor includes position 4, and the second position includes position 5. This corresponds to the position of each value in the original format data run 14. The original and indexed forms 16 consist of 3 tensors, which reduces computational overhead compared to the original form 14.

[0024] Figure 3 shows an example of the uncompressed raw form of the query data run at 18 and an example of the same data run in the mixed RLE and index form at 20. As shown at 18, the data run consists of 7 positions (0-6) in the tensor, where the value "1" occupies positions 0 to 3, the value "2" occupies position 4, the value "3" occupies position 5, and the value "4" occupies position 6.

[0025] The mixing of the original data run 18 is shown at 20. When compressed using run-length encoding (RLE) (as shown at 20), repeating values ​​are represented in a single value position of the "value" tensor, and the start and end positions are represented in the "start" and "end" tensors, respectively. However, in this example, only the value "1" repeats in positions 0-3, while positions 4, 5, and 6 contain different values. Since only the value "1" repeats in this data run, RLE is used to compress only this repeating sequence, because encoding a single non-repeating value would require more memory (value, start, and end tensors) than index-based encoding, which only requires the value and position. As shown at 20, a single position in the RLE value tensor includes the value "1", a single position in the start tensor includes position 0 (where the value "1" begins), and a single position in the end tensor includes position 3 (where the value "1" ends). This means that the value "1" occupies the run from position 0 to position 3. The values ​​“2”, “3” and “4” are indexed such that “2” is indexed to position 4, “3” is indexed to position 5, and “4” is indexed to position 6.

[0026] Figure 4 graphically depicts the formula for RLE and index-based hybrid encoding, which is based on raw data and described with reference to Figure 3. Box 100 includes multiple data columns 120a, 122a, 124a, 126a, 128a, and 130a. In each column, light gray boxes indicate the number of times a single value is repeated, while dark gray boxes each indicate a single instance of one or more non-repeating values. As shown in column 120a, box 104 represents the number of times the value "b" is repeated, box 106 represents the number of times the value "h" is repeated, and box 108 represents the number of times the value "i" is repeated. Box 110 each represents a single instance of a value or multiple single instances of different values. The light gray and dark gray boxes in columns 122a to 130a represent data of a similar form.

[0027] Box 102 depicts the same data as in Box 100, but after it has been encoded with reference to the hybrid RLE / index format described in Figure 3. Column 120b represents the data values ​​of column 120a in the hybrid encoded format. As shown in box 132 of column 120b, the data in column 120a that includes repeating values ​​(“b”, “h”, and “i”) is represented by a single representation of that value, and has the start and end positions of the repeating runs. This corresponds to the RLE representation shown in Figure 5, where the value “b” starts at position X1 and ends at position Y1; the value “h” starts at position X2 and ends at position Y2; and the value “i” starts at position X3 and ends at position Y3.

[0028] Box 134 in column 120b lists the index values ​​of the non-repeating data in column 120a, as shown in box 110. Similar to the example shown in Figure 3, the values ​​in box 110 are indicated by "m" at position Z1 and "n" at position Z2, as shown in Figure 6. The data included in columns 122a to 130a are encoded in a similar manner to the data corresponding to columns 120a and 120b.

[0029] Figure 7 is a flowchart 200 illustrating a process for performing a query operation according to an implementation of this disclosure. In step 202, the data table is sorted to optimize the RLE encoding of the data. In one implementation, this sorting is performed using the Parquet storage file format. Parquet is a storage format that enhances the efficiency of data retrieval and analytical queries within a distributed computing environment. As a columnar storage file format, Parquet optimizes the storage and retrieval of large datasets. Its columnar structure allows for more efficient data storage, particularly suitable for analytical queries that often involve accessing specific columns. Parquet supports various compression algorithms, which helps reduce storage requirements and improve query performance. In the context of query processing, Parquet often works in conjunction with distributed data processing engines that support predicate pushdown. This optimization technique allows filtering conditions to be pushed to the storage layer before data retrieval, thereby minimizing the amount of data processed during query execution. Parquet is compatible with popular big data processing frameworks, and its support for schema evolution makes it a preferred solution for storing and querying large-scale datasets. In an alternative implementation, reordering functionality can be applied to in-memory tabular data.

[0030] Then, the selected columns in the table are converted to RLE tensors 204. In one implementation, this conversion is performed at the CPU, and the RLE tensors are transmitted to a parallel processing system via, for example, a PCIe bus, 206. The parallel processing system determines that the selected data columns have been RLE compressed. The parallel processing system receives an SQL query (210), 208. Then, without decompressing the data, the parallel processing system executes a query on the compressed data, 212, and outputs the query results from the processing system, 214. Alternatively, the column-to-RLE conversion can be performed at the parallel processing system. Alternatively, an RLE tensor can be created directly from the Parquet format RLE data without first decoding the data to its original state as an intermediate step, and then converted to a tensor. In one implementation, not all columns are converted to RLE tensors. If the compression ratio is below a pre-selected compression threshold, the data can be encoded as the original data tensor. Furthermore, if outliers (e.g., significantly large data values) or consecutive, non-repeating values ​​are present in the data, a hybrid representation can be created. Therefore, columns can be loaded in raw / RLE / raw+index / RLE+index representation.

[0031] Referring now to Figures 8-12, an example of a query operation performed in an implementation of this disclosure is shown, where the operation is performed without decompressing the RLE data. Figure 8 depicts an example of an AND operation between two RLE data runs. For clarity, in this example, only the start and end data of the RLE data runs are shown, which are used as masks for the data to be processed in the AND operation. Input 302 is an RLE format mask showing the first value from position 1 to position 3; the second value from position 4 to position 5; and the third value from position 6 to position 8. The second input 304 is also an RLE format mask with values ​​from position 2 to position 7. Performing an AND function on inputs 302 and 304 requires determining the common range of positions that the two masks have. As shown in Figure 8, there are three common ranges between inputs 302 and 304, which are the output of query 306. Output 306 is the RLE mask, which includes the value from position 2 to position 3; the value from position 4 to position 5; and the value from position 6 to position 7.

[0032] Figure 9 illustrates the specific steps involved in determining the output mask 306 based on RLE inputs 302 and 304. First, the number of overlaps between the two sets of ranges is determined. As shown, when the first range of mask 2 304 is compared in parallel with the three ranges of mask 1 302, three overlaps are determined between the two sets of ranges. Once the number of overlaps is determined, the start and end positions of the overlaps are calculated. As shown at 310, the first range 304 of mask 2 is compared with each of the three ranges 302 of mask 1. Since the first range of mask 2 spans positions 2 to 7, and the first range of mask 1 spans positions 1 to 3, the first overlap spans from position 2 to position 3. Since the first range of mask 2 spans positions 2 to 7, and the second range of mask 1 spans positions 4 to 7, the second overlap spans from position 4 to position 5. Since the first range of mask 2 spans positions 2 to 7, and the third range of mask 1 spans positions 6 to 8, the third overlap spans from position 6 to position 7. The final output mask is shown at position 306.

[0033] In another example, the intersection operation between two RLE tensors can be performed in a similar manner. The intersection operation can be used to transform two input RLE tensors (which can have different numbers of runs and / or different run start and end positions) into two output RLE tensors that have the same number of runs and are aligned at the same start and end positions. For example, if column 1 is represented as: value ['a', 'b'], start: [1, 6], end: [5, 10], and column 2 is represented as: value [2.5, 10, 13.7], start: [1, 3, 8], end: [2, 7, 10], then the intersection of column 1 and column 2 will have two output results: (1) the first output result corresponding to column 1 is represented as: value: ['a', 'a', 'b', 'b'], start: [1, 3, 6, 8], end: [2, 5, 7, 10]; (2) the second output result corresponding to column 2 is represented as: value: [2.5, 10, 10, 13.7], start: [1, 3, 6, 8], end: [2, 5, 7, 10]. Because the alignment run in the intermediate results allows operations on the RLE data without decompressing the RLE data, the intersection operation can be used as an intermediate step for many operations.

[0034] Figure 10 illustrates the specific steps for determining output 406 based on the OR operation between RLE inputs 402 and 404. Mask 1, range 1, includes the first value occupying positions 1 to 3, the second value occupying positions 4 and 5, and the third value occupying positions 6 to 8. Mask 2, range 2, includes the first value occupying positions 2 to 7 and the values ​​occupying positions 1 to 8. The OR operation on inputs 402 and 404 produces the union of two ranges, i.e., output 406, which includes the values ​​from the first position to the eighth position.

[0035] Figure 11 illustrates the specific steps for determining the grouped aggregation output 506 based on the RLE grouping input 502 and the RLE aggregation input 504. The grouping input 502 includes the value "1" at positions 1 to 10, the value "2" at positions 21 to 30, and the value "1" at positions 41 to 50. Although this aggregation example uses a summation function, other aggregation functions such as min, max, count, average, etc., can also be performed. Furthermore, while this example shows only a single grouping column and a single aggregation column, it should be understood that similar functions involving multiple columns for one or more inputs are also within the scope of this disclosure.

[0036] When performing the operation, the intersection of the grouping range and the aggregation range is first determined. As shown at 508, the range intersection includes the value "1" at positions 6 to 10, the value "2" at positions 21 to 30, and the value "1" at positions 41 to 45. For each range, the aggregation value 510 is "3", and the product sum 512 is determined by multiplying the value "3" by the number of positions in each range. Thus, the sum 512a of "15" is obtained by multiplying the aggregation value "3" by the number of positions (5) in range 6-10; the sum 512b of "30" is obtained by multiplying the aggregation value "3" by the number of positions (10) in range 21-30; and the sum 512c of "15" is obtained by multiplying the aggregation value "3" by the number of positions (5) in range 41-45. Using these values, the scatter sum 514 is determined by adding the product sums corresponding to each grouping value. Therefore, the sum of the products corresponding to group value "1", 512a and 512c, is 30, and the sum of the products corresponding to group value "2", 514b, is also 30. Therefore, the output 506 includes the group value 516 and the total value 518.

[0037] Figure 12 illustrates an example of an AND operation between index value 602 and RLE data run value 604 to obtain output mask 606. As shown, index input 602 includes values ​​at positions 4 and 9. RLE input 604 includes values ​​from positions 2 to 5, plus another value at positions 7 and 8. Figure 8 is a graphical representation of inputs 602 and 604, showing the positions of the data values ​​relative to each other. At a higher level, it can be seen that index value "4" falls within the RLE position range 2-5, while index value "9" falls outside the RLE position range 7-8. At 610, index positions 4 and 9 are compared with RLE start positions 2 and 7 to determine which index positions are after the start positions. In this example, both index positions 4 and 9 fall after RLE start positions 2 and 7. Therefore, both of these index values ​​are still eligible to be included in the output mask. At 612, index positions 4 and 9 are compared with RLE end positions 5 and 8 to determine which index positions are before the end positions. In this example, index position 4 falls before the RLE end position 5, but index position 9 falls after the RLE end position 8. Based on operations 610 and 612, a mask 616 is generated, where the value corresponding to index position 4 is true ("T"), and the value corresponding to index position 9 is false ("F"). When mask 616 is applied to index value 602, the resulting output 606 is position 4.

[0038] As described above, implementations of this disclosure include systems and processes for performing query operations on run-length encoded data using a parallel processing computing system (such as a GPU) without first decompressing the data. Because compression reduces the size of the data to be processed, the operation can be made more efficient, and the computing system can process more data with lower latency. While specific examples of operations have been described in detail, it will be understood that many other query operations can be performed on RLE data in a similar manner without decompressing the RLE data before processing. Examples of such operations include, but are not limited to: NOT operators, comparison operators, arithmetic operators, grouping operators, aggregation operators, set operators (including but not limited to intersection, union, membership, complement, and deduplication), and join operators (including but not limited to many-to-many joins, one-to-many join optimizations, and many-to-one joins). System Overview:

[0039] Referring to Figure 13, an RLE query procedure 10 is illustrated. The RLE query procedure 10 can be implemented as a server-side procedure, a client-side procedure, or a hybrid server-side / client-side procedure. For example, the RLE query procedure 10 can be implemented as a pure server-side procedure via a computational cost reduction procedure 10s. Alternatively, the RLE query procedure 10 can be implemented as a pure client-side procedure via one or more of RLE query procedures 10c1, 10c2, 10c3, and 10c4. Alternatively, the RLE query procedure 10 can be implemented as a hybrid server-side / client-side procedure via a combination of RLE query procedure 10s and one or more of RLE query procedures 10c1, 10c2, 10c3, and 10c4.

[0040] Therefore, the RLE query process 10 used in this disclosure may include any combination of RLE query process 10s, RLE query process 10c1, RLE query process 10c2, RLE query process 10c3 and RLE query process 10c4.

[0041] The RLE query process 10s can be a server application and can reside on and be executed by a computer system 1000, which can be connected to a network 1002 (e.g., the Internet or a local area network). The computer system 1000 can include various components, examples of which may include, but are not limited to: personal computers, server computers, a series of server computers, minicomputers, mainframes, one or more network-attached storage (NAS) systems, one or more storage area network (SAN) systems, one or more platform-as-a-service (PaaS) systems, one or more infrastructure-as-a-service (IaaS) systems, one or more software-as-a-service (SaaS) systems, cloud-based computing systems, and cloud-based storage platforms.

[0042] A SAN includes one or more of the following: personal computers, server computers, a range of server computers, minicomputers, mainframe computers, RAID devices, and NAS systems. The various components of the computer system 1000 can run one or more operating systems.

[0043] The instruction set and subroutines of the computational cost reduction process 10s can be stored on a storage device 1004 coupled to the computer system 1000, and can be executed by one or more processors (not shown) and one or more memory architectures (not shown) included within the computer system 1000. Examples of storage device 1004 may include, but are not limited to: hard disk drives; RAID devices; random access memory (RAM); read-only memory (ROM); and all forms of flash storage devices.

[0044] Network 1002 can be connected to one or more secondary networks (e.g., network 1004), examples of which may include, but are not limited to, local area networks (LANs), wide area networks (WANs), or corporate intranets.

[0045] Various I / O requests (e.g., I / O request 1008) may be sent to computer system 1000 from RLE query process 10s, RLE query process 10c1, RLE query process 10c2, RLE query process 10c3 and / or RLE query process 10c4. Examples of I / O request 1008 may include, but are not limited to, data write requests (i.e., requests to write content to computer system 1000) and data read requests (i.e., requests to read content from computer system 1000).

[0046] The instruction sets and subroutines of the RLE query procedures 10c1, 10c2, 10c3, and / or computational cost reduction procedures 10c4, which can be stored on storage devices 1010, 1012, 1014, and 1016 coupled to client electronic devices 1018, 1020, 1022, and 1024, can be executed by one or more processors (not shown) and one or more memory architectures (not shown) incorporated into client electronic devices 1018, 1020, 1022, and 1024, respectively. Storage devices 1010, 1012, 1014, and 1016 can include, but are not limited to: hard disk drives; optical drives; RAID devices; random access memory (RAM); read-only memory (ROM); and all forms of flash memory. Examples of client electronic devices 1018, 1020, 1022, and 1024 may include, but are not limited to: personal computing devices 1018 (e.g., smartphones, personal digital assistants, laptops, and desktop computers), audio input devices 1020 (e.g., handheld microphones, lavalier microphones, in-set microphones (such as those embedded in glasses, smartphones, tablets, and / or watches), and audio recording devices), display devices 1022 (e.g., tablets, computer monitors, and smart TVs), hybrid devices (e.g., a single device that includes one or more of the devices described above; not shown), audio rendering devices (e.g., speaker systems, headphone systems, or earphone systems; not shown), and dedicated network devices (not shown).

[0047] Users 1026, 1028, 1030, and 1032 can access computer system 1000 directly through network 1002 or through secondary network 1006. Furthermore, computer system 1000 can be connected to network 1002 through secondary network 1006, as illustrated in link route 1034.

[0048] Various client electronic devices (e.g., client electronic devices 1018, 1020, 1022, and 1024) may be directly or indirectly coupled to network 1002 (or network 1006). For example, personal computing device 1018 is shown as being directly coupled to network 1002 via a hardwired network connection. Furthermore, machine vision input device 1024 is shown as being directly coupled to network 1006 via a hardwired network connection. Audio input device 1022 is shown as being wirelessly coupled to network 1002 via a wireless communication channel 1036 established between audio input device 1020 and wireless access point (WAP) 1038, while WAP 1038 is shown as being directly coupled to network 1002. WAP 1038 may be, for example, IEEE 802.11a, 802.11b, 802.11g, 802.11n, Wi-Fi, and / or any device capable of establishing a wireless communication channel 1036 between audio input device 1020 and WAP 1038. Display device 1022 is shown as being wirelessly coupled to network 1002 via a wireless communication channel 1040 established between display device 1022 and WAP 1042, while WAP 1042 is shown as being directly coupled to network 1002.

[0049] Each client electronic device (e.g., client electronic devices 1018, 1020, 1022, 1024) can execute its own operating system, and the combination of each client electronic device (e.g., client electronic devices 1018, 1020, 1022, 1024) with the computer system 1000 can form a modular system 1044. General Principles:

[0050] As those skilled in the art will understand, this disclosure can be embodied as a method, system, or computer program product. Therefore, this disclosure can take the form of a completely hardware embodiment, a completely software embodiment (including firmware, resident software, microcode, etc.), or a combination of hardware and software embodiments, all of which can be collectively referred to herein as a "circuit," "module," or "system." Furthermore, this disclosure can take the form of a computer program product on a computer-usable storage medium, and computer-usable program code is embodied in that medium.

[0051] Any suitable computer-usable or computer-readable medium may be used. Such a computer-usable or computer-readable medium is, for example, but not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatuses, devices, or transmission media. More specific examples (not an exhaustive list) of computer-readable media may include: electrical connections having one or more wires, portable computer floppy disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disc read-only memory (CD-ROM), optical storage devices, transmission media such as those supporting the Internet or intranets, or magnetic storage devices. A computer-usable or computer-readable medium may also be paper or other suitable media for printing programs, as programs can be captured electronically, for example, by optical scanning of paper or other media, and then compiled, interpreted, or otherwise processed as needed, and finally stored in computer memory. In the context of this document, a computer-usable or computer-readable medium can be any medium capable of containing, storing, communicating, propagating, or transmitting programs for use by or in connection with an instruction execution system, apparatus, or device. Computer-usable media may include data transmission signals containing computer-usable program code in baseband or as part of a carrier wave. Computer-usable program code can be transmitted using any suitable medium, including but not limited to the Internet, wired networks, fiber optic cables, RF, etc.

[0052] Computer program code used to perform the operations of this disclosure can be written in an object-oriented programming language. However, computer program code used to perform the operations of this disclosure can also be written in a traditional procedural programming language, such as C or a similar language. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer can be connected to the user's computer via a local area network (LAN) / wide area network (WAN) / the Internet.

[0053] This disclosure is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this disclosure. It should be understood that each block and combination of blocks in the flowchart illustrations and / or block diagrams can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer / special-purpose computer / other programmable data processing apparatus such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, can produce components for implementing the functions / behaviors specified in the flowchart and / or one or more block diagram blocks.

[0054] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing apparatus to operate in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of art including instruction components that implement the functions / behaviors specified in a flowchart and / or one or more block diagram blocks.

[0055] Computer program instructions can also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be executed on the computer or other programmable apparatus, thereby producing a computer-implemented process. The instructions, which execute on the computer or other programmable apparatus, provide steps for implementing the functions / behaviors specified in the flowchart and / or one or more block diagram blocks.

[0056] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code, comprising one or more executable instructions for implementing a specified logical function(s). It should also be noted that in some alternative implementations, the functions marked in a block may occur in a different order than those marked in the figures. For example, two blocks shown sequentially in the figures may actually be executed substantially simultaneously, or these blocks may sometimes be executed in reverse order, or even not executed at all, or, depending on the functionality involved, may be executed in any combination with any other flowchart. It should also be noted that each block and combination of blocks in the block diagrams and / or flowcharts can be implemented by a dedicated hardware system that performs the specified function or behavior, or a combination of dedicated hardware and computer instructions.

[0057] The terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit this disclosure. As used herein, unless the context clearly indicates otherwise, the singular forms “a,” “an,” and “the” should also include the plural forms. It should be further understood that, when used in this specification, the terms “comprising” and / or “including” specify the presence of the stated features, integers, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or combinations thereof.

[0058] All components or steps plus functional elements in the following claims are intended to include any structure, material, behavior, and equivalent for use in combination with other claim elements included in the specific claim to perform a function. The description in this disclosure is presented for illustration and description purposes and is not intended to be exhaustive or to limit the disclosure to the forms disclosed. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of this disclosure. This embodiment was chosen and described to better explain the principles and practical application of this disclosure and to enable those skilled in the art to understand the various embodiments of this disclosure and various modifications adapted to the particular intended use.

[0059] Several implementations have been described. It will be apparent from the detailed description of the disclosure and its embodiments that modifications and variations are possible without departing from the scope of the disclosure as defined in the appended claims.

Claims

1. A computer-implemented method, executed on a computing device, and comprising: Receive data for query execution at the parallel processing computing system; Determine that at least a portion of the data is compressed according to run-length encoding (RLE) to form RLE data; and perform a query operation on the RLE data without performing a decoding operation on the RLE data.

2. The computer implementation method according to claim 1, wherein the query operation includes a logical AND function.

3. The computer implementation method according to claim 1, wherein the query operation includes a logical OR function.

4. The computer implementation method according to claim 1, wherein the query operation includes a grouping function.

5. The computer implementation method according to claim 1, wherein the query operation includes multiple parameters, at least one parameter is the RLE data, and at least one parameter adopts one of the following: index format, original format, or RLE hybrid format.

6. The computer implementation method according to claim 2, wherein the query operation includes multiple parameters, at least two of which are compressed using RLE to generate at least two RLE parameters.

7. The computer implementation method according to claim 6 further includes determining the range intersection between the at least two RLE parameters.

8. A computing system, comprising: Memory; And a processor, the processor being configured to: sort a data table to optimize the encoding of data according to run-length encoding (RLE); Convert at least one data column in a data table into RLE data; receive an SQL query operation at a parallel processing computing device; execute the SQL query operation on the RLE data in its compressed state; and output the result of the execution of the query operation.

9. The computing system according to claim 8, wherein the query operation includes a logical AND function.

10. The computing system of claim 8, wherein the query operation includes a logical OR function.

11. The computing system according to claim 8, wherein the query operation includes a grouping function.

12. The computing system of claim 8, wherein the query operation includes at least two parameters, at least one parameter being the RLE data, and at least one parameter employing one of the following: an index format, a raw format, or a hybrid RLE format.

13. The computing system of claim 9, wherein the query operation includes a plurality of parameters, at least two of which are compressed using RLE to generate at least two RLE parameters.

14. The computing system of claim 13, further comprising determining the range intersection of the at least two RLE parameters.

15. A computer program product residing on a non-transitory computer-readable medium, the non-transitory computer-readable medium storing a plurality of instructions, the plurality of instructions causing the processor to perform operations when executed by a processor, the operations including: The system receives data for query execution at a parallel processing computing system, at least a portion of which is compressed according to run-length encoding (RLE) to form RLE data; and performs a query operation on the RLE data without performing a decompression operation on the RLE data.

Images