Query systems, computer programs, and methods for fetching query result data (fetching query results using query filters)

Abstract

To create a query filter data structure for determining whether to acquire live query data from a storage server or acquire data over time in a related dataset, and present a query scheme to use.SOLUTION: In a query system, the number of queries to a storage server can be reduced, increasing overall efficiency of the query system. Another query scheme that adjusts frequency of dataset refreshes is also presented, on the basis of a user-defined data age parameter indication included in a subsequent query, and / or on the basis of whether frequency of a storage server query exceeds a predetermined threshold, or on the basis of both, The efficiency of the query system increases because a trend to acquire a query result from a dataset increases and a trend of the query to the storage server decreases.SELECTED DRAWING: Figure 1

Description

Technical Field

[0001] Various embodiments of the present application generally relate to querying stored data. More specifically, various embodiments may relate to creating a query filter data structure and using the query filter data structure to determine whether to fetch live query result data from a storage server or whether to fetch query result data that has passed a certain time from a related dataset. Further, various embodiments may relate to adjusting the refresh frequency of a related dataset based on a data age indication included in a subsequent user query request, or based on the frequency of storage server queries, or based on both.

Summary of the Invention

Problems to be Solved by the Invention

[0002] Data-driven decision-making is becoming increasingly important. Generally, the data used in the decision-making process exists on a storage server accessed when a user executes a query. The more users execute queries to the storage server, the more likely it is that the storage server will be overloaded and its operating efficiency will decrease. Further, query users increasingly expect data to return from the storage server as quickly as possible. Therefore, when the performance of the memory system deteriorates, subsequent data retrieval and the related user experience are adversely affected.

Means for Solving the Problems

[0003] In one embodiment of the present invention, a query system is presented. The query system comprises a query server having a processor and memory. The memory includes a query module that, when invoked by the processor, causes the query server to receive a plurality of query filter data structures from a query manager computing entity, each containing different assigned query themes and theme data age periods. When invoked by the processor, the query module further causes the query server to receive a query from a query user computing entity, which includes a request for query results and user-defined data age parameters. When invoked by the processor, the query module further causes the query server to parse the query to determine a query theme and identify a query filter data structure containing the same assigned query theme as the query theme. When invoked by the processor, the query module further causes the query server to determine whether the entirety of the user-defined data age parameters is ranged within the theme data age period of the one query filter data structure. When the query module is invoked by the processor, if the entire set of user-defined data age parameters is ranged within the subject data age period of the query filter data structure, it causes the query server to fetch query result data from the dataset associated with the query filter data structure. When the query module is invoked by the processor, if the entire set of user-defined data age parameters is not ranged within the subject data age period of the query filter data structure, it causes the query server to fetch query result data from a storage server connected to the query via a network.

[0004] In another embodiment of the present invention, a computer program product for fetching query result data is presented. The computer program product comprises a computer-readable storage medium in which program instructions are embodied. The program instructions are readable to a processor to receive a plurality of query filter data structures from a query manager computing entity, each containing different assigned query themes and theme data age periods. The program instructions are further readable to the processor to receive a query from a query user computing entity, which includes a request for query results and user-defined data age parameters. The program instructions are further readable to the processor to parse the query to determine a query theme and identify a query filter data structure containing the same assigned query theme as the query theme. The program instructions are further readable to the processor to determine whether the entirety of the user-defined data age parameters is ranged within the theme data age period of the one query filter data structure. The program instructions are further readable to cause the processor to fetch query result data from a dataset associated with the query filter data structure, provided that the entire set of user-defined data age parameters is ranged within the subject data age period of the query filter data structure. The program instructions are further readable to cause the processor to fetch query result data from a storage server connected to the query via a network, provided that the entire set of user-defined data age parameters is not ranged within the subject data age period of the query filter data structure.

[0005] In another embodiment of the present invention, a method for fetching query result data is provided. The method comprises the step of receiving a plurality of query filter data structures from a query manager computing entity, each containing different assigned query themes and theme data age periods. The method further comprises the step of receiving a query from a query user computing entity, which includes a request for query results and user-defined data age parameters. The method further comprises the step of parsing the query to determine the query theme. The method further comprises the step of identifying a query filter data structure containing the same assigned query theme as the query theme. The method further comprises the step of determining whether the entire set of user-defined data age parameters is ranged within the theme data age period of the one query filter data structure. If the entire set of user-defined data age parameters is ranged within the theme data age period of the one query filter data structure, the method further comprises the step of fetching query result data from a dataset associated with the one query filter data structure. The method further comprises the step of fetching query result data from a storage server connected to the query via a network if the entire user-defined data age parameter is not ranged within the subject data age period of the one query filter data structure.

[0006] These embodiments, features, aspects, and advantages of the present invention, as well as other embodiments, features, aspects, and advantages, will be better understood by referring to the following description, the appended claims, and the appended drawings. [Brief explanation of the drawing]

[0007] [Figure 1] This block diagram shows one implementation of a data query system according to several embodiments. [Figure 2]This block diagram shows one implementation of a data query management module according to several embodiments.

[0008] [Figure 3] This diagram shows a storage device in a query server and one implementation of a storage device in a storage server, according to several embodiments.

[0009] [Figure 4] This document describes a scheme, according to several embodiments, for retrieving live query data from a storage server or time-lapsed data within a related dataset.

