FIELD OF TECHNOLOGY

The present invention relates to the field of computer technologies, and in particular, to a method and an apparatus for data query.

BACKGROUND

A conventional SQL engine includes a parser/analyzer, an analyzer, an optimizer/planner and an executor. In a conventional SQL sentence execution process, the following steps are involved: a user/client executes an SQL query which goes to the SQL engine for further processing; the parser/analyzer parses an SQL query syntax and decides whether it conforms to a standard; the analyzer checks objects (e.g., tables, columns, etc.) used in an SQL statement which exists in a database, and extracts any bind variable if there are any; the optimizer/planner chooses the best plan tree for query execution based on cost; and the executor creates an execution tree based on the plan tree and then it executes as per the execution tree.

In the above SQL sentence execution process, in one scenario, the execution tree can be reused. Specifically, on first execution, the complete execution tree created to perform the execution is saved in a cursor cache. If the same query gets executed again, the executor reuses the saved execution tree directly. In another scenario, an execution tree cannot be reused. In this case, the execution tree is not saved in the cursor cache after execution. If the same query gets executed again, the SQL engine will generate a new execution tree as it is getting executed first time.

However, the above two cases have the following disadvantages. For the first case, since the complete execution tree has to be saved so it requires lots of storage space of the curser cache, which is a big concern specifically for in-memory database where memory available to store more data is very important. Therefore, it is undesirable to lose so much of memory in order to store the execution tree.

For the second case, since the execution tree is not saved at all, every time the same query gets executed, it will have to create the execution tree from scratch, which will lead to huge performance degradation.

SUMMARY

Embodiments of the present invention provide a method and an apparatus for data query, so as to save a storage space taken by an execution tree in a cursor cache and improve the efficiency of a sentence execution process.

An aspect of the present invention provides a method for data query. A method for data query according to at least some embodiments of the present invention includes: receiving, by a processor, a query request; when a plan tree for the query request and an execution tree for the plan tree exist, and the execution tree is a partial execution tree, reinitializing, by the processor, the partial execution tree to generate a complete execution tree; and retrieving, by the processor, data query result using the complete execution tree.

Another aspect of the present invention provides an apparatus for data query. An apparatus for data query according to at least some embodiments of the present invention includes: a receiving module, configured to receive a query request; a reinitializing module, configured to reinitialize, when a plan tree for the query request and an execution tree for the plan tree exist, and the execution tree is a partial execution tree, the partial execution tree to generate a complete execution tree; and a retrieving module, configured to retrieve data query result using the complete execution tree.

Another aspect of the present invention provides a computer, comprising: a processor and a memory coupled to the processor; wherein the processor is configured to: receive a query request; when a plan tree for the query request and an execution tree for the plan tree exist, and the execution tree is a partial execution tree, reinitialize the partial execution tree to generate a complete execution tree; and retrieve data query result using the complete execution tree.

According to the method and apparatus for data query in embodiments of the present invention, the execution tree is a partial execution tree, and the partial execution tree is reinitialized to generate a complete execution tree, As the partial execution tree takes less memory space than the complete execution tree, compared with the first case in the prior art where the complete execution tree is stored in the curser cache, the storage space taken by the execution tree in the cursor cache can be saved, on the other hand, compared with the second case in the prior art where no execution tree is stored in the curser cache, the performance for data query can be improved because there is no need to generate a new complete execution tree for every new execution. Therefore, compared with conventional data query method, the method and apparatus for data query according to embodiments of the present invention can save the storage space taken by the execution tree in the cursor cache without losing performance which can be beneficial for in-memory systems.

BRIEF DESCRIPTION OF THE ACCOMPANYING DRAWINGS

FIG 1 is a schematic diagram of an execution tree according to an example.

FIG. 2 is a flow chart of a method for data query according to an embodiment of the present invention.

FIG 3 is a flow chart of a method for data query according to another embodiment of the present invention based on the method in FIG. 2.

FIG 4 is a flow chart of a method for data query according to still another embodiment of the present invention.

FIG 5 is a flow chart of a method for data query according to still another embodiment of the present invention.

FIG. 6 is a flow chart of a method for data query according to still another embodiment of the present invention.

FIG. 7 is a flow chart of a method for data query according to still another embodiment of the present invention.

FIG. 8 is a flow chart of a method for data query according to still another embodiment of the present invention.

FIG. 9 is a block diagram of an apparatus for data query according to an embodiment of the present invention.

FIG 10 is a flow chart of an apparatus for data query according to another embodiment of the present invention based on the apparatus in FIG. 9.

FIG 11 is a block chart of an apparatus for data query according to still another embodiment of the present invention.

FIG 12 is a block chart of a computer for data query according to an embodiment of the present invention.

DETAILED DESCRIPTION

The technical solutions in embodiments of the present invention are hereinafter described clearly and comprehensively with reference to the accompanying drawings in the embodiments of the present invention. It should be understood that the described embodiments are only a part rather than all of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by persons of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

FIG 2 is a flow chart of a method for data query according to an embodiment of the present invention. As shown in FIG 2, the method of the embodiment includes:

Step 201: receiving, by a processor, a query request;
wherein the query request is input by a user or a client via a computer;

Step 202: when a plan tree for the query request and an execution tree for the plan tree exist, and the execution tree is a partial execution tree, reinitializing, by the processor, the partial execution tree to generate a complete execution tree; and

In the embodiment, the plan tree is an optimal plan. A given query can be actually executed in a wide variety of different ways, each of which will produce the same result but time taken by them may be small to very large difference. So, the best plan, which takes least time of execution, is selected by a processor, and it is called the plan tree. The plan tree is in form of a tree, where each node represents one of operations to be done to execute the query request.

