Method for performing progressive query processing and system thereof

Abstract

The purpose of the present invention is to provide a method for performing progressive query processing and a system thereof, the method being capable of obtaining all of an approximate result value, a fast response speed, and an accurate result value with a single query by searching all sub-partitions of a partition table in the form of a progressive query after converting a user query into a partition-based progressive query.

Description

Method and system for performing incremental query processing

[0001] The present invention relates to a method and system for performing incremental query processing, and more particularly, to a method capable of providing accurate results while ensuring a fast response speed by performing a partition-based incremental query for a user query.

[0002]

[0003] The material described in this section merely provides background information on one embodiment of the present invention and does not constitute prior art.

[0004] Approximate query DBMS technology, which enables rapid query processing of data objects, has a problem with queries involving aggregate functions taking a long time to execute. However, users or applications sometimes require rapid response times, even if it's only an approximate value rather than an exact value for a user query.

[0005] Traditionally, approximate query DBMSs were used to derive the necessary approximate results to meet the demand for fast response times. However, users or applications may request accurate results alongside approximate results for user queries, in addition to fast response times.

[0006] At this time, a typical query processing system based on a typical approximate query DBMS first queries the entire table to obtain approximate results, and then queries the entire table again to obtain accurate results. Thus, a typical query processing system must perform two queries—an approximate query and an exact query—to obtain both approximate and accurate results, before it can retrieve and return the values ​​requested by the user or application.

[0007] Conventional approximate query DBMSs cannot achieve accurate results because they perform queries on data modeled through learning across entire tables. To obtain accurate results for user queries, queries must be performed on the entire table containing the data, which hinders fast response times.

[0008] Therefore, to achieve fast response times, approximate queries must be performed on the modeled tables to obtain results. However, these query results are often inaccurate. Furthermore, to obtain accurate results for user queries, precise queries must be performed on the tables containing the entire data. However, this lack of the fast response times that are a key advantage of approximate query DBMSs presents.

[0009]

[0010] The present invention aims to provide a method and system for performing incremental query processing, which can obtain approximate result values, fast response speed, and accurate result values ​​all with a single query, by converting a user query into a partition-based incremental query according to one embodiment of the present invention and then performing a search for all sub-partitions of a partition table in the form of an incremental query, in order to solve the above-mentioned problem.

[0011] However, the technical task that this embodiment seeks to achieve is not limited to the technical task described above, and other technical tasks may exist.

[0012]

[0013] As a technical means for achieving the above-described technical task, an embodiment of the present invention provides a method for performing incremental query processing, which is performed by a system including a query processing engine. The method comprises: a query receiving process for receiving a user query; a query transformation process for transforming the user query into incremental search queries for searching each sub-partition based on at least one sub-partition included in at least one partition table in a partitioned database environment; a query processing process for sequentially searching the sub-partitions using the sub-partition-specific search query to generate query results, performing a query on an integrated result obtained by incrementally integrating preceding query results for each sub-partition to generate intermediate results, and sequentially transmitting the intermediate results to an application; And a query termination process for terminating query processing for the user query after performing the query processing process for all sub-partitions of the partition table; wherein the query processing process integrates the query results for the previous sub-partition and the query results for the current sub-partition to generate an integrated result, generates an aggregate query using aggregate functions based on the integrated result, and provides an alternative query result for the current sub-partition based on the aggregate query as an intermediate result for the current sub-partition.

[0014] Alternatively, the query transformation process provides a partition table matching the user query based on a key value set in the partition table.

[0015] Alternatively, the query processing process passes the query result for the first subpartition of the partition table to the application as an approximate result value.

[0016] Alternatively, the aggregate functions are selected from the group of COUNT, SUM, AVG, MIN, and MAX.