[0010] [Figure 5A] This document describes a scheme that utilizes a query filter data structure to determine whether to retrieve live query data from a storage server or to retrieve time-lapsed data from a previously created dataset, according to several embodiments. [Figure 5B] This document describes a scheme that utilizes a query filter data structure to determine whether to retrieve live query data from a storage server or to retrieve time-lapsed data from a previously created dataset, according to several embodiments.

[0011] [Figure 6] This document describes a method, according to several embodiments, for adjusting the dataset refresh time granularity based on data age instructions included in subsequent user query requests, or based on the frequency of memory server queries, or both.

[0012] In accordance with common practice, various features shown in the drawings may not be depicted to scale. Therefore, the dimensions of various features may be arbitrarily enlarged or reduced for clarity. Furthermore, some of the drawings may not show all components of a given system, method, or device. Finally, the same reference numerals may be used throughout the specification and drawings to indicate similar features. [Modes for carrying out the invention]

[0013] Data-driven decision-making is becoming increasingly important. Generally, the data used in the decision-making process resides on memory servers accessed when users execute queries. The more users querying the memory servers, the greater the burden on the servers, and the more likely their operational efficiency is to decrease. Furthermore, querying users increasingly expect data to be returned from the memory servers as quickly as possible. Therefore, a decline in memory system performance negatively impacts data retrieval and the associated user experience.

[0014] Memory server efficiency can be improved using a query data model that enables the sharing of query data among multiple users. More specifically, performance can be improved by pre-executing queries and retrieving the query results. Then, when users perform queries, the query results are available for them to return without expending the resources necessary to access the memory system. This all-or-nothing approach has several limitations, such as the difficulty in predicting when and how often the memory server needs to be pre-accessed, and the difficulty in predicting when and how often the query results need to be refreshed.

[0015] Another challenge with these methods is the difficulty in providing specific query results to multiple users with varying data age requirements. For example, some users may request query results that include live query data, while others may request queries where longer-term data is more appropriate.

[0016] To address these challenges, a query scheme is presented that utilizes a query filter data structure to determine whether to retrieve live query data from a storage server or aged data from a previously created dataset. Using this scheme reduces the number of queries to the storage server and improves the overall efficiency of the query system. Furthermore, a query scheme is presented to adjust the refresh frequency of previously created datasets based on data age instructions included in subsequent user query requests, or based on the frequency of storage server queries, or both. Using this scheme increases the likelihood that datasets exist and contain appropriate data to satisfy user queries, ultimately reducing the number of queries to the storage server and improving the efficiency of the query system.

[0017] Numerous details are described herein to provide a complete understanding of the exemplary embodiments shown in the accompanying drawings. However, some embodiments can be carried out without these specific details, and the scope of the claims is limited only to the features and aspects specifically described herein. Furthermore, well-known methods, components, or circuits, etc., are not described in full detail so as not to unnecessarily obscure more relevant aspects of the embodiments described herein.

[0018] Figure 1 is a diagram of one implementation of the query system 10 according to several embodiments. Several exemplary features are shown, but for the sake of brevity and to avoid obscuring more relevant aspects of the exemplary embodiments disclosed herein, various other features are not shown.

[0019] To that end, by way of non-limiting example, query system 10 includes query manager computer 12, query user computer 20, query server 100 used in conjunction with query manager computer 12 and query user computer 20, and storage server 200 used in conjunction with query server 100.

[0020] Query manager computer 12 and query user computer 20 can each be collectively referred to as physical computer systems 12, 20. Physical computer systems 12, 20 are examples of distinct or individual computing entities. The term computing entity is defined herein as a physical computer or a virtual machine (VM). In some embodiments, each computing entity is communicatively connected to query server 100 by a well-known network.

[0021] Physical computer systems 12, 20 can be servers, computers, laptop computers, tablet devices, netbooks, Internet kiosks, personal digital assistants, cellular phones, smart phones, gaming devices, or other physical computing devices. Similarly, the computing entity can be distinct VMs 14, 16, 22, 24. Each of VMs 14, 16, 22, 24 is a virtual computer on which its own virtual computing resources are created on physical computer systems 12, 20. Generally, software separates and appropriately provisions the resources of physical computer systems 12, 20 so that they can be used by each of VMs 14, 16, 22, 24, respectively. In the illustrated example, VMs 14 and 16 function as distinct virtual computers on which their own virtual computing resources are created on physical computer systems 12, 20. Similarly, VMs 22 and 24 function as distinct virtual computers on which their own virtual computing resources are created on physical computer system 20.

[0022] In some embodiments, each physical computer system 12, 20 includes one or more processors, one or more types of memory, a display, or other user interface components, or a combination thereof, and other user interface components include a keyboard, a touch screen display, a mouse, a trackpad, a digital camera, or any number of auxiliary devices for adding functionality, or a combination thereof, etc.

[0023] The physical computer systems 12, 20 can be coupled to the query server 100 through one or more data connections 101 such as a well-known network or a physical cable. Similarly, the physical computer system 20 can be coupled to the query server 100 through one or more data connections 102 such as a well-known network or a physical cable.