The execution tree is created using the plan tree and in addition to information from plan tree, and it also adds some additional information, which will be used directly for execution. For example, if a SEQ-SCAN node is in the plan tree, this node will be transformed to add information like list of Targets getting selected, memory required to store the result etc to make a corresponding SEQ-SCAN node in the execution tree as shown in FIG 1. The execution tree is executed by the processor starting from a leaf node to a root node. On execution of every node, the result is passed to its parent node. For example, see FIG. 1, the execution tree is executed by the processor starting from the SEQ-SCAN node to the Nested Loop Join node, and finally the query result is sent to the user.

In the embodiment, the partial execution tree is saved in a cursor cache, and is referred to an execution tree which nodes are partial or do not exist completely. There is a flag in each of all nodes of the execution tree, and once the node is reset partially, then the node can be marked using the corresponding flag. So, while the partial execution tree is to be used, each node is gone through to see if any of node flag is set to be partial. If yes, then the node is re-constructed again completely.

In the embodiment, the partial execution tree is reinitialized to generate a complete execution tree by, but not limited to, a known method. Specially, based on the execution tree, it can be found out which nodes are partial. Then using a corresponding node in the plan tree, the remaining data of the partial node can be generated and hence this node will become complete. For example, see the execution tree shown in FIG. 1, there is a leaf node SEQ-SCAN, where TargetList data from this node have been reset. So once it is found that the SEQ-SCAN node is incomplete, the corresponding node in the plan tree can be processed to retrieve the TargetList data and append them to the SEQ-SCAN node, which will make this node as complete.

Step 203: retrieving, by the processor, data query result using the complete execution tree.

In the embodiment, for example, for the execution tree shown in FIG. 1, execution of each node of the execution tree happens from bottom to up and finally the query result is sent to the user. The query result is just the data requested by the user. E.g. a select query is executed by the processor to retrieve all records from a table "tbl", then a plan tree will be created for this query and then an execution tree will be created based on the plan tree. Then using the execution tree, the data query result will be retrieved and given back to the user.

As the partial execution tree takes less memory space than the complete execution tree, compared with the first case in the prior art where the complete execution tree is stored in the curser cache, the storage space taken by the execution tree in the cursor cache can be saved, on the other hand, compared with the second case in the prior art where no execution tree is stored in the curser cache, the performance for data query can be improved because there is no need to generate a new complete execution tree for every new execution. Therefore, compared with conventional data query method, the method according to the embodiment can save the storage space taken by the execution tree in the cursor cache without losing performance which can be beneficial for in-memory systems. As this method uses less storage space to store the partial execution tree, it can get benefit of storing more execution trees which in-turn leads to performance benefit of handling more data queries.

In addition, the method for data query according to the embodiment of the present invention can be applied to any kind of queries, which use execution tree for execution, for example, it can be applied to an SQL data query.

FIG. 3 is a flow chart of a method for data query according to another embodiment of the present invention based on the method in FIG 2. After Step 203, the method may further include:

Step 304: determining a cursor share mode; and

Step 305: performing a corresponding processing on the complete execution tree based on the determined cursor share mode.

Optionally, Step 304 may further include:

determining whether a first sum of a first size of a storage space taken in the cursor cache before receiving the query request and a second size of a storage space to be required to save the complete execution tree is less than or equal to a first threshold, if the first sum is less than or equal to the first threshold, the cursor share mode is a COMPLETE mode, which means that the complete execution tree can be saved in the cursor cache;

if the first sum is greater than the first threshold, determining whether the first sum or a second sum of the first size of the storage space taken by the cursor cache before receiving the query request and a third size of a storage space to be required to save the partial execution tree is less than or equal to a second threshold, if the first sum or the second sum is less than or equal to the second threshold, the cursor share mode is a PARTIAL mode, which means that the partial execution tree can be saved in the cursor cache; and

if the first sum or the second sum is greater than the second threshold, the cursor share mode is a NONE mode, which means that no execution tree can be saved in the cursor cache;

wherein the second threshold is greater than the first threshold. In addition, the first threshold and second threshold can be configured by the user per session or per query. For example, these two thresholds can be configured for a particular query, for whole session lifetime or server life time, and the values of these thresholds can be decided based on the memory availability in the system and with some analysis of the query like how much memory it will take. The values of these thresholds can be set using an SQL command, e.g., "SET minThreshold to value session/query". Similarly, a maxThreshold can be set also. If this needs to be configured for server life time, then it can be configured in a configuration file before the server starts-up.

Optionally, Step 305 may further comprise:

when the cursor share mode is a COMPLETE mode, deleting the partial execution tree from the cursor cache, and saving the complete execution tree in the cursor cache; or saving the complete execution tree in the cursor cache, wherein the partial execution tree in the cursor cache is covered by the complete execution tree;

when the cursor share mode is a PARTIAL mode, releasing the complete execution tree from a memory; and

when the cursor share mode is a NONE mode, releasing the complete execution tree from the memory and deleting the partial execution tree from the cursor cache.

In the case when the cursor share mode is the PARTIAL mode, no need to save anything as partial execution tree is already saved.

In this embodiment, the cursor cache is a part of the memory.

In this embodiment, the complete execution tree can be processed based on the determined cursor share mode, and the first threshold and second threshold can be configured by the user, thus the user has a better control on the storage space taken by the cursor cache and can decide the cursor share mode for different queries/session based on his requirement.

FIG 4 is a flow chart of a method for data query according to still another embodiment of the present invention. As shown in FIG 4, the method of the embodiment includes:

Step 401: receiving, by a processor, a query request;
wherein the query request is input by a user or a client via a computer;