[0017] Alternatively, the query processing process includes: when a search query including an aggregate function of average (AVG) for individual sub-partitions is input, a step of generating an aggregate query by dividing the search query using the aggregate functions of sum (SUM) and count (COUNT); and a step of generating a search result of a sub-partition using the aggregate query as divided query results, and integrating the divided query results to generate an intermediate result of the corresponding sub-partition.

[0018] Alternatively, the query processing process includes the steps of: when a search query including an aggregate function of COUNT for each sub-partition is input, generating individual query results for the search results of each sub-partition using the aggregate function of COUNT; and generating an aggregate result by integrating the individual query results using the aggregate function of SUM, and generating a new aggregate query that performs a sum operation on the aggregate result, and then providing the search result of the sub-partition using the aggregate query as an intermediate result of the sub-partition.

[0019] Alternatively, the query processing process includes, when the partition table includes N sub-partitions, a first step of performing a search on the first sub-partition using a search query on the first sub-partition to generate a first query result and then transmitting the first query result to an application; a second step of performing a search on the second sub-partition using a search query on the second sub-partition to generate a second query result and then integrating the first query result and the second query result to generate an integrated result; a third step of generating an aggregate query based on the integrated result and performing a search on the second sub-partition using the aggregate query to generate an intermediate result and then transmitting the intermediate result to the application; and a fourth step of repeatedly performing the second and third steps for N sub-partitions and transmitting a termination message to the application notifying that query processing for the user query is completed when query processing for all sub-partitions of the partition table is completed.

[0020] As a technical means for achieving the above-described technical task, an embodiment of the present invention provides a system for performing incremental query processing. The system comprises: a database module storing a plurality of partition tables each composed of at least one sub-partition, thereby providing a partitioned database environment; a query transformation module parsing a user query and transforming the user query into an incremental search query based on a sub-partition; and a query processing engine sequentially searching the sub-partitions using the sub-partition-specific search query to generate incremental query results, integrating previous query results to generate intermediate results for each sub-partition, and then sequentially transmitting the intermediate results to an application, wherein the query processing engine integrates query results for a previous sub-partition and query results for a current sub-partition to generate an integrated result, generates an aggregate query based on the integrated result, and provides a result of searching the current sub-partition using the aggregate query as an intermediate result for the current sub-partition.

[0021] Alternatively, the query processing engine includes at least one processor, and the search process is distributed and performed on at least one processor for each partition table.

[0022]

[0023] According to the above-described problem solving means of the present invention, the present invention can obtain a fast response speed by converting a user query into a partition-based incremental query form in a partitioned database environment, thereby providing an approximate result value as an initial query execution result for the first sub-partition of a partition table, and thereafter, by performing a query on an integrated result obtained by incrementally integrating preceding query results for other sub-partitions, thereby finally generating a query result for all sub-partitions of the partition table, thereby providing an accurate result value.

[0024] In addition, the present invention has the effect of enabling a fast query response speed and accurate query results to be obtained in an exploratory data analysis approximate query DBMS technology capable of fast query processing of big data targets.

[0025]

[0026] FIG. 1 is a diagram illustrating the configuration of a system that performs progressive query processing according to one embodiment of the present invention.

[0027] Figure 2 is a block diagram of a query processing engine according to one embodiment of the present invention.

[0028] FIG. 3 is a flowchart illustrating a method for performing incremental query processing according to one embodiment of the present invention.

[0029] Figure 4 is a flowchart showing in detail a query processing process according to one embodiment of the present invention.

[0030]

[0031] Below, embodiments of the present invention are described in detail with reference to the attached drawings so that those skilled in the art can easily implement the present invention. The embodiments presented in the present invention are provided to enable those skilled in the art to utilize or practice the contents of the present invention. Accordingly, various modifications to the embodiments of the present invention will be apparent to those skilled in the art. That is, the present invention can be implemented in various different forms and is not limited to the embodiments described below.

[0032] Throughout the specification of the present invention, identical or similar drawing numbers refer to identical or similar components. Furthermore, for the purpose of clearly explaining the present invention, drawing numbers for parts in the drawings that are not relevant to the description of the present invention may be omitted.