[0024] The query server 100 can include a buffer 123, a storage device 128, a management module 121, or a CPU 122, or a combination thereof. The query server 100 can be a computing entity (such as a physical computer or a VM, etc.). The storage server 200 can include a buffer 223, a storage device 228, a management module 221, or a CPU 222, or a combination thereof. The storage server 200 can be a computing entity (such as a physical computer or a VM, etc.).

[0025] In some embodiments, the storage devices 128, 228 are single storage devices, while in other embodiments, the storage devices 128, 228 include multiple storage devices. In some embodiments, the storage devices 128, 228 may include different types of storage devices. In some embodiments, the storage devices 128, 228 include one or more NAND flash storage devices and one or more NOR flash storage devices. However, depending on the aspects of the wide variety of embodiments, other types of storage devices may be included (e.g., PCRAM, ReRAM, STT-RAM, etc.). In some embodiments, the flash storage device includes one or more flash memory dies, one or more flash memory packages, one or more flash memory channels, one or more solid-state disks (SSDs), or one or more SSD arrays, etc.

[0026] The query server 100 may further include a management module 121, one or more input / output buffers 123, and so on. Similarly, the storage server 200 may further include a management module 221, one or more input / output buffers 223, and so on. The query server 100 and the storage server 200 may include various additional features not shown for brevity and to avoid obscuring more relevant features of the exemplary embodiments disclosed herein, and different feature configurations are also possible.

[0027] The input and output buffers 123 provide interfaces to the physical computer system 12 via data connection 101 and to the physical computer system 20 via data connection 102. The management module 121 may include one or more processing units (CPUs, sometimes called processors) 122 configured to execute instructions in one or more programs or applications (e.g., stored in the management module 121). In some embodiments, one or more CPUs 122 are shared by one or more components within the functionality of the query server 100, and in some cases by one or more components outside of that functionality. To coordinate the operation of these components, the management module 121 is coupled to the input / output buffers 123 and the storage device 128.

[0028] The input and output buffers 223 provide an interface to the query server 100 through the data connection 201. The management module 221 may include one or more CPUs 222 configured to execute instructions in one or more programs or applications (e.g., stored in the management module 221). In some embodiments, one or more CPUs 222 are shared by one or more components within the functionality of the storage server 200, and in some cases by one or more components outside of that functionality. To coordinate the operation of these components, the management module 221 is coupled to the input / output buffers 223 and the storage device 228.

[0029] The storage server 200 can be connected to the management module 121 through connection 201. Connections 101, 102, and 201 are sometimes called data connections, but generally transmit commands in addition to data, and optionally transmit metadata, error correction information, or other information, or a combination thereof, in addition to data values ​​to be stored in storage devices 128 and 228 and data values ​​read from storage devices 128 and 228. For clarity, storage devices 128 and 228 are contained in different computing entities, e.g., different physical servers.

[0030] A query operation can begin when a requesting computing entity sends one or more query requests to the query server 100 (for example, via a data connection 102) to request data associated with those requests. The query server 100 can obtain the data associated with the one or more query requests by fetching time-lapsed data from a dataset stored locally in the storage device 128, or by fetching live query data from the storage server 200, or both. The query server 100 can package or collect the fetched data into query results or datasets, store the dataset locally in the storage device 128, return the query results to the requesting computing entity, or a combination of these.

[0031] Figure 2 is a block diagram showing an exemplary management module 121 according to several embodiments. The management module 121 may include one or more processing units (CPUs) 122 for executing modules, programs, applications, or instructions, or combinations thereof, stored in memory 306, and thus performing processing operations; memory 306; and one or more communication buses 304 for interconnecting these components. The one or more communication buses 304 optionally include circuitry (sometimes called a chipset) for interconnecting and controlling communication between components connected by the buses 304. The management module 121 is coupled to a buffer 123 and a storage device 128 by one or more communication buses 304.

[0032] Memory 306 includes high-speed random-access memory such as DRAM, SRAM, DDR RAM, or other random-access solid-state memory devices, and may also include non-volatile memory such as one or more magnetic disk storage devices, optical disk storage devices, flash memory devices, or other non-volatile solid-state memory devices. Memory 306 optionally includes one or more storage devices located remotely from the CPU 122. Memory 306, or the non-volatile memory devices within Memory 306, comprises a computer-readable storage medium. In some embodiments, Memory 306 or the computer-readable storage medium of Memory 306 stores the following programs, modules, or data structures, or combinations thereof, or subsets or supersets thereof.

[0033] An operating system 308 that provides an operational interface between programs, modules, or associated computer entities and their data structures and hardware resources, or between them in combination, thereby enabling programs, modules, or data structures, or combinations thereof, to interact with such hardware resources;

[0034] A data reading module 309 for reading data from the storage device 128, or from the storage server 300, or both;

[0035] A data writing module 311 for writing data to the storage device 128, the storage server 300, the requesting computing entity, or a combination thereof;

[0036] One or more applications 310; and

[0037] A query module for receiving, managing, and providing query results to query requests, wherein the query module is a) A query filter generator 315 for creating and storing a query filter data structure 317; b) A query receiver 319 for receiving queries from a query user computing entity; c) Query parser 321 that determines the subject associated with the received query; d) Comparator 322 for comparing the data age query threshold associated with the received query with the subject data age period associated with the determined subject; e) A query data fetcher 323 for obtaining timed data from the storage device 128 or live query data from the storage server 300 based on the comparator 322; and f) A query result aggregater 325 may include a collection of fetched data into a dataset or query result data structure 327, or both.