Step 402: determining, by the processor, whether an execution tree for a plan tree which corresponds to the query request exists; if the execution tree exists, it performs Step 403, otherwise, it performs Step 405;

Step 403: when the execution tree is a partial execution tree, reinitializing, by the processor, the partial execution tree to generate a complete execution tree; and

As for how to determine whether the execution tree is a partial execution tree and how to reinitialize the partial execution tree to generate a complete execution tree, it can be referred to the related description with respect to FIG. 2.

Step 404: retrieving, by the processor, data query result using the complete execution tree. Finish.

Step 405: generating, by the processor, a complete execution tree based on the plan tree;

Step 406: retrieving, by the processor, data query result using the complete execution tree;

Step 407: determining, by the processor, a cursor share mode; and

Step 408: performing, by the processor, a corresponding processing on the complete execution tree based on the determined cursor share mode.

Optionally, Step 407 may further include:

determining whether a first sum of a first size of a storage space taken in the cursor cache before receiving the query request and a second size of a storage space to be required to save the complete execution tree is less than or equal to a first threshold, if the first sum is less than or equal to the first threshold, the cursor share mode is a COMPLETE mode, which means that the complete execution tree can be saved in the cursor cache;

if the first sum is greater than the first threshold, determining whether the first sum or a second sum of the first size of the storage space taken by the cursor cache before receiving the query request and a third size of a storage space to be -required to save the partial execution tree is less than or equal to a second threshold, if the first sum or the second sum is less than or equal to the second threshold, the cursor share mode is a PARTIAL mode, which means that the partial execution tree can be saved in the cursor cache; and

if the first sum or the second sum is greater than the second threshold, the cursor share mode is a NONE mode, which means that no execution tree can be saved in the cursor cache;

wherein the second threshold is greater than the first threshold. In addition, the first threshold and second threshold can be configured by the user per session or per query. As for how to configure the first and second thresholds, it can be referred to the related description with respect to FIG. 3.

Optionally, Step 408 may further comprise the following cases:

when the cursor share mode is a COMPLETE mode, saving the complete execution tree in a cursor cache;

when the cursor share mode is a PARTIAL mode, processing the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache; and

when the cursor share mode is a NONE mode, releasing the complete execution tree from a memory, or releasing one or more nodes of an old execution tree which exist in a cursor cache before receiving the query request, and processing the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache.

In this embodiment, the cursor cache is a part of the memory.

Optionally, Step 402 of the method may further comprise:

determining whether the plan tree is dead, if the plan tree is dead, dropping the dead plan tree, and generating a new plan tree.

Optionally, the processing the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache in Step 408 comprises:

releasing intermediate nodes completely and leaf nodes partially of the complete execution tree to obtain the partial execution tree and save the partial execution tree.

In this embodiment, upon the inventor's analysis, the intermediate nodes takes less time about l/5th of the leaf nodes to reconstruct, that is, in the proportion of time, the storage space usage of the intermediate nodes is high. On releasing the intermediate nodes, good amount of storage spaces taken in the cursor cache can be saved by investing comparatively very small time to

reconstruct. Therefore, the intermediate nodes can be released completely, and the leaf nodes can be released partially.

Take the execution tree shown in FIG. 1 as an example, the memory and time taken by the nodes of the execution tree are as given in below table:

In this example, internal nodes (i.e. Nested Loop Join and Materialize) can be released completely and leaf nodes (i.e. Index Scan and Seq Scan) can be released partially because:

1. The internal nodes are taking good amount of storage spaces but comparatively very less time to construct. So if these nodes are released, then whole storage spaces can be saved by investing very less time to re-construct.

2. For leaf node, for example, Index Scan, if index related data's are removed, then it can save around 1/7* of storage spaces as given below:

So we see here around l/7th of storage spaces is reduced, and time is reduced less than !4 of actual. Thus, the leaf node can be released partially to save huge storage spaces by investing marginal time to reconstruct.

3. Similarly the leaf node, Seq Scan node, can be released partially to save good amount of storage spaces with very marginal investment of time to reconstruct.

Optionally, which nodes will be released completely or partially can be decided by the user.

In this embodiment, the complete execution tree can be processed based on the determined cursor share mode, and the first threshold and second threshold can be configured by the user, thus the user has a better control on the storage space taken in the cursor cache and can decide the cursor share mode for different queries/session based on his requirement. In addition, according to the different characteristics of the intermediate nodes and the leaf nodes, a partial execution tree can be constructed and saved, and it can get benefit of storing more execution trees which in-turn leads to performance benefit of handling more data queries.

FIG 5 is a flow chart of a method for data query according to still another embodiment of the present invention. As shown in FIG. 5, the method of the embodiment includes:

Step 501: receiving, by a processor, a query request; wherein the query request is input by a user or a client via a computer;

Step 502: generating, by the processor, a complete execution tree based on a plan tree when an execution tree for the plan tree does not exist;

Step 503: retrieving, by the processor, data query result using the complete execution tree;

Step 504: determining, by the processor, a cursor share mode; and

Step 505: when the cursor share mode is a NONE mode, releasing, by the processor, the complete execution tree from a memory.

In this embodiment, the cursor cache is a part of the memory.

This embodiment provides an example of performing a corresponding processing on the complete execution tree based on the NONE mode. For example, a query is getting executed for the first time. The configured maximum storage space taken by the cursor cache is 1024KB out of which 1023KB already used by earlier storage of one or more execution trees. For the current execution tree to get stored partially, the storage space required is 2KB. So, in this case, the cursor share mode will change to NONE and no execution tree will be stored.