[0033] The term "or" as used herein is intended to mean an inclusive "or" rather than an exclusive "or." That is, unless otherwise specified herein or the meaning is clear from the context, "X utilizes A or B" should be understood to mean either of the natural inclusive permutations. For example, unless otherwise specified herein or the meaning is clear from the context, "X utilizes A or B" can be interpreted to mean either X utilizes A, X utilizes B, or X utilizes both A and B.

[0034] The term "and / or" as used herein should be understood to refer to and include all possible combinations of one or more of the related concepts listed.

[0035] The terms "comprises" and / or "comprising" as used herein should be understood to mean the presence of certain features and / or components. However, it should be understood that the terms "comprises" and / or "comprising" do not exclude the presence or addition of one or more other features, other components, and / or combinations thereof.

[0036] Unless otherwise specified in the present invention or unless the context makes it clear that the singular form is indicated, the singular should generally be construed to include "one or more."

[0037] The term "connection" as used in the present invention should be interpreted to include not only cases where components are "directly connected" but also cases where other components are "present" between them and cases where they are "electrically connected" with other components in between them.

[0038] The term "acquisition" as used in the present invention may be understood to refer to generating or receiving data in an on-device form as well as receiving data via a wireless communication network with an external device or system.

[0039] Meanwhile, the term "module" or "unit" used in the present invention can be understood as a term referring to an independent functional unit that processes computing resources, such as a computer-related entity, firmware, software or a part thereof, hardware or a part thereof, or a combination of software and hardware. At this time, the "module" or "unit" may be a unit composed of a single element, or a unit expressed as a combination or set of multiple elements. For example, as a narrow concept, a "module" or "unit" may refer to a hardware element of a computing device or a set thereof, an application program that performs a specific function of software, a processing process implemented through software execution, or a set of instructions for program execution, etc. In addition, as a broad concept, a "module" or "unit" may refer to the computing device itself that constitutes the system, or an application that runs on the computing device, etc. However, since the above-described concept is only an example, the concept of “module” or “part” can be defined in various ways within a range understandable to those skilled in the art based on the contents of the present invention.

[0040] The explanation of the aforementioned terms is intended to aid understanding of the present invention. Therefore, unless explicitly stated as limiting the scope of the present invention, it should be noted that the aforementioned terms are not intended to limit the technical concept of the present invention.

[0041]

[0042] Hereinafter, an embodiment of the present invention will be described in detail with reference to the attached drawings.

[0043] FIG. 1 is a diagram illustrating the configuration of a system that performs progressive query processing according to one embodiment of the present invention.

[0044] Referring to FIG. 1, the system (100) includes, but is not limited to, a database module (110), a query transformation module (120), and a query processing engine (130).

[0045] The database module (110) stores multiple partition tables each consisting of at least one sub-partition, thereby providing a partitioned database environment.

[0046] When a user query is entered from a user terminal or application, the query transformation module (120) parses the user query and transforms the user query into an incremental search query based on sub-partitions.

[0047] The query processing engine (130) uses a search query for each sub-partition to sequentially search sub-partitions to generate incremental query results, integrates the results of preceding queries to generate intermediate results for each sub-partition, and sequentially transmits the intermediate results generated in this way to the application (200).

[0048] At this time, the query processing engine (130) may include at least one processor, and the search process for a user query may be distributed and performed by at least one processor for each partition table within the database module (110).

[0049] Meanwhile, the query transformation module (120) may be included in the query processing engine (130) or implemented independently, and its implementation method and application technology may be conceived in various forms.

[0050] Accordingly, the application (200) can perform data visualization for analysis by using intermediate results transmitted from the query processing engine (130), or can create a main visualization object for query result visualization and provide the visualization result to the user.