[0038] Each of the elements identified above may be stored in one or more of the previously mentioned storage devices 128, 228, or memory 306, and may correspond to a data structure or a set of instructions for performing the functions described above. The modules or programs (i.e., sets of instructions) identified above do not need to be implemented as separate software programs, procedures, or modules; therefore, in various embodiments, various subsets of these modules may be combined or rearranged. In some embodiments, memory 306 may store a subset of the modules and data structures identified above. Furthermore, memory 306 may store additional modules and data structures not described above. In some embodiments, the programs, modules, and data structures stored in memory 306 or the computer-readable storage medium of memory 306 provide instructions for implementing one of the methods described below with reference to Figures 5A and 6. In some embodiments, some or all of these modules may be implemented using dedicated hardware circuitry that encompasses some or all of the module functions.

[0039] Figure 2 shows the management module 121, but it is intended to illustrate the functionality of various features that may be present within the management module rather than to illustrate the structure of the embodiments described herein. As will be understood by those skilled in the art, in practice, the programs, modules, and data structures shown separately can be combined, and some programs, modules, and data structures can be kept separate.

[0040] Figure 3 is a block diagram showing one implementation of a storage device 128 in a query server 100 and a storage device 228 in a storage server 200 according to several embodiments. In various embodiments, storage devices 128, generally shown as storage devices 128.1, 128.2, and 128.3 respectively, can store time-lapsed data. The term "time-lapsed query data" is defined herein as data retrieved from queries of storage server 200 contained within a dataset having a dataset creation timestamp and an estimated dataset end date with a useful period indicator. Time-lapsed data of various time classes can be stored in storage device 128. For example, data that is one week old, one month old, one quarter old, or one year old can be stored in storage device 128.

[0041] Over time, query data can be stored in datasets within the query server 100. Generally, a dataset is a query result obtained by the query server 100 executing queries that have been prefetched by the query server 100 based on predictions, even though they have not been requested by any query user computing entity (prefetching allows such relevant data to be stored locally in the query server 100). In this way, the data in the dataset can later be fetched by the query data fetcher 323, packaged by the query result aggregater 325, and provided to the requesting computing entity, without the query server 100 having to retrieve this data from the storage server 200. As shown in Figure 3, individual or separate storage devices 128.1, 128.2, and 128.3 can store datasets 344, 346, or 348, or combinations thereof, individually or collectively.

[0042] When a dataset is created, the associated data is generally static. Therefore, a dataset can be described as a snapshot of the associated data over time. Furthermore, at the time of creation, each dataset has an associated age. In some cases, a dataset may become obsolete. In other words, the age of a dataset exceeds a predetermined dataset refresh time granularity. In such cases, once the predetermined dataset refresh time granularity has elapsed, the query server 100 can refresh this dataset by executing the same query that was used to create the associated obsolete dataset, and obtain the refreshed query results. These refreshed query results can also become a dataset in that they are obtained by the query server 100 by being predicted and prefetched by the query server 100 and stored locally, without being requested by any query user computing entity.

[0043] In various embodiments, storage devices 228, shown as storage devices 228.1, 228.2, and 228.3, store live query data. The term “live query data” is defined herein as the most recent or current data that is not included in any existing dataset within the query server 100.

[0044] Figure 4 shows a scheme, according to several embodiments, for retrieving live query data from a storage server 200 or time-lapsed data from a previously created dataset.

[0045] In various embodiments, a dataset or a group of related datasets has a predefined thematic data age period specified and stored within a query filter data structure 317 associated with the theme of the dataset or group of related datasets. The thematic data age period may define the predicted usefulness of the data contained within the dataset or group of related datasets. The thematic data age period may be initially set by the query manager computing entity and may be automatically extended when new relational datasets are added to the group of related datasets. If associated with a single dataset, the thematic data age period may be equal to the predicted dataset age. The thematic data age period may also be equal to the period from the creation of the longest-elapsed dataset in the group of related datasets to the predicted usefulness of the shortest-elapsed dataset in the group of related datasets.

[0046] Query A may be received by the query receiver 319. Query A may include a user-defined data age parameter associated with the query, specifying the applicable time period associated with the desired query data result. As illustrated, the user-defined data age parameter of query A is outside the thematic data age period of the dataset, not within it, so the query data fetcher 323 retrieves the required query (live) data from the storage server 200. In other words, the data in the dataset is not long enough to satisfy query A.

[0047] Query B may be received by the query receiver 319. Query B may include a user-defined data age parameter associated with the query, specifying the applicable time period associated with the desired query data result. As shown in the example, since the user-defined data age parameter of query B is within the thematic data age period of at least one dataset, the query data fetcher 323 retrieves the required query (aged) data from the dataset or from a group of relevant datasets. In other words, the data in the dataset is sufficiently old and not too old (i.e., not too old and not obsolete) to satisfy query B.

[0048] In various embodiments, it is generally assumed that the dataset contains all the appropriate data for collecting query results and returning them to the requesting query user computing entity. If, as is known in the art, the dataset does not contain all the appropriate data for collecting query results and returning them to the requesting query user computing entity, the query data fetcher 323 retrieves the appropriate data from the storage server 200.