FIG. 6 is a flow chart of a method for data query according to still another embodiment of the present invention. As shown in FIG 6, the method of the embodiment includes:

Step 601: receiving, by a processor, a query request;

wherein the query request is input by a user or a client via a computer;

Step 602: generating, by the processor, a complete execution tree based on a plan tree when an execution tree for the plan tree does not exist;

Step 603: retrieving, by the processor, data query result using the complete execution tree;

Step 604: releasing, by the processor, some nodes of an old execution tree which exists in a cursor cache before receiving the query request based on a user configuration; and

Step 605: partially saving, by the processor, the complete execution tree in the cursor cache.

In this embodiment, in which case if storage space usage goes beyond a maximum threshold, then the user will have an option to decide to reset some old execution tree and free some storage space so that it can still continue with PARTIAL mode of cursor cache, thereby giving control to the user to decide what to save based on his application and experience.

In this embodiment, for example, a query is getting executed for the first time. The configured maximum storage space taken by the cursor cache is 1024KB out of which 1023KB already used by earlier storage of one or more execution trees. User has configured to release some nodes of the old execution tree and still continue with the PARTIAL cursor share mode. That is, in this embodiment, even if the first threshold and the second threshold remain unchanged, the user can have a better control on the storage space taken in the cursor cache and decide the cursor share mode for different queries/session based on his requirement.

FIG 7 is a flow chart of a method for data query according to still another embodiment of the present invention. As shown in FIG. 7, the method of the embodiment comprises:

Step 701: receiving, by a processor, a query request;

wherein the query request is input by a user or a client via a computer; Step 702: generating, by the processor, a complete execution tree based on a plan tree when an execution tree for the plan tree does not exist;

Step 703: retrieving, by the processor, data query result using the complete execution tree; and

Step 704: when the cursor share mode is a PARTIAL mode, processing, by the processor, the complete execution tree to obtain a partial execution tree and save the partial execution tree in a cursor cache.

In this embodiment, the method involves storing the complete execution tree with storage space usage limited to a minimum storage space taken by the cursor cache. Once the storage space has reached the limit of a minimum threshold, then the cursor share mode will get changed to PARTIAL, thereby giving freedom to the user to use mixed mode of cursor share mode with a constraint on the storage space usage.

This embodiment provides an example of performing a corresponding processing on the complete execution tree based on the PARTIAL mode. For example, a query is getting executed for the first time. The configured minimum storage space taken by the cursor cache is 512KB out of which 511KB already used by earlier storage of one or more execution trees. For the current execution tree to get stored partially, the storage space required is 2KB. So, in this case, the cursor share mode will change to PARTIAL and a partial execution tree will be stored for further execution of any new query.

FIG. 8 is a flow chart of a method for data query according to still another embodiment of the present invention. As shown in FIG 8, the method of the embodiment comprises:

Step 801: receiving, by a processor, a query request;
wherein the query request is input by a user or a client via a computer;

Step 802: generating, by the processor, a complete execution tree based on a plan tree when an execution tree for the plan tree does not exist;

Step 803: retrieving, by the processor, data query result using the complete execution tree; and

Step 804: saving, by the processor, nodes of the complete execution tree completely and partially depending on a user configuration.

In this embodiment, if the storage space usage goes beyond a minimum storage space taken by the cursor cache, then the user will have an option to decide whether the COMPLETE cursor share mode itself has to change to PARTIAL or only specific nodes will be saved partially and the rest completely, thereby giving control to the user to decide how to save nodes based on his application and experience.

In this embodiment, for example, a query is getting executed for the first time. The configured minimum storage space taken by the cursor cache is 512KB out of which 511KB already used by earlier storage of one or more execution trees. For the current execution tree to get stored partially, the storage space required is 2KB. So, in this case, the user can configure to store some nodes completely and some nodes partially, so that the usage of storage space remains balanced. With this method, the user can decide based on his expertise that if some nodes take too much time but less storage space, for example, the leaf node SEQ- SCAN shown in FIG. 1, then those nodes can be saved completely otherwise partially, thus the user can have a better control on the storage space taken in the cursor cache and decide the cursor share mode for different queries/session based on his requirement.

FIG. 9 is a block diagram of an apparatus for data query according to an embodiment of the present invention. As shown in FIG 9, the apparatus comprises a receiving module 901, a reinitializing module 902, and a retrieving module 903, wherein the receiving module 901 is configured to receive a query request, the reinitializing module 902 is configured to reinitialize, when a plan tree for the query request and an execution tree for the plan tree exist, and the execution tree is a partial execution tree, the partial execution tree to generate a complete execution tree; and the retrieving module 903 is configured to retrieve data query result using the complete execution tree.

In the embodiment, the partial execution tree is saved in the cursor cache.

The apparatus of the present embodiment can perform the method for data query as shown in FIG 2, and the principle is similar, thus it need not be repeated here.

In the embodiment, the partial execution tree can be reinitialized to generate a complete execution tree, thus compared with the first case in the prior art, the storage space taken in the cursor cache can be saved, on the other hand, compared with the second case in the prior art, the performance for data query can be improved. Over the existing solutions, the method according to the embodiment can save the storage space taken in the cursor cache without losing performance which can be beneficial for in-memory systems. As this method uses less storage space to store the partial execution tree, it can get benefit of storing more execution trees which in-turn can lead to performance benefit of more number of queries.

In addition, the apparatus for data query according to the embodiment of the present invention can be applied to any kind of queries, which use execution tree for execution, for example, it can be applied to an SQL data query.