[0051] The system (100) according to one embodiment of the present invention may be a hardware device or a part of a hardware device that performs comprehensive processing and calculation of data, or may be a software-based computing environment connected to a communication network. For example, the system (100) may be a server that performs intensive data processing functions and shares resources, or a client that shares resources through interaction with a server. Furthermore, the system (100) may be a cloud system in which multiple servers and clients interact to comprehensively process data. Since the above description is only one example related to the type of the system (100), the type of the system (100) may be configured in various ways within a range understandable to those skilled in the art based on the contents of the present invention.

[0052] Figure 2 is a block diagram of a query processing engine according to one embodiment of the present invention.

[0053] Referring to FIG. 2, a query processing engine (130) according to one embodiment of the present invention may include a processor (131), a memory (132), and a network unit (133). However, FIG. 2 is merely an example, and thus the query processing engine (130) may include other components for implementing a computing environment. In addition, only some of the disclosed components may be included in the query processing engine (130).

[0054] The processor (131) according to one embodiment of the present invention may be understood as a configuration unit including hardware and / or software for performing computing operations. The processor (131) for performing data processing may include a central processing unit (CPU), a general purpose graphics processing unit (GPGPU), a tensor processing unit (TPU), an application specific integrated circuit (ASICc), or a field programmable gate array (FPGA). The type of the processor (131) described above is only an example, and thus the type of the processor (131) may be configured in various ways within a range understandable to those skilled in the art based on the contents of the present invention. The query processing engine (130) may include one or more processors (131) so as to perform a query processing process for each partition table.

[0055] The memory (132) may be understood as a configuration unit including hardware and / or software for storing and managing data processed by the query processing engine (130). That is, the memory (132) may store any type of data generated or determined by the processor (131) and any type of data received by the network unit (133). For example, the memory (131) may include at least one type of storage medium among a flash memory type, a hard disk type, a multimedia card micro type, a card type memory, a random access memory (RAM), a static random access memory (SRAM), a read-only memory (ROM), an electrically erasable programmable read-only memory (EEPROM), a programmable read-only memory (PROM), a magnetic memory, a magnetic disk, and an optical disk. In addition, the memory (120) may also include a database system that controls and manages data in a predetermined system. The type of memory (132) described above is only one example, and thus the type of memory (132) can be configured in various ways within a range understandable to those skilled in the art based on the contents of the present invention.

[0056] The memory (132) can structure and organize and manage functions and data required for the processor (131) to perform operations, combinations of data, and program codes executable by the processor (131).

[0057] The network unit (133) may be understood as a component that transmits and receives data through any known wired or wireless communication system. For example, the network unit (133) may perform data transmission and reception using a wired or wireless communication system such as a local area network (LAN), wideband code division multiple access (WCDMA), long term evolution (LTE), wireless broadband internet (WIBRO), 5th generation mobile communication (5G), ultra wide-band, Zigbee, radio frequency (RF) communication, wireless LAN, wireless fidelity, near field communication (NFC), or Bluetooth. Since the above-described communication systems are only examples, the wired and wireless communication system for data transmission and reception of the network unit (133) may be applied in various ways other than the above-described examples.

[0058] The network unit (133) can receive data necessary for the processor (131) to perform calculations through wired or wireless communication with any system or any client, etc. In addition, the network unit (133) can transmit data generated through calculations of the processor (131) through wired or wireless communication with any system or any client, etc.

[0059] FIG. 3 is a flowchart illustrating a method for performing incremental query processing according to one embodiment of the present invention.

[0060] Referring to FIG. 3, a method for performing incremental query processing may be comprised of a query receiving process (S10), a query conversion process (S20), and a query processing process (S30), but may also include a process of outputting the results transmitted in the query processing process (S30) to a user terminal from an application (200).

[0061] In the query receiving process (S10S), a user query is received from a user terminal or application.

[0062] In the query transformation process (S20), the user query is transformed into incremental search queries for searching each sub-partition within the partition table. At this time, the query transformation process (S20) can provide a partition table matching the user query based on the key value set in the partition table. Accordingly, when multiple user queries are received, a partition table can be matched to each user query, and the query processing engine (130) can also perform the query processing process in a distributed manner for each partition table.