[0049] Query C may be received by the query receiver 319. Query C may include a user-defined data age parameter associated with the query, specifying the applicable period associated with the desired query data result. As illustrated, the user-defined data age parameter of query C is outside the thematic data age period of the dataset, not within it, so the query data fetcher 323 retrieves the required query (live) data from the storage server 200. In other words, the data in the dataset is either too old or too obsolete to satisfy query C.

[0050] Figures 5A and 5B illustrate a scheme, according to several embodiments, that utilizes a query filter data structure 317 to determine whether to retrieve live query data from the storage server 200 or to retrieve time-lapsed data from a previously created dataset.

[0051] Specifically, Figure 5A illustrates a method 400 for fetching live query data from the storage server 200 or time-lapsed data in a previously created dataset in response to a query, by utilizing a query filter data structure 317. Method 400 begins with a query receiver 319 receiving one or more data queries from a requesting query user computing entity (block 402). For example, as shown, the query server 100 may receive four data queries from one or more requesting query user computing entities. The first data query may specify a user-defined data age parameter "A", a user-defined data age parameter "B", and a related query subject "M". The second data query may specify a user-defined data age parameter "C", a user-defined data age parameter "D", and a related query subject "N". The third data query may specify a user-defined data age parameter "E", a user-defined data age parameter "F", and a related query subject "O". Finally, the fourth data query may specify a user-defined data age parameter "G", a user-defined data age parameter "H", and an associated query subject "P".

[0052] The term “user-defined data parameter” is defined herein as a generic or known customizable parameter that a query user computing entity specifies when initializing a data query. The term “user-defined data age parameter” is defined herein as any type of customizable parameter that a query user computing entity may specify, such as indicating a desired age period or range for query data within the query result data structure 327. For example, a query might request customer sales for the most recent quarter. The user-defined data age parameter for such a query should be a period associated with “the entire most recent quarter.”

[0053] The term “subject” is defined herein as the definition of the common part of various data sources used to fetch and package the data for a relevant query result. For example, the subject “customer sales” might define a query when the relevant query results are obtained from the data source “customer list” and the data source “sales.”

[0054] User-defined data age parameters and data query topics may be specified by the user computing entity and included in the query request, or determined by the query server 100 from the received query request, etc.

[0055] In the following example, query receiver 319 can receive the query <Customer Sales, Entire Most Recent Quarter>.

[0056] The query parser 321 may parse or determine each subject of the received queries (block 404), and method 400 may continue. For example, the query server 100 may determine or parse subject "M" as the subject of the first query, subject "N" as the subject of the second query, subject "O" as the subject of the third query, and subject "P" as the subject of the fourth query.

[0057] In this example, query parser 321 can parse and determine the subject of the exemplary query as <customer sales>.

[0058] Method 400 may continue by having the query module 314 read each query filter data structure 317 associated with the parsed subject (block 406). For example, the query server 100 reads a first query filter data structure 317.1 (not shown) previously created by the query manager computing entity and stored in the query server 100, which identifies the subject data age period "R" and associates it with the subject "M". Similarly, the query server 100 reads a second query filter data structure 317.2 (not shown) previously created by the query manager computing entity and stored in the query server 100, which identifies the subject data age period "S" and associates it with the subject "N". Similarly, the query server 100 reads a third query filter data structure 317.3 (not shown) previously created by the query manager computing entity and stored in the query server 100, which identifies the subject data age period "T" and associates it with the subject "O". Similarly, the query server 100 reads a fourth query filter data structure 317.4 (not shown) that was previously created by the query manager computing entity and stored in the query server 100, which identifies a thematic data age period "U" and associates it with the theme "P".

[0059] In one embodiment, a single query filter data structure 317 may relate to each dataset or the entire set of related datasets.

[0060] In this example, the query module 314 can read the query filter data structure 317 associated with the subject <customer sales>.

[0061] The comparator 322 compares the relevant user-defined data age parameters with the relevant thematic data age period and determines whether the entirety of the compared user-defined data age parameters falls within the thematic data age period (blocks 408, 410), after which method 400 may continue.

[0062] For example, comparator 322 compares a user-defined data age parameter "B" with the thematic data age period "R", a user-defined data age parameter "D" with the thematic data age period "S", a user-defined data age parameter "F" with the thematic data age period "T", and a user-defined data age parameter "H" with the thematic data age period "U".

[0063] In this example, comparator 322 can compare the relevant user-defined data age parameter (i.e., the period associated with the most recent quarter) with the relevant subject data age period (for example, the period from the creation date of the relevant dataset to the predefined useful age within a week) in a read query filter data structure 317 associated with the subject <customer sales> in an existing dataset or a related set of datasets.

[0064] If the entire range of the relevant user-defined data age parameter is not within the subject data age period, or is not thereby defined, the query data fetcher 323 may fetch the query data from the storage server 200 (block 412), and method 400 may continue. This is an example of what might happen if the data in an existing dataset is too long elapsed to satisfy the relevant query, or if it is not long enough to do so. Since the data in such datasets should be either too short or too long elapsed in each situation, the query module 314 effectively decides that the query data should be fetched from the storage server 200.

[0065] If the entirety of the applicable user-defined data age parameter falls within or is defined within the applicable subject data age period, the query data fetcher 323 may continue method 400 by fetching query data from the applicable dataset, the most recent dataset in a set of related datasets, some or all of the related datasets (block 414). Since the data in these exemplary datasets is neither too short in time nor too long old, the query module 314 effectively determines that the query data should be fetched from the applicable dataset.