FIG. 10 is a flow chart of an apparatus for data query according to another embodiment of the present invention based on the apparatus in FIG. 9. The apparatus further comprises a determination module 904 and a performing module 905, wherein the determination module 904 is configured to determine a cursor share mode; and the performing module 905 is configured to perform a corresponding processing on the complete execution tree based on the determine cursor share mode.

Optionally, the determination module 904 may be specifically configured to: determine whether a first sum of a first size of a storage space taken in a cursor cache before receiving the query request and a second size of a storage space to be required to save the complete execution tree is less than or equal to a first threshold, if the first sum is less than or equal to the first threshold, the cursor share mode is a COMPLETE mode, which means that the complete execution tree can be saved in the cursor cache;

if the first sum is greater than the first threshold, determine whether the first sum or a second sum of the first size of the storage space taken by the cursor cache before receiving the query request and a third size of a storage space to be required to save the partial execution tree is less than or equal to a second threshold, if the first sum or the second sum is less than or equal to the second threshold, the cursor share mode is a PARTIAL mode, which means that the partial execution tree can be saved in the cursor cache; and

if the first sum or the second sum is greater than the second threshold, the cursor share mode is a NONE mode, which means that no execution tree can be saved in the cursor cache; wherein the second threshold is greater than the first threshold.

In addition, the first threshold and second threshold can be configured by the user per session or per query.

Optionally, the performing module 905 may be specifically configured to:

when the cursor share mode is a COMPLETE mode, delete the partial execution tree from a cursor cache, and save the complete execution tree in the cursor cache; or save the complete execution tree in the cursor cache, wherein the partial execution tree in the cursor cache is covered by the complete execution tree; when the cursor share mode is a PARTIAL mode, release the complete execution tree from a memory; and when the cursor share mode is a NONE mode, release the complete execution tree from the memory and delete the partial execution tree from the cursor cache.

In the case when the cursor share mode is the PARTIAL mode, no need to save anything as partial execution tree is already saved.

In this embodiment, the cursor cache is a part of the memory.

In this embodiment, the complete execution tree can be processed based on the determined cursor share mode, and the first threshold and second threshold can be configured by the user, thus the user has a better control on the storage space taken in the cursor cache and can decide the cursor share mode for different queries/session based on his requirement.

FIG 11 is a block chart of an apparatus for data query according to still another embodiment of the present invention. As shown in FIG 11, the apparatus of the embodiment comprises a receiving module 1101, a generating module 1102, a retrieving module 1103, a determination module 1104, and a performing module 1105, wherein the receiving module 1101 is configured to receive a query request; the generating module 1102 is configured to generate a complete execution tree based on a plan tree when the plan tree for the query request exists and the execution tree for the plan tree does not exist; the retrieving module 1103 is configured to retrieve data query result using the complete execution tree; the determination module 1104 is configured to determine a cursor share mode; and the performing module 1105 is configured to perform a corresponding processing on the complete execution tree based on the determined cursor share mode.

In addition, when the plan tree is dead, the dead plan tree is dropped and a new plan tree is generated.

Optionally, the determination module 1104 may be specifically configured to:
determine whether a first sum of a first size of a storage space taken in a cursor cache before receiving the query request and a second size of a storage space to be required to save the complete execution tree is less than or equal to a first threshold, if the first sum is less than or equal to the first threshold, the cursor share mode is a COMPLETE mode, which means that the complete execution tree can be saved in the cursor cache;

if the first sum is greater than the first threshold, determine whether the first sum or a second sum of the first size and a third size of a storage space to be required to save the partial execution tree is less than or equal to a second threshold, if the first sum or the second sum is less than or equal to the second threshold, the cursor share mode is a PARTIAL mode, which means that the partial execution tree can be saved in the cursor cache; and

if the first sum or the second sum is greater than the second threshold, the cursor share mode is a NONE mode, which means that no execution tree can be saved in the cursor cache;
wherein the second threshold is greater than the first threshold.

In addition, the first threshold and second threshold can be configured by the user per session or per query.

Optionally, the performing module 1105 may be specifically configured to:

when the cursor share mode is a COMPLETE mode, save the complete execution tree in a cursor cache;

when the cursor share mode is a PARTIAL mode, process the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache; and

when the cursor share mode is a NONE mode, release the complete execution tree from a memory or release one or more nodes of an old execution tree which exist in the cursor cache before receiving the query request, and process the complete execution tree to obtain and save a partial execution tree in the cursor cache.

In this embodiment, the cursor cache is a part of the memory.

Optionally, the performing module may be further configured to release intermediate nodes completely and leaf nodes partially of the complete execution tree to obtain the partial execution tree and save the partial execution tree in the cursor cache.

In this embodiment, upon the inventor's analysis, the intermediate nodes takes less time about 1/5 of the leaf nodes to reconstruct, that is, in the proportion of time, the storage space usage of the intermediate nodes is high. On releasing the intermediate nodes, good amount of storage spaces taken in the cursor cache can be saved by investing comparatively very small time to reconstruct. Therefore, the intermediate nodes can be released completely, and the leaf nodes can be released partially. Optionally, which nodes will be released completely or partially can be decided by the user.

In this embodiment, the complete execution tree can be processed based on the determined cursor share mode, and the first threshold and second threshold can be configured by the user, thus the user has a better control on the storage space taken in the cursor cache and can decide the cursor share mode for different queries/session based on his requirement. In addition, according to the different characteristics of the intermediate nodes and the leaf nodes, a partial execution tree can be constructed and saved, and it can get benefit of storing more execution trees which in-turn leads to performance benefit of handling more data queries.

An embodiment of the present invention further provides a computer for data query. The computer can be a terminal device, or a server, or a database or any other device or hardware form.