[0063] The query processing process (S30) uses a search query for each sub-partition to sequentially search sub-partitions to generate incremental query results, integrates the results of preceding queries to generate intermediate results for each sub-partition, and sequentially transmits the intermediate results generated in this way to the application (200). This query processing process (S30) is repeatedly performed according to the number of sub-partitions included in the partition table.

[0064] After the query processing engine (130) performs a query processing process for all sub-partitions of the partition table, it transmits a termination message to the application (200) indicating that query processing for the user query has been completed, and the application (200) outputs a query completion message corresponding to the termination message to the user.

[0065] In this way, the query processing engine (130) performs incremental query processing based on the partition table, and does not perform query processing in cases where the table is not a partition table. In addition, the query processing engine (130) performs one of a group of aggregate functions on the intermediate results for each sub-partition, and at this time, the aggregate functions can be selected from the group of count (COUNT), sum (SUM), average (AVG), minimum (MIN), and maximum (MAX). The query processing engine (130) does not support aggregate functions other than the group of count (COUNT), sum (SUM), average (AVG), minimum (MIN), and maximum (MAX).

[0066] As an example, the following describes how to perform incremental query processing using the aggregate function COUNT.

[0067] When a user query (test) including an aggregate function of COUNT() is input, the query processing engine (130) receives the first subpartition (p1) from the partition table, performs a search for the first subpartition using a search query for the first subpartition, generates a first query result (Result#1), and then transmits the first query result to the application.

[0068] In a general query processing process, when a search process based on a user query is completed for the entire partition table, the query result is transmitted to the application. However, in the present invention, the first query result (Result#1) generated as a search result for the first sub-partition (p1) is immediately transmitted to the application (200) so that the first query result can be output, thereby ensuring a fast response speed while providing the first query result as an approximate result value.

[0069] After outputting the first query result in the application (200), the next query result is requested and waits until the search result is delivered. The query processing engine (130) that received the next result request from the application (200) receives the next second sub-partition (p2) from the partition table. The query processing engine (130) uses the search query for the second sub-partition (p2) to perform a search for the second sub-partition to generate a second query result (Result#2), and then integrates the first query result (Result#1) and the second query result (Result#2) to generate an integrated result (Result#3).

[0070] Afterwards, the query processing engine (130) generates an aggregate query based on the integrated result (Result#3), performs a search on the second sub-partition (p2) using the generated aggregate query, generates an intermediate result (Result#4), and then transmits the intermediate result (Result#4) to the application.

[0071] The query processing engine (130) immediately transmits the first query result (Result#1) to the application (200), but does not transmit subsequent query results to the application (200), and combines the first query result (Result#1) and the second query result (Result#2) to generate an integrated result (Result#3).

[0072] At this time, the query processing engine (130) must generate a new search query for the integrated result (Result#3), but if the search query is generated based on the original aggregate function, distortion of the result may occur. Therefore, the query processing engine (130) can use the aggregate functions MIN(), MAX(), and SUM() among the aggregate functions to generate the query result of the second sub-partition based on the aggregate query for the integrated result (Result#3) to prevent distortion of the result.

[0073] Meanwhile, when using the aggregate functions COUNT() and AVG(), using the aggregate functions MIN(), MAX(), and SUM() in the same way for the consolidated results may result in distorted results.

[0074] Therefore, the query processing engine (130) uses a modified aggregate function to obtain an accurate result value. That is, when using the aggregate function of COUNT(), individual first query results (Result#1) and second query results (Result#2) can be generated for individual sub-partitions, and a new aggregate query (Select sum(num) from (Result#3)) that performs a SUM() operation on the combined result (Result#3) that combines the first and second query results is generated to perform query processing through a search for the second sub-partition. The query processing engine (130) can obtain an accurate result value (Result#4) through the aggregate function of SUM() for query results using the aggregate function of COUNT().

[0075] The query processing engine (130) receives the next third sub-partition (p3) from the partition table, generates a search query for searching the third sub-partition (p3), and searches the third sub-partition (p3) using the search query generated in this manner to generate a third query result (Result#5). At this time, the query processing engine (130) generates an integrated result (Result#6) by combining the integrated result (Result#3) and the third query result (Result#5), and performs a SUM() operation on the integrated result (Result#6) by generating a new aggregate query (Select sum(num) from (Result#6)), and performs query processing through a search for the third sub-partition to generate an intermediate result (Result#7), and transmits the intermediate result generated in this manner to the application.

[0076] In this way, the query processing engine (130) repeatedly performs the S30 and S40 processes on N sub-partitions, and when query processing for all sub-partitions of the partition table is completed, transmits a termination message to the application (200) notifying that query processing for the user query is completed.

[0077] Figure 4 is a flowchart showing in detail a query processing process according to one embodiment of the present invention.

[0078] The query processing process (S30) according to one embodiment of the present invention may include, in detail, steps of generating an aggregate query using an aggregate function, generating and integrating query results, and generating intermediate results.

[0079] When a search query (Select avg(id) from test) including an aggregate function of AVG() is input, the query processing engine (130) generates an aggregate query by dividing the search query (Select sum(id), count(id) from test partition(p1)) that searches for the first subpartition (p1) and the search query (Select sum(id), count(id) from test partition(p2)) that searches for the second subpartition (p2) using the aggregate functions of SUM() and COUNT() (S31, S32, S33).

[0080] The query processing engine (130) performs a search of the first and second sub-partitions using an aggregate query to obtain partitioned query results ((Result#1, Result#2), combines the query results (Result#1, Result#2) configured in a partitioned form to generate an integrated result (Result#3), and generates a new aggregate query (Select sum(id) / count(id) from (Result#3)) using the aggregate function of SUM() / COUNT() when configuring a function to calculate AVG() for the integrated result (Result#3). The query result (Result#4) obtained by performing a search for the second sub-partition (p2) using the aggregate query generated in this way has the same result value as the result performed with the original AVG() aggregate function.

[0081] In this way, the present invention can perform incremental queries based on a partition table for a user query, and sequentially performs queries starting from the first subpartition in the partition table to the last subpartition, so that incremental query processing ends when queries are performed for all subpartitions.

[0082] In the present invention, whenever a query is performed while moving through sub-partitions within a partition table, the query results performed in the sub-partition and the query results performed in the current sub-partition are first integrated, and then the integrated result is query-performed and returned to the user or application as an intermediate result. At this time, the present invention sequentially returns to the user not only the first query result obtained by performing query processing on the first sub-partition but also the intermediate results obtained by performing query processing on the next sub-sub-partition. Therefore, although the first query result obtained by performing a query on the first sub-partition table is not an exact query result, an approximate result value and a fast query response speed can be obtained. In addition, since the present invention ultimately performs a query on all sub-partition tables, the last obtained query result can obtain the same result as the exact result value obtained by performing a query on the entire partition table.

[0083]

[0084] The embodiments of the present invention described above may also be implemented in the form of a recording medium including computer-executable instructions, such as program modules executed by a computer. Such recording medium includes computer-readable media, and computer-readable media can be any available media that can be accessed by a computer, and includes both volatile and nonvolatile media, removable and non-removable media. Furthermore, computer-readable media includes computer storage media, and computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storing information, such as computer-readable instructions, data structures, program modules, or other data.

[0085] The foregoing description of the present invention is for illustrative purposes only, and those skilled in the art will readily appreciate that the present invention can be readily modified into other specific forms without altering the technical spirit or essential characteristics of the present invention. Therefore, the embodiments described above should be understood as illustrative in all respects and not restrictive. For example, each component described as a single entity may be implemented in a distributed manner, and similarly, components described as distributed may be implemented in a combined manner.

[0086] The scope of the present invention is indicated by the claims described below rather than the detailed description above, and all changes or modifications derived from the meaning and scope of the claims and their equivalent concepts should be interpreted as being included in the scope of the present invention.

Claims

1. A method for performing incremental query processing, performed by a system including a query processing engine, Query receiving process for receiving user queries; In a partitioned database environment, a query transformation process for transforming a user query into incremental search queries for searching each sub-partition based on at least one sub-partition contained in at least one partition table; A query processing process that sequentially searches the sub-partitions using the search query for each sub-partition to generate query results, performs a query on the integrated result that gradually integrates the preceding query results for each sub-partition to generate intermediate results, and sequentially transmits the intermediate results to the application; and A query termination process for terminating query processing for the user query after performing the query processing process for all subpartitions of the partition table; including; The above query processing process is: A method of generating an integrated result by integrating a query result for a previous sub-partition and a query result for a current sub-partition, generating an aggregate query using aggregate functions based on the integrated result, and providing an alternative query result for the current sub-partition based on the aggregate query as an intermediate result for the current sub-partition.

2. In paragraph 1, The above query conversion process is, A method of providing a partition table matching the user query based on a key value set in the partition table.

3. In paragraph 1, The above query processing process is: A method of delivering a query result for the first subpartition of the above partition table to an application as an approximate result value.

4. In paragraph 1, The above aggregate functions are, A method that is selected from the group of COUNT, SUM, AVG, MIN, and MAX.

5. In paragraph 4, The above query processing process is: When a search query including an aggregate function of AVG for individual sub-partitions is input, a step of generating an aggregate query by partitioning the search query using the aggregate functions of SUM and COUNT; and A method comprising the steps of generating a search result of a sub-partition using the above aggregate query as divided query results and integrating the divided query results to generate an intermediate result of the corresponding sub-partition.

6. In paragraph 4, The above query processing process is: When a search query including an aggregate function of COUNT for each sub-partition is input, a step of generating individual query results for the search results of each sub-partition through the aggregate function of COUNT; and A method comprising the steps of: integrating individual query results using the aggregate function of SUM to generate an integrated result; generating a new aggregate query that performs a sum operation on the integrated result; and then providing the search result of a sub-partition using the aggregate query as an intermediate result of the sub-partition.

7. In paragraph 1, The above query processing process is: If the above partition table contains N subpartitions, A first step of performing a search on the first sub-partition using a search query on the first sub-partition to generate a first query result and then transmitting the first query result to the application; A second step of generating a second query result by performing a search for the second sub-partition using a search query for the second sub-partition, and then generating a combined result by integrating the first query result and the second query result; A third step of generating an aggregate query based on the above integration result, performing a search on the second sub-partition using the aggregate query to generate an intermediate result, and then transmitting the intermediate result to the application; and A method comprising: repeating steps 2 and 3 for N sub-partitions; and transmitting a termination message to the application indicating that query processing for the user query is completed when query processing for all sub-partitions of the partition table is completed.

8. A system that performs progressive query processing, A database module that provides a partitioned database environment by storing multiple partition tables each consisting of at least one sub-partition; A query transformation module that parses a user query and transforms the user query into a subpartition-based incremental search query; and A query processing engine is included that sequentially searches the sub-partitions using the search query for each sub-partition to generate incremental query results, integrates the preceding query results to generate intermediate results for each sub-partition, and then sequentially transmits the intermediate results to the application. The above query processing engine, A system that generates an integrated result by integrating a query result for a previous sub-partition and a query result for a current sub-partition, generates an aggregate query based on the integrated result, and provides the result of searching the current sub-partition using the aggregate query as an intermediate result for the current sub-partition.

9. In paragraph 8, The above query processing engine, A system comprising at least one processor, wherein a search process for each partition table is distributed and performed on at least one processor.

Images