[0066] Since the entire user-defined data age parameter "B" associated with <Subject M> is not within the subject data age period "R" and is not defined by it, the query data fetcher 323 can fetch query data from the storage server 200 to satisfy the first query, as shown in Figure 5B as an example. Similarly, since the entire user-defined data age parameter "D" associated with <Subject N> is not within the subject data age period "S" and is not defined by it, the query data fetcher 323 can fetch query data from the storage server 200 to satisfy the second query. Similarly, since the entire user-defined data age parameter "F" associated with <Subject O> is within the subject data age period "T" and is defined by it, the query data fetcher 323 can fetch query data from the associated dataset 344 to satisfy the third query. Similarly, since the entire user-defined data age parameter "H" associated with <theme P> lies within the theme data age period "U" and is thus ranged, the query data fetcher 323 can fetch query data from the associated dataset 346 to satisfy the fourth query.

[0067] Method 400 can continue by having the query result aggregater 325 collect or package the fetched data into a query result or query result data structure 327, or both (block 416). The query result data structure 327 may take the form of a packaged query result for delivery to the requesting computing entity of the query user, or it may be packaged into a dataset. For example, the query result aggregater 325 may assemble and package a query result data structure 327.1 (not shown) for a first query, a query result data structure 327.2 (not shown) for a second query, a query result data structure 327.3 (not shown) for a third query, and a query result data structure 327.4 (not shown) for a fourth query.

[0068] Finally, the method 400 may continue with the query module 314 providing the query result data structure 327 to the requesting query user computing entity (block 418). For example, the query module 314 may send the query result data structures 327.1, 327.2, 327.3, and 327.4 to one or more appropriate requesting query user computing entities. Alternatively, or in addition to doing so, the method 400 may continue with the query module 314 locally storing the query result data structure 327 as a dataset in the storage device 128 within the query server 100.

[0069] Figure 6 shows a method 500, according to several embodiments, for adjusting the frequency of a previously set dataset refresh granularity based on a user-defined data age parameter specified in a later user query request, or based on the frequency of queries to the storage server 200, or both.

[0070] Method 500 may be initiated by a query manager computing entity creating a query filter data structure 317 that is associated with an existing dataset or will be associated with a dataset or a set of related datasets (block 502). For example, the query manager computing entity may create the query filter data structure 317, which will be received by the query server 100, via a web browser or the like.

[0071] The query filter data structure 317 may specify or include a subject that defines or will define the query result in the form of the result provided to the query user requesting computing entity, or in the form of a dataset. The query filter data structure 317 may further include a subject data age period associated with the query (block 504). The subject data age period may specify a data age useful span for data associated with or to be associated with the query result, which is initially estimated by the query manager computing entity. For example, the subject data age period may indicate that the expected data lifetime from the created query result could be one hour, one day, one week, one month, one quarter, one year, or ten years, etc.

[0072] The query manager compute entity may further specify within the query filter data structure 317 whether the subject data age period may be modifiable. If it is not modifiable, the query manager compute entity may indicate that the subject data age period is static; if the subject data age period is modifiable, the query manager compute entity may indicate that the subject data age period is dynamic (block 506).

[0073] The query manager compute entity can further configure the initial dataset refresh time granularity (block 508). For example, the query manager compute entity may indicate that the relevant datasets should be refreshed weekly. Thus, a set or series of relevant datasets are created using the same query and prefetched into the query server 100 with the indicated dataset refresh time granularity.

[0074] The query manager computing entity can further set initial memory server 200 frequency thresholds (block 510). For example, the query manager computing entity may indicate the overall maximum frequency at which the query data fetcher 323 can fetch query data from the memory server 200, or it may indicate the maximum frequency at which the query data fetcher 323 can fetch query data from the memory server 200 in relation to each dataset or each set of related datasets.

[0075] The query server 100 may create and store a dataset, or a series of related datasets separated temporally by a dataset refresh time granularity, or both (block 514), and the method 500 may continue. Furthermore, the query user computing entity may send a query request to the query server 100 (block 512), and the method 500 may continue.

[0076] The comparator 322 compares the relevant user-defined data age parameter with the relevant subject data age period and determines whether the entirety of the compared user-defined data age parameter falls within the subject data age period (block 518), after which method 500 may continue.

[0077] If the entire set of user-defined data age parameters falls within or is defined within the relevant subject data age period, the query data fetcher 323 may fetch query data from the relevant dataset (block 516), and method 500 may continue. Since the data in such exemplary datasets is neither too short in time nor too long old, the query module 314 effectively determines that it can fetch such data from the relevant dataset without retrieving query data from the storage server 200.

[0078] If the entirety of the relevant user-defined data age parameter is not within the subject data age period, or is not thereby ranged, the query data fetcher 323 may fetch the query data from the storage server 200 (block 520), and method 500 may continue. This is an example of what might happen if the data in an existing dataset associated with the subject of the user query is too old or not old enough to satisfy the query. Since the data in such datasets should be either too short or too old in each of the circumstances, the query module 314 effectively determines that the relevant datasets do not contain the requested data and that the query data fetcher 323 should fetch this data from the storage server 200.