FIG 12 is a block chart of a computer for data query according to an embodiment of the present invention. As shown in FIG 12, the computer includes a processor 1201 and a memory 1202 coupled to the processor 1201.

The memory 1202 is configured to store program. Specifically, the program can includes program code, the program code includes computer operating instruction.

The processor 1201 is configured to receive a query request; when a plan tree for the query request and an execution tree for the plan tree exist, and the execution tree is a partial execution tree, reinitialize the partial execution tree to generate a complete execution tree; and retrieve data query result using the complete execution tree.

The memory 1202 may include a high speed RAM and a non-volatile memory.

The processor 1201 may be a Central Processing Unit (CPU), or can be Application Specific Integrated Circuit (ASIC), or can be configured to one or more ASIC.

According to the above computer, as the partial execution tree takes less memory space than the complete execution tree, compared with the first case in the prior art where the complete execution tree is stored in the curser cache, the storage space taken by the execution tree in the cursor cache can be saved, on the other hand, compared with the second case in the prior art where no execution tree is stored in the curser cache, the performance for data query can be improved because there is no need to generate a new complete execution tree for every new execution. Therefore, compared with conventional data query method, the computer according to the embodiment can save the storage space taken by the execution tree in the cursor cache without losing performance which can be beneficial for in-memory systems. As this computer uses less storage space to store the partial execution tree, it can get benefit of storing more execution trees which in-turn leads to performance benefit of handling more data queries.

Further, after the step of retrieving the data query result using the complete execution tree, the processor 1201 is further configured to: determine a cursor share mode, and perform a corresponding processing on the complete execution tree based on the determined cursor share mode. In addition, in the step of performing the corresponding processing on the complete execution tree based on the determined cursor share mode, the processor 1201 is specifically configured to: when the cursor share mode is a COMPLETE mode, delete the partial execution tree from a cursor cache, and save the complete execution tree in the cursor cache; or save the complete execution tree in the cursor cache, wherein the partial execution tree in the cursor cache is covered by the complete execution tree; when the cursor share mode is a PARTIAL mode, release the complete execution tree from a memory; and when the cursor share mode is a NONE mode, release the complete execution tree from the memory and delete the partial execution tree from the cursor cache.

According to the above computer, the complete execution tree can be processed based on the determined cursor share mode, and the first threshold and second threshold can be configured by the user, thus the user has a better control on the storage space taken by the cursor cache and can decide the cursor share mode for different queries/session based on his requirement.

Further, after the step of receiving the query request, the processor 1201 is further configured to: generate the complete execution tree based on the plan tree when the plan tree for the query request exists and the execution tree for the plan tree does not exist; retrieve the data query result using the complete execution tree; determine a cursor share mode; and perform a corresponding processing on the complete execution tree based on the determined cursor share mode. In addition, in the step of performing the corresponding processing on the complete execution tree based on the determined cursor share mode, the processor 1201 is specifically configured to: when the cursor share mode is a COMPLETE mode, save the complete execution tree in a cursor cache; when the cursor share mode is a PARTIAL mode, process the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache; and when the cursor share mode is a NONE mode, release the complete execution tree from a memory or release one or more nodes of an old execution tree which exist in the cursor cache before receiving the query request, and process the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache.

According to the above computer, the complete execution tree can be processed based on the determined cursor share mode, and the first threshold and second threshold can be configured by the user, thus the user has a better control on the storage space taken in the cursor cache and can decide the cursor share mode for different queries/session based on his requirement.

Further, in the step of determining the cursor share mode, the processor 1201 is specifically configured to: determine whether a first sum of a first size of a storage space taken by a cursor cache before receiving the query request and a second size of a storage space to be required to save the complete execution tree is less than or equal to a first threshold, if the first sum is less than or equal to the first threshold, the cursor share mode is a COMPLETE mode; if the first sum is greater than the first threshold, determine whether the first sum or a second sum of the first size of the storage space taken by the cursor cache before receiving the query request and a third size of a storage space to be required to save the partial execution tree is less than or equal to a second threshold, if the first sum or the second sum is less than or equal to the second threshold, the cursor share mode is a PARTIAL mode; and if the first sum or the second sum is greater than the second threshold, the cursor share mode is a NONE mode; wherein the second threshold is greater than the first threshold.

According to the above computer, the first threshold and second threshold can be configured by the user per session or per query, thus the user has a better control on the storage space taken by the cursor cache and can decide the cursor share mode for different queries/session based on his requirement.

Further, in the step of processing the complete execution tree to obtain the partial execution tree and save the partial execution tree in the cursor cache, the processor is specifically configured to: release intermediate nodes completely and leaf nodes partially of the complete execution tree to obtain the partial execution tree and save the partial execution tree in the cursor cache.

According to the above computer, according to the different characteristics of the intermediate nodes and the leaf nodes, a partial execution tree can be constructed and saved, and it can get benefit of storing more execution trees which in-turn leads to performance benefit of handling more data queries.

Further, as shown in Fig. 12, the computer may also include a communication interface 1203 configured to complete the communication between the computer and other devices.

As shown in Fig. 12, the computer may also include a disk 1204, configured to store other program or data.

Alternatively, in specific implementation, if the memory 1202, the processor 1201, the communication interface 1203 and the disk 1204 can be implemented individually, then the memory 1202, the processor 1201, the communication interface 1203 and the disk 1204 can be in communication connection via BUS. The BUS can be Industry Standard Architecture (ISA) BUS, Peripheral Component (PCI) BUS or Extended Industry Standard Architecture (EISA) BUS etc. The BUS can be divided into address BUS, data BUS and control BUS etc. For convenient representation, the BUS is only represented by a single thick line, but does not mean there is only one BUS or one kind of BUS.