[0079] Method 500 may continue with query module 314 reducing the dataset refresh time granularity associated with existing datasets associated with the subject of the user query (block 521). The amount or duration of this reduction in dataset refresh time granularity may be predetermined. For example, if the initial refresh time granularity associated with existing datasets associated with the subject of the user query is set to one week, query module 314 may reduce the refresh time granularity to one day or the like.

[0080] The query server 100 may then create and store the next related dataset, separated in time only by the reduced dataset refresh time granularity (block 522), and method 500 may continue.

[0081] Method 500 may continue if the query module 314 determines (block 524) whether the query data fetcher 323 is fetching query data from the storage server 200, exceeding the frequency threshold of queries to the storage server 200. If the query data fetcher 323 is fetching query data from the storage server 200, Method 500 may continue (block 526) by increasing the dataset refresh time granularity associated with one or more existing datasets (e.g., datasets associated with the subject of the user query). The amount or duration by which this dataset refresh time granularity is increased may be predetermined. For example, if the current refresh time granularity associated with an existing dataset is one day, the query module 314 may increase the refresh time granularity to one week or the like. Method 500 may then return to block 502.

[0082] If the query data fetcher 323 has not fetched query data from the storage server 200, exceeding the query frequency threshold for the storage server 200, method 500 may return to block 512.

[0083] This embodiment may be a system, method, or computer program product, or a combination thereof. The computer program product may include a computer-readable storage medium (or a plurality of computer-readable storage mediums) having computer-readable program instructions for causing a processor to execute aspects of the present invention. The computer-readable storage medium may be a tangible device capable of holding and storing instructions used by an instruction execution device. The computer-readable storage medium may be, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination thereof. A non-exclusive list of more specific examples of computer-readable storage mediums includes portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanically encoded devices such as punch cards or grooved raised structures on which instructions are recorded, and any suitable combination of the above. In this specification, computer-readable storage media themselves are not considered to be radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through fiber optic cables), or transient signals such as electrical signals transmitted through wires.

[0084] The computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to each computing / processing device, or they may be downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network may include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives computer-readable program instructions from the network and transfers the computer-readable program instructions for storage in a computer-readable storage medium within each computing / processing device.

[0085] The computer-readable program instructions that perform the operation of the present invention may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Java®, Smalltalk®, or C++, and conventional procedural programming languages ​​such as the C programming language or similar programming languages. The computer-readable program instructions may run as a standalone software package, either entirely on the user's computer, partially on the user's computer, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or wide area network (WAN), or the connection may be to an external computer (for example, via the Internet using an Internet service provider). In some embodiments, for example, an electronic circuit including a programmable logic circuit, a field-programmable gate array (FPGA), or a programmable logic array (PLA) can be personalized by executing computer-readable program instructions using state information of computer-readable program instructions in order to perform an aspect of the present invention.

[0086] Aspects of the present invention are described herein with reference to flowcharts or block diagrams, or both, of methods, apparatuses (systems), and computer program products according to embodiments of the present invention. It will be understood that each block in a flowchart or block diagram, or both, and combinations of blocks in a flowchart or block diagram, or both, can be implemented by computer-readable program instructions. These computer-readable program instructions may be provided to a processor of a general-purpose computer, a dedicated computer, or other programmable data processing device for generating machines, thereby creating means for instructions executed via the computer's processor or other programmable data processing device to implement functions / operations specified in one or more blocks in a flowchart or block diagram, or both. These computer-readable program instructions may also be stored in a computer-readable storage medium capable of instructing a computer, a programmable data processing device, or other device, or a combination thereof, to function in a particular manner, thereby the computer-readable storage medium storing the instructions may contain a product containing instructions that implements the modes of functions / operations specified in one or more blocks in a flowchart or block diagram, or both.

[0087] Furthermore, computer-readable program instructions can also be loaded into a computer, other programmable data processing device, or other device to create a computer implementation process by executing a series of operational steps on the computer, other programmable device, or other device, thereby enabling the instructions executed on the computer, other programmable device, or other device to implement functions / operations specified in one or more blocks of a flowchart or block diagram, or both.

[0088] The flowcharts and block diagrams in the drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of instructions containing one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions described in a block may be performed in an order different from the order shown in the drawing. For example, two blocks shown consecutively may actually be executed substantially simultaneously, or such blocks may, depending on the functions involved, be executed in reverse order. It should also be noted that each block in a block diagram or flowchart, or both, and any combination of blocks in a block diagram or flowchart, or both, may be implemented by an application-specific hardware-based system that performs a specified function or operation, or a combination of application-specific hardware and computer instructions.

[0089] The descriptions of various embodiments of the present invention are presented for illustrative purposes only and are not intended to be comprehensive or limitless to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the embodiments described. The terminology used herein has been selected to best describe the principles, practical applications, or technical improvements to practical applications found in the market of the embodiments, or to enable other persons skilled in the art to understand the embodiments disclosed herein.

Claims

1. A query system comprising a query server having a processor and memory, wherein the memory includes a query module, and when the query module is called by the processor, it sends to the query server, The query manager compute entity receives multiple query filter data structures, each associated with a query subject and including the subject data age period corresponding to that query subject; Receiving queries from a query user computing entity that include a request for query results and a user-defined data age parameter indicating the data age of the requested query result data; Parse the aforementioned query to determine the query subject; To identify one query filter data structure among the plurality of query filter data structures associated with the query subject; To determine whether the range of data ages indicated by the user-defined data age parameter falls within the subject data age period, by comparing it with the subject data age period of the one query filter data structure; If the range of data ages indicated by the user-defined data age parameter falls within the subject data age period, the query server shall fetch query result data from the dataset associated with the one query filter data structure; and If the data age range indicated by the user-defined data age parameter is not within the subject data age period, the query server shall fetch query result data from a storage server that is connected to the query server via the network in a communicable manner. A query system that performs the following actions.

2. The query system according to claim 1, wherein the query result data fetched from the dataset is data that has been stored for a period of time.

3. The query system according to claim 1, wherein the query result data fetched from the storage server is live data.

4. The query system according to claim 1, wherein if the range of data ages indicated by the user-defined data age parameter falls within the subject data age period, the query result data is fetched from the dataset and one or more other related datasets, each associated with one of the query filter data structures.

5. The query system according to any one of claims 1 to 4, wherein each of the plurality of query filter data structures includes a dataset refresh time granularity.

6. When the query module is called by the processor, it will communicate to the query server: The query system according to claim 5, further comprising reducing the refresh time granularity of the dataset of one query filter data structure when query result data is fetched from the storage server.

7. When the query module is called by the processor, it will communicate to the query server: The query system according to claim 6, further comprising creating relational datasets related to the dataset associated with the one query filter data structure, with a reduced dataset refresh time granularity.

8. When the query module is called by the processor, it will communicate to the query server: The query system according to claim 7, further comprising determining whether query result data is being fetched from the storage server at a frequency higher than a predetermined frequency threshold.

9. When the query module is called by the processor, it will communicate to the query server: The query system according to claim 8, further increasing the dataset refresh time granularity of one query filter data structure when query result data is fetched from the storage server at a frequency higher than the predetermined frequency threshold.

10. A computer program for fetching query result data, wherein the computer program comprises program instructions, and the program instructions are The query manager compute entity receives multiple query filter data structures, each associated with a query subject and including the subject data age period corresponding to that query subject; Receiving queries from a query user computing entity that include a request for query results and a user-defined data age parameter indicating the data age of the requested query result data; Parse the aforementioned query to determine the query subject; To identify one query filter data structure among the plurality of query filter data structures associated with the query subject; To determine whether the range of data ages indicated by the user-defined data age parameter falls within the subject data age period, by comparing it with the subject data age period of the one query filter data structure; If the range of data age indicated by the user-defined data age parameter falls within the subject data age period, the query server fetches query result data from the dataset associated with the one query filter data structure; and If the range of data ages indicated by the user-defined data age parameter is not within the subject data age period, the query server has a readable computer program that causes the processor to fetch query result data from a storage server connected to the query server via a network.

11. The computer program according to claim 10, wherein the query result data fetched from the dataset is data that has been stored for a period of time.

12. The computer program according to claim 10, wherein the query result data fetched from the storage server is live data.

13. The computer program according to claim 10, wherein if the range of data ages indicated by the user-defined data age parameter falls within the subject data age period, the query result data is fetched from the dataset and one or more other related datasets, each associated with one of the query filter data structures.

14. The computer program according to any one of claims 10 to 13, wherein each of the plurality of query filter data structures includes a dataset refresh time granularity.

15. When the query module is called by the processor, it sends a query to the query server, The computer program according to claim 14, further causing the refresh time granularity of the dataset of one query filter data structure to be reduced when query result data is fetched from the storage server.

16. When the query module is called by the processor, it will communicate to the query server: The computer program according to claim 15, further causing the computer program to create relational datasets relating to the dataset associated with the one query filter data structure, with a reduced dataset refresh time granularity.

17. When the query module is called by the processor, it will communicate to the query server: The computer program according to claim 16, further comprising determining whether query result data is being fetched from the storage server at a frequency higher than a predetermined frequency threshold.

18. When the query module is called by the processor, it will communicate to the query server: The computer program according to claim 17, further causing the refresh time granularity of the dataset of one query filter data structure to increase when query result data is fetched from the storage server at a frequency higher than the predetermined frequency threshold.

19. A method for fetching query result data, which is performed by a query server, The step of receiving multiple query filter data structures from the query manager computing entity, each associated with a query subject and including the subject data age period corresponding to that query subject; The step of receiving a query from a query user computing entity, which includes a request for query results and a user-defined data age parameter indicating the data age of the requested query result data; The step of parsing the aforementioned query and determining the query subject; A step of identifying one query filter data structure among the plurality of query filter data structures associated with the query subject; A step of determining whether the range of data ages indicated by the user-defined data age parameter falls within the thematic data age period, compared with the thematic data age period of the one query filter data structure; If the range of data ages indicated by the user-defined data age parameter falls within the subject data age period, the query server fetches query result data from the dataset associated with the one query filter data structure; and If the range of data age indicated by the user-defined data age parameter is not within the subject data age period, the query server fetches query result data from a storage server that is connected to the query server via the network. A method for fetching query result data, which includes the following features.

20. The method for fetching query result data according to claim 19, wherein if the range of data ages indicated by the user-defined data age parameter falls within the subject data age period, query result data is fetched from the dataset and one or more other related datasets each associated with the one query filter data structure.

Images