Alternatively, in specific implementation, if the memory 1202, the processor 1201, the communication interface 1203 and the disk 1204 can be integrated in a single chip, then the memory 1202, the processor 1201, the communication interface 1203 and the disk 1204 can be in communication connection via internal interface.

The present invention also provides a non-transitory computer readable storage medium, including computer program codes which when executed by a computer processor cause the compute processor to execute the methods for data query according to embodiments of the present invention.

According to the above non-transitory computer readable storage medium, as the partial execution tree takes less memory space than the complete execution tree, compared with the first case in the prior art where the complete execution tree is stored in the curser cache, the storage space taken by the execution tree in the cursor cache can be saved, on the other hand, compared with the second case in the prior art where no execution tree is stored in the curser cache, the performance for data query can be improved because there is no need to generate a new complete execution tree for every new execution. Therefore, compared with conventional data query method, the non-transitory computer readable storage medium according to the embodiment can save the storage space taken by the execution tree in the cursor cache without losing performance which can be beneficial for in-memory systems. As this non-transitory computer readable storage medium uses less storage space to store the partial execution tree, it can get benefit of storing more execution trees which in-turn leads to performance benefit of handling more data queries.

By the embodiments described above, persons skilled in the art may clearly understand that the present invention may be implemented by software with necessary common hardware. Specifically, the present invention may also be implemented by only hardware. However, the former is the preferred implementation mode. Based on such understanding, the essence of the technical solution of the present invention or the part of that makes a contribution to the prior art may be implemented in the form of software product. The computer software product is stored in a readable storage medium such as a computer floppy disk, a hard disk, or an optical disk, and includes multiple instructions to enable computer equipment (which may be a personal computer, a server, or network equipment) to execute the method described in embodiments of the present invention.

The foregoing descriptions are merely exemplary embodiments of the present invention, but are not intended to limit the present invention. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention shall fall within the protection scope of the present invention.

WE CLAIM :

1. A method for data query, comprising:
receiving, by a processor, a query request;
when a plan tree for the query request and an execution tree for the plan tree exist, and the execution tree is a partial execution tree, reinitializing, by the processor, the partial execution tree to generate a complete execution tree; and
retrieving, by the processor, data query result using the complete execution tree.

2. The method as claimed in claim 1, wherein after the retrieving, by the
processor, the data query result using the complete execution tree, the method
further comprises:
determining a cursor share mode, and
performing a corresponding processing on the complete execution tree based on the determined cursor share mode.

3. The method as claimed in claim 2, wherein the performing a
corresponding processing on the complete execution tree based on the determined
cursor share mode comprises:
when the cursor share mode is a COMPLETE mode, deleting the partial execution tree from a cursor cache, and saving the complete execution tree in the cursor cache; or saving the complete execution tree in the cursor cache, wherein the partial execution tree in the cursor cache is covered by the complete execution tree;
when the cursor share mode is a PARTIAL mode, releasing the complete execution tree from a memory; and
when the cursor share mode is a NONE mode, releasing the complete execution tree from the memory and deleting the partial execution tree from the cursor cache.

4. The method as claimed in claim 1, wherein after the receiving, by the
processor, the query request, the method further comprises:
generating the complete execution tree based on the plan tree when the plan tree for the query request exists and the execution tree for the plan tree does not exist;
retrieving the data query result using the complete execution tree;
determining a cursor share mode; and
performing a corresponding processing on the complete execution tree based on the determined cursor share mode.

5. The method as claimed in claim 4, wherein the performing a
corresponding processing on the complete execution tree based on the determined
cursor share mode comprises:
when the cursor share mode is a COMPLETE mode, saving the complete execution tree in a cursor cache;
when the cursor share mode is a PARTIAL mode, processing the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache; and
when the cursor share mode is a NONE mode, releasing the complete execution tree from a memory or releasing one or more nodes of an old execution tree which exist in the cursor cache before receiving the query request, and processing the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache.

6. The method as claimed in claim 2 or claim 4, wherein the determining the
cursor share mode comprises:
determining whether a first sum of a first size of a storage space taken by a cursor cache before receiving the query request and a second size of a storage space to be required to save the complete execution tree is less than or equal to a first threshold, if the first sum is less than or equal to the first threshold, the cursor share mode is a COMPLETE mode;
if the first sum is greater than the first threshold, determining whether the first sum or a second sum of the first size of the storage space taken by the cursor cache before receiving the query request and a third size of a storage space to be required to save the partial execution tree is less than or equal to a second threshold, if the first sum or the second sum is less than or equal to the second threshold, the cursor share mode is a PARTIAL mode; and
if the first sum or the second sum is greater than the second threshold, the cursor share mode is a NONE mode;
wherein the second threshold is greater than the first threshold.

7. The method as claimed in claim 5, wherein the processing the complete
execution tree to obtain the partial execution tree and save the partial execution
tree in the cursor cache comprises:
releasing intermediate nodes completely and leaf nodes partially of the complete execution tree to obtain the partial execution tree and save the partial execution tree in the cursor cache.

8. An apparatus for data query, comprising:
a receiving module, configured to receive a query request;
a reinitializing module, configured to reinitialize, when a plan tree for the query request and an execution tree for the plan tree exist, and the execution tree is a partial execution tree, the partial execution tree to generate a complete execution tree; and
a retrieving module, configured to retrieve data query result using the complete execution tree.

9. The apparatus as claimed in claim 8, further comprising:
a determination module, configured to determine a cursor share mode; and

a performing module, configured to perform a corresponding processing on the complete execution tree based on the determined cursor share mode.

10. The apparatus as claimed in claim 9, wherein the performing module is
specifically configured to:
when the cursor share mode is a COMPLETE mode, delete the partial execution tree from a cursor cache, and save the complete execution tree in the cursor cache; or save the complete execution tree in the cursor cache, wherein the partial execution tree in the cursor cache is covered by the complete execution tree;
when the cursor share mode is a PARTIAL mode, release the complete execution tree from a memory; and
when the cursor share mode is a NONE mode, release the complete execution tree from the memory and delete the partial execution tree from the cursor cache.

11. The apparatus as claimed in claim 8, further comprising:
a generating module, configured to generate the complete execution tree based on the plan tree when the plan tree for the query request exists and the execution tree for the plan tree does not exist;
a determination module, configured to determine a cursor share mode; and a performing module, configured to perform a corresponding processing on the complete execution tree based on the determined cursor share mode.

12. The apparatus as claimed in claim 11, wherein the performing module is
specifically configured to:
when the cursor share mode is a COMPLETE mode, save the complete execution tree in a cursor cache;
when the cursor share mode is a PARTIAL mode, process the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache; and
when the cursor share mode is a NONE mode, release the complete execution tree from a memory or release one or more nodes of an old execution tree which exist in the cursor cache before receiving the query request, and process the complete execution tree to obtain and save a partial execution tree in the cursor cache.

13. The apparatus as claimed in claim 9 or claim 11, wherein the
determination module is specifically configured to:
determine whether a first sum of a first size of a storage space taken by a cursor cache before receiving the query request and a second size of a storage space to be required to save the complete execution tree is less than or equal to a first threshold, if the first sum is less than or equal to the first threshold, the cursor share mode is a COMPLETE mode;
if the first sum is greater than the first threshold, determine whether the first sum or a second sum of the first size of the storage space taken by the cursor cache before receiving the query request and a third size of a storage space to be required to save the partial execution tree is less than or equal to a second threshold, if the first sum or the second sum is less than or equal to the second threshold, the cursor share mode is a PARTIAL mode; and
if the first sum or the second sum is greater than the second threshold, the cursor share mode is a NONE mode;
wherein the second threshold is greater than the first threshold.

14. The apparatus as claimed in claim 12, wherein the performing module is
further configured to:
release intermediate nodes completely and leaf nodes partially of the complete execution tree to obtain the partial execution tree and save the partial execution tree in the cursor cache.

15. A computer, comprising:
a processor and a memory coupled to the processor;
wherein the processor is configured to:
receive a query request;
when a plan tree for the query request and an execution tree for the plan tree exist, and the execution tree is a partial execution tree, reinitialize the partial execution tree to generate a complete execution tree; and
retrieve data query result using the complete execution tree.

16. The computer as claimed in claim 15, wherein after the step of retrieving
the data query result using the complete execution tree, the processor is further
configured to:
determine a cursor share mode, and
perform a corresponding processing on the complete execution tree based on the determined cursor share mode.

17. The computer as claimed in claim 16, wherein in the step of performing
the corresponding processing on the complete execution tree based on the
determined cursor share mode, the processor is specifically configured to:
when the cursor share mode is a COMPLETE mode, delete the partial execution tree from a cursor cache, and save the complete execution tree in the cursor cache; or save the complete execution tree in the cursor cache, wherein the partial execution tree in the cursor cache is covered by the complete execution tree;
when the cursor share mode is a PARTIAL mode, release the complete execution tree from a memory; and when the cursor share mode is a NONE mode, release the complete execution tree from the memory and delete the partial execution tree from the cursor cache.

18. The computer as claimed in claim 15, wherein after the step of receiving
the query request, the processor is further configured to: generate the complete
execution tree based on the plan tree when the plan tree for the query request
exists and the execution tree for the plan tree does not exist;
retrieve the data query result using the complete execution tree; determine a cursor share mode; and
perform a corresponding processing on the complete execution tree based on the determined cursor share mode.

19. The computer as claimed in claim 18, wherein in the step of performing
the corresponding processing on the complete execution tree based on the
determined cursor share mode, the processor is specifically configured to: when
the cursor share mode is a COMPLETE mode, save the complete execution tree in
a cursor cache;
when the cursor share mode is a PARTIAL mode, process the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache; and
when the cursor share mode is a NONE mode, release the complete execution tree from a memory or release one or more nodes of an old execution tree which exist in the cursor cache before receiving the query request, and process the complete execution tree to obtain a partial execution tree and save the partial execution tree in the cursor cache.

20. The computer as claimed in claim 16 or claim 18, wherein in the step of
determining the cursor share mode, the processor is specifically configured to:
determine whether a first sum of a first size of a storage space taken by a cursor cache before receiving the query request and a second size of a storage space to be required to save the complete execution tree is less than or equal to a first threshold, if the first sum is less than or equal to the first threshold, the cursor share mode is a COMPLETE mode;
if the first sum is greater than the first threshold, determine whether the first sum or a second sum of the first size of the storage space taken by the cursor cache before receiving the query request and a third size of a storage space to be required to save the partial execution tree is less than or equal to a second threshold, if the first sum or the second sum is less than or equal to the second threshold, the cursor share mode is a PARTIAL mode; and
if the first sum or the second sum is greater than the second threshold, the cursor share mode is a NONE mode;
wherein the second threshold is greater than the first threshold.

21. The computer as claimed in claim 19, wherein in the step of processing the complete execution tree to obtain the partial execution tree and save the partial execution tree in the cursor cache, the processor is specifically configured to:
release intermediate nodes completely and leaf nodes partially of the complete execution tree to obtain the partial execution tree and save the partial execution tree in the cursor cache.