Patent ID: 12197441

While embodiments are described herein by way of example for several embodiments and illustrative drawings, those skilled in the art will recognize that the embodiments are not limited to the embodiments or drawings described. It should be understood that the drawings and detailed description thereto are not intended to limit embodiments to the particular form disclosed, but on the contrary, the intention is to cover all modifications, equivalents and alternatives falling within the spirit and scope as defined by the appended claims. As used throughout this application, the word “may” is used in a permissive sense (i.e., meaning having the potential to), rather than the mandatory sense (i.e., meaning must). Similarly, the words “include”, “including”, and “includes” mean including, but not limited to.

This specification includes references to “one embodiment” or “an embodiment.” The appearances of the phrases “in one embodiment” or “in an embodiment” do not necessarily refer to the same embodiment. Particular features, structures, or characteristics may be combined in any suitable manner consistent with this disclosure.

DETAILED DESCRIPTION

Various embodiments of systems and processes for paginated synchronous database queries are described herein. A provider network may include one or more computing resources configured to provide database services. For example, the computer resources may include one or more storage devices configured to implement data stores configured to store databases on behalf of clients of a multi-tenant service. The computing resources may also implement a query engine configured to manage queries directed to the databases. The computing resources may include computing nodes configured to implement the queries. In some embodiments, the computing nodes maybe organized as computing clusters, such that the computing nodes in respective computing clusters are coordinated to implement the queries assigned to that respective computing cluster.

The query engine may be configured to determine which computing cluster to execute the query based on numerous factors. For example, the query engine may determine which computing cluster to execute the query based on resource utilization of respective computing clusters, projected utilization of the query if run at the respective computing clusters, or configuration requirements for the query. In some situations, the query or a response to the query may be stored in a data page until the response is ready to be sent back to the client that sent the query.

A query may be classified based on a duration of time required to complete execution of the query, in some situations. For example, a threshold duration may result in classification of queries as short queries or long queries depending on whether execution time of the query is less than or greater than the threshold duration. In some embodiments, responses to short queries may be sent back to the client associated with the query, and responses to long queries may be held in data pages or other data storage for subsequent retrieval.

After the query engine initiates execution of the query at the selected computing cluster, the query engine may initiate a loop of actions to manage the query. In some embodiments, the query engine may wait a time period, such as the threshold duration of time that is used to determine whether a query is a short query or a long query. In some implementations, during the wait, the query engine may be configured to block subsequent queries or requests from the client. For example, the query engine may reject subsequent queries from the client to prevent excessive or redundant queries from being processed while the original query is still being executed for the client. After the time period elapses, the query engine may determine whether the query is completed or fulfilled. If the query is completed within the time period, such that the query may be classifiable as a short query, the response to the query may be sent to the client that sent the query. If the query is not yet completed within the time period, such that the query may be classifiable as a long query, the query engine may send information to the client indicating that the query is not yet completed. The information may include a token for pagination and a query identifier for the query. The token and the query identifier may be recorded as metadata for the query.

The query may send an additional query including the token and the query identifier to indicate to the query engine that the additional query is a continuation of the previously sent query. The query engine may continue the loop of actions to manage the query. The loop of actions may be iterated by the query engine by waiting the time period and blocking subsequent queries after the additional query while waiting. The loop of actions may further be iterated by determining whether the query has been completed or fulfilled. If the query has been completed, the response to the query may be sent to the client, and the loop may be terminated. If the query has not been fulfilled, another token and the query identifier may be sent to the client to perform another iteration of the loop. The loop of actions may continue until execution of the query is completed, and the response to the query is sent to the client.

The query engine may also have a size limit for query responses that are sent to clients. For example, the query engine may have limited bandwidth for query responses such that responses are fragmented to multiple portions that have a file size less than or equal to the size limit. The multiple portions may be sent at different points in time separated by a time period, such as the threshold duration of time that is used to determine whether a query is a short query or a long query. Each portion of the multiple portions of the response may be sent sequentially to the client while waiting the time period between each portion. When a final portion of the response to the query is sent to the client, the final portion may include an indication that the response to the query has been completely sent to the client.

In one aspect, a system is described. The system includes one or more storage devices configured to implement a data store to store database data. The system also includes one or more computing devices configured to implement a query engine. The query engine is configured to receive, from a client, a database query. The query engine is also configured to initiate performance of the query at the data store. The query engine is also configured to compare a performance time of the query with a performance time threshold. Based on a determination that the performance time exceeds the performance time threshold, the query engine is configured to send, to the client, a query identifier for the query and a token indicating that the query has not been completed. The query engine may be configured to receive, from the client, an additional query for the data stored at the database, wherein the additional query comprises the token and the query identifier. Based on a determination that the performance time does not exceed the performance time threshold, the query engine may send a response to the query to the client, the response comprising data requested by the query.

In another aspect, a method is described. The method includes receiving a query at a database system from a client. The method also includes initiating performance of the query at the database system. The method further includes selecting, by the database system, a protocol for returning a result of the query based on a performance time of the query at the database system. The method also includes returning, by the database system, the result of the query according to the selected protocol.

In yet another aspect, a one or more computer-readable storage media is described. The one or more computer-readable storage media store instructions that, when executed on or across one or more processors, cause the one or more processors to perform operations. The operations include in response to receiving a query at a database system from a client, initiating performance of the query at the database system. The operations also include selecting, by the database system, a protocol for returning a result of the query based on a performance time of the query at the database system. The operations further include returning, by the database system, the result of the query according to the selected protocol.

FIG.1is a block diagram illustrating a system100for paginated synchronous database querying, according to some embodiments. The system100may include a client110and a database system120, according to some embodiments. The client110may be communicatively coupled to the database system120via a network150. In some embodiments, the database system120may be implemented as part of a provider network. The database system120may include one or more storage devices configured to implement a data store140, according to some embodiments. The data store140may be configured to store one or more databases, such as database142, according to some embodiments.

The client110may include one or more computing devices such as one or more processors and a memory, according to some embodiments. For example, the memory may store instructions that, when executed on or across the one or more processors, cause the one or more processors to implement an application. The application may include application logic112, according to some embodiments. For example, the application logic112may cause the client110to perform various tasks in accordance with the instructions stored on the memory. In some embodiments, the application logic112may include instructions to generate a synchronous query114. The client110may be configured to send the synchronous query114to the database system120via the network150.

The database system120may receive the synchronous query114to perform a query at database142on behalf of the client110, according to some embodiments. For example, the database system120may include a control plane configured to receive the database query124from the client110. In some embodiments, the database system120may also be configured to receive the synchronous query114in accordance with an API, according to some embodiments. For example, the client110may generate the synchronous query114to include arguments in accordance with the API and send the synchronous query114to the database system120via the API, including an indication of the database142and an argument indicating data142to be retrieved from the database142.

The database system120may be configured to provide a network endpoint for the client110to interact with the database system120, according to some embodiments. For example, the control plane124configured to provide the network endpoint to the client110in response to a request to establish the database142. The client110may be configured to access the network endpoint to query the database142, such as by sending the synchronous query114via the network endpoint.

A provider network may include one or more computing resources configured to implement services, including database system120, that are provided to clients, such as the client110, according to some embodiments. For example, the provider network may be configured to provide services to the clients via the network150as a remote or cloud-based service provider. In other embodiments, the provider network may be configured to provide services to clients located within the provider network, such as virtualized computing systems hosted at the provider network via another service.

The database system120may include computing resources configured to implement query processing clusters. The query processing clusters may include a plurality of query processing nodes, according to some embodiments. The query processing nodes may designate one of the query processing nodes to function as a query engine122, according to some embodiments. The query engine122may be configured to manage queries to databases, such as the database142, according to some embodiments. For example, the query engine122may manage incoming queries from clients and implement query workers or nodes to query the database142. In some embodiments, the query engine122may be configured to allocate computing resources from the query processing cluster to be configured as a query worker or node to perform at least a portion of a given query. For example, the query engine122may request or allocate the computing resources in order to scale processing capability for processing queries to databases at the data store140.

The client110may initiate a connection to the database system120by sending the synchronous query114. In some embodiments, the connection may be held open so long as the client110is awaiting a response to the synchronous query114from the database system120. For example, the connection may remain active between a time when the synchronous query114is sent to the database system120and a time when the database system120responds to the synchronous query114with the data144from the database142. In some embodiments, the query engine122may terminate the connection between the client110and the database system120to conserve resources. For example, the query engine122may be configured to terminate the connection after a period of time, such as performance time threshold124. In some situations, the query engine122maintaining an open connection while idle without active transmission of data would increase operational costs of the provider network. The query engine122may reduce operational costs and improve computing resource efficiency by terminating the connection between the client110and the database system120when a response to the synchronous query114is not ready to be sent to the client110.

The query engine122may manage queries by limiting repeated queries by clients while queries are being processed on behalf of the clients, according to some embodiments. For example, the client110may send the synchronous query114to retrieve the data144from the database142. The query engine122may be configured to limit the client110from sending asynchronous queries115while the synchronous query114is being processed by the query workers123. In some embodiments, the query engine122may be configured to limit responsiveness to the asynchronous queries115sent by the client110. For example, the query engine122may be configured to block the additional queries or ignore the asynchronous queries115as they are sent by the client110until the performance time threshold124has elapsed.

Protocol selection logic126may be configured to classify queries based on execution times for the queries, according to some embodiments. For example, the queries may be classified based on whether the execution time for respective queries satisfy a threshold time period, such as performance time threshold124. The query engine122may cause execution of a query and wait for the performance time threshold124to elapse before proceeding, according to some embodiments. For example, the query engine122may wait for the performance time threshold124then determine whether the execution of the query is complete while rejecting any other incoming queries from the client110while waiting. The query engine122may determine whether the execution of the query is completed within the performance time threshold124in various ways. In some embodiments, the query engine122may receive a response to the query from the worker tasked with executing the query to retrieve the data144from the database142, where the response includes the data144. For example, the query engine122may determine that the execution of the query is completed in response to receiving the response to the query from the worker. The response to the query may implicitly or explicitly indicate to the query engine122that the query has finished execution by the worker. In some embodiments, the protocol selection logic126may classify queries that are completed within one iteration of the performance time threshold124as being short queries.

The query engine122may include protocol selection logic126configured to determine whether the query engine122should use a synchronous protocol or an asynchronous protocol to process queries received from the client110, according to some embodiments. For example, the protocol selection logic126may determine whether queries received from the client110include information indicating that the queries are primary or secondary queries. As another example, queries may be primary or original queries based on a determination that the queries do not include a token or query identifier that refer to another query.

In situations when the query is not completed within one iteration of the performance time threshold124, the protocol selection logic126may classify the query as a long query. Based on a determination that the query is not completed after the performance time threshold124has elapsed, the query engine122may be configured to send information to the client110indicating that the query has not been completed, according to some embodiments. For example, the query engine122may send to the client110a token for pagination and a query identifier for the synchronous query114. In some embodiments, the information sent to the client110may indicate that no data responsive to the query114is included in the information. In some embodiments, the query engine122may store the token and the query identifier as metadata for the synchronous query114. For example, the query engine122may store query metadata134for the database query144including storing the token as token136and the query identifier as query identifier138. In some embodiments, the query metadata134may include metadata for multiple ongoing queries for multiple clients.

In some embodiments, the query engine122may close the connection to the client110responsive to sending the information to the client110. For example, the query engine122may close or terminate the connection to the client110that may have been held open while the query was being executed. The query engine122may terminate the connection to the client110to reduce computational overhead costs for maintaining an open connection while not transferring the data144to the client110. After the connection is terminated, the client110may issue an asynchronous query115to the database system120. For example, the other query may include the token and the query identifier. The token and the query identifier may indicate to the database system120that the asynchronous query115is a continuation of the synchronous query114such that the client110has yet to receive a response to the synchronous query114.

The client110may be configured to send asynchronous queries115after subsequent connections are terminated until the client110receives a response to the synchronous query114, according to some embodiments. For example, the client110may be configured to generate the asynchronous queries115based on the database system120indicating that the synchronous query114has not been completed or fulfilled. In some embodiments, the client110may send the asynchronous queries115to the database system120such that the database system120may repeat a similar set of actions as responsive to the synchronous query114originally sent by the client110. For example, the database system120may receive an asynchronous query115that includes the token as token116and the query identifier for the synchronous query114as query identifier118.

The database service may parse the asynchronous queries115to identify an original query based on the query metadata134for the synchronous query114, according to some embodiments. For example, the query engine may compare the token116and the query identifier118against the token136and the query identifier138stored in the query metadata134. Based on identifying the original query for the asynchronous queries115, the query engine122may continue to wait for a response for the synchronous query114.

The query engine122may be configured to determine whether a performance time of the query satisfies the performance time threshold124, according to some embodiments. The query engine122may wait for a duration of the performance time threshold124and block subsequent queries from the client110during the performance time threshold124, according to some embodiments. After waiting for the performance time threshold124, the query engine122may determine whether the query worker has completed the synchronous query114. Based on a determination that the query worker124has completed the synchronous query114, the data144may be transferred from the database142to a destination, according to some embodiments. For example, the query engine122may receive the data144and send the data144to the client110. As another example, the query engine may receive the data144and send the data144to a data cache storage128. In some embodiments, the data cache storage128may be configured to store the data144for subsequent retrieval by the client110in an asynchronous manner with respect to the queries sent by the client110. For example, the data cache storage128may include a cache data store configured to store data on behalf of the client110as retrieved from the database142, where the data cache storage128has a different retention policy compared to the database142.

The data cache storage128may be configured to store the data144in a plurality of pages to allow individual pages to be sent to the client110in accordance with a transfer size limit. For example, respective sizes may be less than or equal to the transfer size limit. In other embodiments, data stored in the data cache storage128may be transferred to the client110in transmission configured to not exceed the transfer size limit.

Based on a determination that the query worker has not completed the synchronous query114, the query engine122may send a new token and the query identifier138to the client110to indicate that the synchronous query114is still not yet completed, according to some embodiments. For example, the query engine122may generate the new token based on the token136, such as by incrementing a counter for the token136. As another example, the token136may be resent to the client110without any modifications. If the new token is generated and is different from the token136previously sent to the client110, the new token may be stored as the token136in the query metadata134. The client110may send asynchronous queries115, and the query engine122may repeat the process until the query worker has completed the synchronous query114to retrieve the data144from the database142, according to some embodiments.

FIG.2is a block diagram of provider network200for a managed database as a service, according to some embodiments. The provider network200may be configured to provide various services to clients250via a network260, according to some embodiments. The provider network200may include database service210configured to provide computing services. The provider network200may also include a storage service220, and other services240, according to some embodiments.

The provider network200can be formed as a number of regions, where a region is a separate geographical area in which the cloud provider clusters data centers. Each region can include two or more availability zones connected to one another via a private high-speed network, for example a fiber communication connection. An availability zone (also known as an availability domain, or simply a “zone”) refers to an isolated failure domain including one or more data center facilities with separate power, separate networking, and separate cooling from those in another availability zone. Preferably, availability zones within a region are positioned far enough away from one other that the same natural disaster should not take more than one availability zone offline at the same time. Customers can connect to availability zones of the provider network200via a publicly accessible network (e.g., the Internet, a cellular communication network), such as the network260. Regions are connected to a global network which includes private networking infrastructure (e.g., fiber connections controlled by the cloud provider) connecting each region to at least one other region. The provider network200may deliver content from points of presence outside of, but networked with, these regions by way of edge locations and regional edge cache servers. An edge location can be an extension of the cloud provider network outside of the traditional region/AZ context. For example, an edge location can be a data center positioned to provide capacity to a set of customers within a certain latency requirement, a set of servers provided to a customer's premises, or a set of servers provided within (or forming part of) a cellular communications network, each of which can be controlled at least in part by the control plane of a nearby AZ or region. This compartmentalization and geographic distribution of computing hardware enables the provider network200to provide low-latency resource access to customers on a global scale with a high degree of fault tolerance and stability.

The traffic and operations of the cloud provider network may broadly be subdivided into two categories in various embodiments: control plane operations carried over a logical control plane and data plane operations carried over a logical data plane. While the data plane represents the movement of user data through the distributed computing system, the control plane represents the movement of control signals through the distributed computing system. The control plane generally includes one or more control plane components distributed across and implemented by one or more control servers. Control plane traffic generally includes administrative operations, such as system configuration and management (e.g., resource placement, hardware capacity management, diagnostic monitoring, system state information). The data plane includes customer resources that are implemented on the cloud provider network (e.g., computing instances, containers, block storage volumes, databases, file storage). Data plane traffic generally includes non-administrative operations such as transferring customer data to and from the customer resources. Certain control plane components (e.g., tier one control plane components such as the control plane for a virtualized computing service) are typically implemented on a separate set of servers from the data plane servers, while other control plane components (e.g., tier two control plane components such as analytics services) may share the virtualized servers with the data plane, and control plane traffic and data plane traffic may be sent over separate/distinct networks.

As noted above, provider network200may implement various computing resources or services, such as a database service210, a block-based storage service220, and other service(s)240which may be any other type of network based services, including various other types of storage (e.g., database service or an object storage service), data processing, analysis, communication, event handling, visualization, and security services not illustrated).

In various embodiments, the components illustrated inFIG.2may be implemented directly within computer hardware, as instructions directly or indirectly executable by computer hardware (e.g., a microprocessor or computer system), or using a combination of these techniques. For example, the components ofFIG.2may be implemented by a system that includes a number of computing nodes (or simply, nodes), each of which may be similar to the computer system embodiment illustrated inFIG.11and described below. In various embodiments, the functionality of a given system or service component (e.g., a component of data storage service220) may be implemented by a particular node or may be distributed across several nodes. In some embodiments, a given node may implement the functionality of more than one service system component (e.g., more than one data store component).

Database service210may offer database resources according to various configurations for client250operation. For example, the database service210may include query processing clusters216configured to manage queries for data store218to retrieve or modify data219. Management interface214may implement the workflows, tasks, or other operations to handle database requests, including, but not limited to establishing databases, disabling databases, or modifying databases.

Database service210may implement control plane212, which may include various features to manage the Database service210on behalf of client(s)250, in some embodiments. For example, control plane212may implement various interfaces that transmit information on behalf of the clients250. Control plane212may also implement the management interface214, which may support various operations to configure or enable features, deploy, start, stop, pause, resume, or other controls for the database service210. Control plane212may also support various features related to implementing databases as a service.

Database service210may also include front end services215configured to provide client-facing services for interacting with the database service210. Database service210may include router217configured to direct client queries to the query processing clusters216for obtaining data219from the data store218.

Interfaces may include various types of interfaces, such as a command line interface, graphical user interface, and/or programmatic interface (e.g., Application Programming Interfaces (APIs)) in order to perform requested operations. An API refers to an interface and/or communication protocol between a client and a server, such that if the client makes a request in a predefined format, the client should receive a response in a specific format or initiate a defined action. In the cloud provider network context, APIs provide a gateway for customers to access cloud infrastructure by allowing customers to obtain data from or cause actions within the cloud provider network, enabling the development of applications that interact with resources and services hosted in the cloud provider network. APIs can also enable different services of the cloud provider network to exchange data with one another.

Provider network200may also implement block-based storage service230, in various embodiments, for performing storage operations. Block-based storage service230may be a storage system that provides block level storage for storing one or more sets of data volumes of data that may be mapped to particular clients (e.g., a virtual compute instance of virtual compute service210), providing virtual block-based storage (e.g., hard disk storage or other persistent storage) as a contiguous set of logical blocks. In some embodiments, block-based storage service230may store data in a data store.

Generally speaking, clients250may encompass any type of client configurable to submit network-based requests to provider network200via network260, including requests for storage services (e.g., a request to create a replication job in migration service230, etc.). For example, a given client250may include a suitable version of a web browser or may include a plug-in module or other type of code module that may execute as an extension to or within an execution environment provided by a web browser. Alternatively, a client250may encompass an application (or user interface thereof), a media application, an office application or any other application that may make use of resources in provider network200to implement various applications. In some embodiments, such an application may include sufficient protocol support (e.g., for a suitable version of Hypertext Transfer Protocol (HTTP)) for generating and processing network-based services requests without necessarily implementing full browser support for all types of network-based data. That is, client250may be an application may interact directly with provider network200. In some embodiments, client250may generate network-based services requests according to a Representational State Transfer (REST)-style network-based services architecture, a document- or message-based network-based services architecture, or another suitable network-based services architecture.

In some embodiments, a client250may provide access to provider network200to other applications in a manner that is transparent to those applications. For example, client250may integrate with an operating system or file system to provide storage on a data storage service (e.g., a block-based storage service230). However, the operating system or file system may present a different storage interface to applications, such as a conventional file system hierarchy of files, directories and/or folders. In such an embodiment, applications may not need to be modified to make use of the storage system service model. Instead, the details of interfacing to the data storage service may be coordinated by client250and the operating system or file system on behalf of applications executing within the operating system environment.

Clients250may convey network-based services requests to and receive responses from provider network200via network260. In various embodiments, network260may encompass any suitable combination of networking hardware and protocols necessary to establish network-based-based communications between clients250, user devices252and provider network200. For example, network260may generally encompass the various telecommunications networks and service providers that collectively implement the Internet. Network260may also include private networks such as local area networks (LANs) or wide area networks (WANs) as well as public or private wireless networks. For example, both a given client250and provider network260may be respectively provisioned within enterprises having their own internal networks. In such an embodiment, network260may include the hardware (e.g., modems, routers, switches, load balancers, proxy servers, etc.) and software (e.g., protocol stacks, accounting software, firewall/security software, etc.) necessary to establish a networking link between given client250and the Internet as well as between the Internet and provider network200. It is noted that in some embodiments, clients250may communicate with provider network200using a private network rather than the public Internet.

In some embodiments, provider network200may include the hardware (e.g., modems, routers, switches, load balancers, proxy servers, etc.) and software (e.g., protocol stacks, accounting software, firewall/security software, etc.) necessary to establish a networking links between different components of provider network200, such as virtualization hosts, control plane components as well as external networks260(e.g., the Internet). In some embodiments, provider network200may employ an Internet Protocol (IP) tunneling technology to provide an overlay network via which encapsulated packets may be passed through the internal network using tunnels. The IP tunneling technology may provide a mapping and encapsulating system for creating an overlay network and may provide a separate namespace for the overlay layer and the internal network layer. Packets in the overlay layer may be checked against a mapping directory to determine what their tunnel target should be. The IP tunneling technology provides a virtual network topology; the interfaces that are presented to clients250may be attached to the overlay network so that when a client250provides an IP address that they want to send packets to, the IP address is run in virtual space by communicating with a mapping service that knows where the IP overlay addresses are.

FIG.3is a timeline diagram illustrating a data flow300between a client and a database service, according to some embodiments. The database service may be implemented as part of a provider network, such as the provider network ofFIG.1. The database service may correspond to the database system120ofFIG.1. Client302may correspond to the client110ofFIG.1, according to some embodiments. Query processing cluster303may include query engine304and query node(s)306, according to some embodiments. Query engine304may correspond to the query engine122ofFIG.1, according to some embodiments. Database308may correspond to the database142ofFIG.1, according to some embodiments.

The client302may be configured to send, to a query engine304of a database service, a query to retrieve data from database308, at310. The query may correspond to the synchronous query114ofFIG.1, according to some embodiments. The query may indicate a type of data to retrieve from the database308, according to some embodiments.

The query engine304may instantiate the query nodes306to perform the query, at312. In some embodiments, the query engine304may cause deployment of the query nodes306. For example, the query nodes306may be deployed from a pool of nodes of the provider network. In some embodiments, the query engine304may send information indicating the query to the query nodes306. For example, the query engine304may provide an indication of the requested data and the database from which the query nodes306are to obtain the requested data.

The query nodes306may perform the query, at314. The query nodes306may be configured to execute the query responsive to instantiation by the query engine304, according to some embodiments. The query may be performed over a period of time such that other aspects of the database service may be configured to perform additional actions while the query is being performed.

While the query is being performed by the query nodes306, the client302and the query engine304may continue to iteratively loop asynchronously relative to the query nodes306, at316. The query engine304may be configured to determine whether the query has been completed at the query nodes306within a performance time threshold, at318. In some embodiments, the performance time threshold may correspond to the performance time threshold124ofFIG.1. The performance time threshold may be a threshold time period may be compared against execution times of queries to determine whether the queries are classifiable as short queries or long queries. In some embodiments, while the query engine304is waiting for the performance time threshold to elapse, the query engine304may be configured to reject or block subsequent query attempts from the client302. For example, the query engine304may ignore or affirmatively decline the subsequent query attempts until the performance time threshold has elapsed.

The query engine304may be configured to determine whether the query has been completed at the query nodes306, at318. In some embodiments, the query engine304may be configured to determine whether the query node306has been completed based on receiving a response from the query nodes306indicating the results of the query. In other embodiments, the query engine304may be configured to poll the query node306to determine whether the query has been completed. In yet other embodiments, the query engine304may be configured to analyze metadata for the query nodes306to identify a flag that indicates that the query has been completed.

Based on a determination that the query is not completed, the query engine304may send a query token and a token for the query to the client302, at320. In some embodiments, the query identifier may be used by the query engine304to identify the query originally sent by the client302. For example, the query engine304may be configured to identify ongoing queries according to query identifiers provided by the client302. In some embodiments, the query engine304may be configured to record the query identifier and the token as metadata for the query. For example, the query engine304may be configured to store metadata for queries sent by clients to track long queries that have not yet been completed by respective ones of the query nodes306. In some embodiments, the query engine304may be configured to terminate the connection between the client302and the query engine304after sending the query identifier and the token to the client302. For example, the query engine304may reduce operational overhead costs by terminating the connection while the query is not yet completed by the query nodes306to mitigate having the connection remain open while no data resulting from the query is being transmitted to the client302. In some embodiments, the token may be incremented for each iteration of the process. For example, the token may be incremented for every other token that has been sent to the client302relating to the query sent at310.

The client302may be configured to send another query to retrieve the data, where the other query includes the query identifier and the token, at322. The other query may correspond to the asynchronous query115ofFIG.1, according to some embodiments. In some embodiments, the client302may send the other query after termination of the connection by the query engine304. For example, the query engine304may terminate the connection to conserve bandwidth or connection resources, and the client302may reestablish the connection at a later time to attempt to obtain the data requested in the query.

While the query is being performed by the query nodes306, the process may return to316to continue another iteration of the loop until the query has been completed by the query nodes306. In some embodiments, the process may be iterated repeatedly until the query has been completed.

Based on a determination that the query has been completed, the process may proceed to324, according to some embodiments. The database308may provide the requested data in response to the query, at324. In some embodiments, the database308provide the requested data to the query nodes306for subsequent transmission to the query engine304. For example, the query nodes306may receive the requested data and subsequently send the requested data to the query engine304. In other embodiments, the database308may send the requested data to the query engine304directly through an interface configured between the query engine304and the database308.

The query engine304may provide the requested data in response to the query, at326. In some embodiments, the query engine304may send the requested data after the pre-determined time period elapses, at316, and a determination that the query has been completed, at318. For example, the query engine304may send the requested data as part of an iteration of the process for performance of the query. In some embodiments, the query engine304may send the requested data in response to the query originally sent at310or any other query sent at322. For example, the requested data may be provided as a response to any query sent by the client relating to the original query at310. In some embodiments, the query engine304may send the requested data to a data cache service to be stored for a period of time. For example, the client302may be configured to retrieve the requested data from the data cache service based on information provided by the query engine304, such as endpoint information or other connection information.

FIG.4is a timeline diagram illustrating a data flow400between a client and a database service, according to some embodiments. The database service may be implemented as part of a provider network, such as the provider network ofFIG.1. The database service may correspond to the database system120ofFIG.1. Client402may correspond to the client110ofFIG.1or the client302ofFIG.3, according to some embodiments. Query processing cluster403may include query engine404and query node(s)406, according to some embodiments. Query engine404may correspond to the query engine122ofFIG.1or the query engine304ofFIG.3, according to some embodiments. Query node(s)406may correspond to the query node(s)306ofFIG.3, according to some embodiments. Database408may correspond to the database142ofFIG.1or the database308ofFIG.3, according to some embodiments.

The client402may be configured to send, to a query engine404of a database service, a query to retrieve data from database408, at410. The query may correspond to the synchronous query114ofFIG.1, according to some embodiments. The query may indicate a type of data to retrieve from the database408, according to some embodiments.

The query engine404may instantiate the query nodes406to perform the query, at412. In some embodiments, the query engine404may cause deployment of the query nodes406. For example, the query nodes406may be deployed from a pool of nodes of the provider network. In some embodiments, the query engine404may send information indicating the query to the query nodes406. For example, the query engine404may provide an indication of the requested data and the database from which the query nodes406are to obtain the requested data.

The query nodes406may perform the query, at414. The query nodes406may be configured to execute the query responsive to instantiation by the query engine404, according to some embodiments. The query may be performed over a period of time such that other aspects of the database service may be configured to perform additional actions while the query is being performed.

The database408may provide the requested data in response to the query, at416. In some embodiments, the database408provide the requested data to the query nodes406for subsequent transmission to the query engine404. For example, the query nodes406may receive the requested data and subsequently send the requested data to the query engine404. In other embodiments, the database408may send the requested data to the query engine404directly through an interface configured between the query engine404and the database408.

The data flow400may include performing a loop while the requested has not been completely sent to the client, at418. The query engine404may be configured to provide a paginated portion of the requested data in response to the query, at420. Pagination may refer to partitioning or segmenting the requested data into portions that are less than or equal to a transfer size limit. In some embodiments, the query engine404may be subject to a transfer size limit for data sent by the query engine404to the client402. For example, the query engine404may limit outgoing data transmissions to reduce or spread-out bandwidth consumption such that a size of the paginated portion does not exceed the transfer size limit. In some embodiments, the query engine404may set the transfer size limit based on utilization statistics or historical data for the database service. In some embodiments, the query engine404may set the transfer size limit based on a service level agreement between the database service and the client402. In various embodiments, the wait at402may occur before or after providing the paginated portion to the client402, at422. For example, the query engine404may first provide the paginated portion, at422, then wait for the performance time threshold to elapse, at422. As an alternative example, the query engine404may first wait for the performance time threshold to elapse, at422, then provide the paginated portion of the requested data, at422.

The query engine404may be configured to determine whether the requested data has been completely sent to the client402, at422. In some embodiments, the query engine404may be configured to track a quantity of the requested data that has been sent to the client402. For example, the query engine404may be configured to record metadata for the query and the requested data. In some embodiments, the metadata may include a query identifier for the query and a token that indicates that the requested data has not been completely sent to the client402. For example, the query identifier may identify the query to the query engine404such that when the query identifier is provided as part of a subsequent query, the query engine404may resume the loop418as relating to the query. As another example, the token may indicate a quantity of data that has already been sent to the client402. In some embodiments, the token may include information that identifies the quantity of data that has been sent to the client402. For example, the query engine404may analyze the token to determine a remaining quantity of the requested data to send to the client402.

If the requested data has not been completely sent to the client402, the query engine404may be configured to send the query identifier and the token for the query to the client402, at424. In some embodiments, the token may be incremented each time the query engine404sends a portion of the requested data while unsent portions of the requested data remain. For example, the query engine404may increment the token for each iteration of the loop418. In some embodiments, the paginated portion of the requested data may be sent with the query identifier and the token as a consolidated response to the query.

The client402may be configured to send another query to retrieve the remaining data from the query engine404, where the other query includes the query identifier and the token, at426. In some embodiments, the client402may determine that the requested data has not been completely sent to the client402based on the presence of the token. For example, the client402may be configured to infer that remaining portions of the requested data are at the query engine404based on the token being sent to the client402.

FIG.5is a block diagram illustrating logical representations of queries and responses to queries, according to some embodiments. The depicted queries and responses are for illustrative purposes and may be expressed in a computer-readable manner, such as an extensible markup language (XML).

Query500may be generated by a client, such as the client110ofFIG.1, the clients250ofFIG.2, the client302ofFIG.3, or the client402ofFIG.4, according to some embodiments. The client may be configured to generate the query500to request data from a database. For example, the query500may include a data request502that identifies data or a data type to be retrieved from the database. In some embodiments, the client may send the query500to a database service, such as the database system120ofFIG.1, the database service210ofFIG.2, the database308ofFIG.3, or the database408ofFIG.4. In some embodiments, the query500may be an original query to request the data indicated by the data request502. For example, an original query for data may not necessarily include a token or query identifier that would indicate to the database service that the query500is a continuation of a previously sent query.

In situations when the database service has not completed execution of the query500, the database service may generate a response510to the query500, according to some embodiments. For example, the database service may include a query engine configured to manage queries, including the query500. The query engine may determine that execution of the query500is incomplete and generate a token and a query identifier for the query500. The token may indicate to the client and the database service that the query500has not been completed by the database service. The response510may be sent to the client in response to the query500after a waiting period causing the database service to issue the response510.

In situations when the database service has completed execution of the query500, the database service may generate a response520to the query500, according to some embodiments. The database service may have the requested data to be sent to the client prepared for transmission subject to a transfer size limit, according to some embodiments. For example, the database service may have a limited amount of bandwidth such that outgoing transmissions are limited to the transfer size limit. The response520may include a requested data portion522, a token524, and a query identifier526for the query500. The token524may indicate that the requested data included in the requested data portion522is not complete with respect to the data request502of the query500. The token524may be incremented or modified to indicate how many portions have been transferred to the client or how many portions remain to be sent to the client.

The client may be configured to generate an additional query530that includes a data request532, a token534, and a query identifier536associated with the query500, according to some embodiments. The additional query530may be sent by the client to the database service in response to the response510or the response520being received by the client. The data request532may correspond to the data request502to maintain consistency between the query500and the additional query530.

The database service may generate a response540to the query500based on a determination that the requested data portion542is all of the requested data for the query500. As another example, the response540may be generated based on a determination that the requested data portion542is a final portion of the requested data that has been paginated or fragmented in accordance with the transfer size limit. The client may determine that the requested data portion542is intended to be the final response to the query500based on a lack of a token or a query identifier in the response540.

FIG.6is a flowchart diagram for a method600for managing queries for a database, according to some embodiments. The method600may be performed by a query engine for a database service. The query engine may correspond to the query engine122ofFIG.1, the query processing clusters216ofFIG.2, the query engine304ofFIG.3, or the query engine404ofFIG.4, according to some embodiments.

The method600may include receiving, at the query engine from a client via a connection, a query requesting data stored at a database, at602. The query may correspond to the synchronous query114ofFIG.1or the query400ofFIG.4, according to some embodiments. The database may correspond to the database142ofFIG.1, the database208ofFIG.2, the database308ofFIG.3, or the data store518ofFIG.5, according to some embodiments.

The method600may include initiating performance of the query at one or more query workers to retrieve the requested data from the database, at604. The query workers may correspond to the query workers123ofFIG.1, the query nodes206ofFIG.2, the query nodes306ofFIG.3, or the query workers517ofFIG.5, according to some embodiments. In some embodiments, the query engine may deploy, instantiate, or provision one or more computing devices or computing nodes to implement the query workers. For example, the query engine may obtain, lease, or acquire the computing devices to be configured to implement one or more tasks relating to performing a query at a database.

The method600may include determining whether the query has been completed by the query worker(s) within a performance time threshold, at606. The performance time threshold may correspond to the performance time threshold124ofFIG.1, according to some embodiments. In some embodiments, the performance time threshold may correspond to a duration of time that may be used to determine whether a query is considered a short or fast query versus a long query. For example, a query that is not completed by the time the performance time threshold elapses may be considered a long query, and a query that is completed by the time the performance time threshold elapses may be considered a short or fast query. In other embodiments, the pre-determined time period may represent a delay to pace or defer query responses to mitigate overloading of the computing resources used to implement the query engine or the query workers.

In some embodiments, the query engine may be configured to determine whether the query has been completed within the performance time threshold based on receiving the requested data from the query workers. In other embodiments, the query engine may be configured to determine whether the query has been completed performance time threshold based on the query workers storing information indicating that the query has been completed. In yet other embodiments, the query engine may be configured to determine whether the query has been completed performance time threshold based on polling the query workers.

The query engine may determine whether to apply a synchronous query protocol or an asynchronous query protocol based on whether the query has been completed within the performance time threshold, according to some embodiments. For example, a synchronous query may result in a response prior to the performance time threshold elapsing. As another example, an asynchronous query may require one or more additional iterations to retrieve the requested data from the database.

Based on a determination that the query has been completed by the query worker(s) within the performance time threshold, the method600may include sending, to the client, the requested data from the database, at608. In some embodiments, the query engine may be configured to send a response to the query. The response may correspond to the response540, according to some embodiments. In some embodiments, the query worker may provide the requested data to the query engine to be sent to the client. In other embodiments, the query worker may be directed by the query engine to send the requested data to the client. In yet other embodiments, the query engine may store the requested data in temporary storage to be obtained by the client. For example, the query engine may store the requested data in a data cache and provide the client with information on how to access the data cache to retrieve the requested data.

Based on a determination that the query has not been completed by the query worker(s) within the performance time threshold, the method600may include storing a query identifier for the query and incrementing a token indicating that the query has not been completed as metadata for the query, at610. In some embodiments, the query engine may be configured to maintain the metadata for queries sent to the query engine that are considered long queries that require more time to complete than the performance time threshold. The token may indicate a quantity of iterations the performance time threshold was met while performing the query.

The method600may include sending, to the client, the query identifier and the token indicating that the query has not been completed, at612. In some embodiments, the query engine may send a response to the query that includes the query identifier and the token. The response may correspond to the response510ofFIG.5, according to some embodiments. For example, the response may comprise a null portion reserved for the requested data, the query identifier, and the token.

The method600may include terminating the connection to the client, at614. In some embodiments, the query engine may preserve bandwidth or computing resources by terminating the connection between the database service and the client. For example, the connection may incur operational costs by remaining open without an active data transfer between the client and the database service.

The method600may include receiving, from the client via another connection, an additional query for the data stored at the database, where the additional query includes the token and the query identifier, at616. The additional query may correspond to the asynchronous query115ofFIG.1. In some embodiments, the client may establish another connection for the additional query. For example, the terminated connection at614may require that the client reconnect or establish a new connection to the database service. The additional query may include the token and the query identifier that was supplied by the query engine at612. The method600may return to606to again determine whether the query has been completed by the query worker(s) with a performance time threshold since the additional query was received from the client.

FIG.7illustrates a flowchart diagram for a method700for a client sending queries requesting data from a database. The client may correspond to the client110ofFIG.1, the clients250ofFIG.2, the client302ofFIG.3, or the client402ofFIG.4, according to some embodiments. In some embodiments, the method700may be performed by the client as a counterpart to the method600being performed by the query engine.

The method700may include sending, to a database service from a client, a query requesting data stored at a database, at702. The database service may correspond to the database system120ofFIG.1, the database service210ofFIG.2, the database308ofFIG.3, or the database408ofFIG.4, according to some embodiments. The query may correspond to the synchronous query114ofFIG.1or the query400ofFIG.4, according to some embodiments. The database may correspond to the database142ofFIG.1, the database208ofFIG.2, the database308ofFIG.3, or the data store518ofFIG.5, according to some embodiments.

The method700may include receiving, at the client, a response to the query from the database service, at704. The response may correspond to the response510or the response540ofFIG.5, according to some embodiments. In some embodiments, the response to the query may be generated by a query engine of the database service. For example, the response to the query may be generated as described with respect to608or612ofFIG.6.

The method700may include determining whether the response received from the database service includes the requested data or an indication of a storage location for the requested data, at706. In some embodiments, the client may analyze the response to determine if the response includes a null portion or a requested data portion. For example, the client may determine whether any data from the requested data of the query is included in the received response. In some situations, the requested data portion of the response may include an indication of a storage location, such as a network endpoint or resource address to obtain the requested data. For example, the requested data may be stored in at a storage service configured to cache the requested data until the client has had the opportunity to retrieve the requested data.

Based on a determination that the received response includes the requested data or an indication of a storage location for the requested data, the method700may include obtaining the requested data from the received response or the storage location, at708. The method700may conclude by storing the requested data at the client, at710.

Based on a determination that the received response does not include the requested data or an indication of a storage location for the requested data, the method700may include obtaining, from the received response, a query identifier for the query and a token indicating that the query has not been completed, at712. In situations when the received response does not include the requested data, the received response may include the query identifier and the token provided by the database service.

The method700may include sending, from the client, an additional query for the data stored at the database, where the additional query includes the token and the query identifier, at718. The additional query may correspond to the asynchronous query115ofFIG.1, according to some embodiments. The additional query may include the token and the query identifier that was supplied by the query engine at612. The method700may return to704to receive another response to the additional query.

FIG.8illustrates a flowchart diagram of a method800for a query engine of a database service to send data in response to a query, according to some embodiments. The query engine may correspond to the query engine122ofFIG.1, the query processing clusters216ofFIG.2, the query engine304ofFIG.3, or the query engine404ofFIG.4, according to some embodiments.

The method800may include receiving, at a query engine from a client via a connection, a query requesting data stored at a database, at802. The query may correspond to the synchronous query114ofFIG.1or the query400ofFIG.4, according to some embodiments. The database may correspond to the database142ofFIG.1, the database208ofFIG.2, the database308ofFIG.3, or the data store518ofFIG.5, according to some embodiments.

The method800may include retrieving, from the database, the requested data, at804. In some embodiments, retrieving the requested data may include the method600described with respect toFIG.6. The method800may incorporate the method600in some embodiments. In other embodiments, the query engine may be configured to perform the query with the database to retrieve the requested data.

The method800may include sending, to the client, a portion of the requested data according to a transfer size limit, at806. In some situations, the transfer size limit may be a bandwidth limit that limits a quantity of data sent as a response to the query. The query engine may be configured to generate portions of the requested data when the requested data exceeds the transfer size limit. In some embodiments, the portions may be partitioned into pages that may be sent to the client at different points in time.

The method800may include determining whether the requested data has been completely sent to the client, at808. In some embodiments, the query engine may be configured to determine whether the requested data has been completely sent based on metadata for the query. For example, the metadata for the query may indicate a quantity of data that has been transmitted to the client and a total size of the requested data. In other embodiments, the metadata may include a token which indicates that there are unsent portions of the requested data. Based on a determination that the requested data has been completely sent to the client, the method800may end, at810.

Based on a determination that the requested data has not been completely sent to the client, the method800may include storing a query identifier and increment a token indicating that the data has not been completely sent as metadata for the query, at812. In some embodiments, the query engine may be configured to maintain the metadata for queries sent to the query engine that are considered long queries that require more time to complete than the performance time threshold. The token may indicate a quantity of iterations the performance time threshold was met while performing the query.

The method800may include sending, to the client, an additional portion of the data, the query identifier, and the token, where the additional portion is limited to the transfer size limit, at814. In some embodiments, the query engine may send a response to the query that includes the query identifier and the token. The response may correspond to the response520ofFIG.5, according to some embodiments. For example, the response may comprise a null portion reserved for the requested data, the query identifier, and the token.

The method800may include terminating the connection to the client, at816. In some embodiments, the query engine may preserve bandwidth or computing resources by terminating the connection between the database service and the client. For example, the connection may incur operational costs by remaining open without an active data transfer between the client and the database service.

The method800may include receiving, from the client, an additional query for unsent portions of the data, where the additional query includes the token and the query identifier, at818. The additional query may correspond to the asynchronous query115ofFIG.1. The additional query may include the token and the query identifier that was supplied by the database service at814. The method800may return to808to again determine whether the requested data has been completely sent to the client.

FIG.9illustrates a flowchart diagram of a method900for a client receiving data in response to a query, according to some embodiments. The client may correspond to the client110ofFIG.1, the clients250ofFIG.2, the client302ofFIG.3, or the client402ofFIG.4, according to some embodiments. In some embodiments, the method900may be performed by the client as a counterpart to the method800being performed by the query engine.

The method900may include sending, to a database service from a client via a connection, a query requesting data stored at a database, at902. The database service may correspond to the database system120ofFIG.1, the database service210ofFIG.2, the database308ofFIG.3, or the database408ofFIG.4, according to some embodiments. The query may correspond to the synchronous query114ofFIG.1or the query400ofFIG.4, according to some embodiments. The database may correspond to the database142ofFIG.1, the database208ofFIG.2, the database308ofFIG.3, or the data store518ofFIG.5, according to some embodiments.

The method900may include receiving, at the client, a response to the query from the database service, the response including at least a portion of the requested data904. The response may correspond to the response520or the response540ofFIG.5, according to some embodiments. In some embodiments, the response to the query may be generated by a query engine of the database service. For example, the response to the query may be generated as described with respect to806or814ofFIG.6.

The method900may include determining whether the requested data has been completely received by the client, at906. In some embodiments, the client may be configured to determine whether the requested data has been completely received based on metadata for the requested data. For example, the metadata for the query may indicate a quantity of data that has been transmitted to the client and a total size of the requested data. In other embodiments, the metadata may include a token which indicates that there are unsent portions of the requested data. Based on a determination that the requested data has been completely received by the client, the method900may end, at908.

Based on a determination that the requested data has not been completely received by the client, the method900may include obtaining, from the received response, a query identifier for the query and a token indicating that the requested data has not been completely sent, at910. The query identifier and the token may be used by the client to identify to the database service that a subsequent query is related to the query sent at902.

The method900may include sending, from the client, an additional query for unsent portions of the requested data, where the additional query includes the token and the query identifier, at912. The additional query may correspond to the asynchronous query115ofFIG.1. The additional query may include the token and the query identifier that was supplied by the database service at910. The method900may return to904to receive an additional response to the additional query.

FIG.10illustrates a flowchart diagram for a method1000for processing a query at a database system, according to some embodiments. The database system may correspond to the database system120ofFIG.1, the database service210ofFIG.2, the database308ofFIG.3, or the database408ofFIG.4, according to some embodiments.

The method1000may include receiving a query at a database system from a client, at1002. The query may correspond to the synchronous query114or the asynchronous query115ofFIG.1or the query400or the query430ofFIG.4, according to some embodiments.

The method1000may include initiating performance of the query at the database system, at1004. In some embodiments, performance of the query may be initiated by implementing worker nodes configured to process the query. In some embodiments, a query engine may deploy, instantiate, or provision one or more computing devices or computing nodes to implement the query workers. For example, the query engine may obtain, lease, or acquire the computing devices to be configured to implement one or more tasks relating to performing a query at a database.

The method1000may include selecting, by the database system, a protocol for returning a result of the query based on a performance time of the query at the database system, at1006. The method1000may include returning, by the database system, the result of the query according to the selected protocol, at1008. In some embodiments, the database system may be configured to select a synchronous protocol or an asynchronous protocol for returning the result of the query. For example, a synchronous protocol may be configured to return the result of the query responsive to the query. As another example, an asynchronous protocol may be configured to receive a subsequent query to retrieve the result. In some embodiments, the protocol may be selected based on other criteria. For example, the protocol may be selected based on a selection indicated by the client. As another example, the client may establish a performance time threshold used to select the protocol.

Any of various computer systems may be configured to implement techniques for managing database queries, as disclosed herein. For example,FIG.11is a block diagram illustrating one embodiment of a computer system suitable for implementing some or all of the techniques and systems described herein. In various embodiments, the provider network may include one or more computer systems1100such as that illustrated inFIG.11or one or more components of the computer system1100that function in a same or similar way as described for the computer system1100.

In the illustrated embodiment, computer system1100includes one or more processors1110coupled to a system memory1120via an input/output (I/O) interface1130. Computer system1100further includes a network interface1140coupled to I/O interface1130. In some embodiments, computer system1100may be illustrative of servers implementing enterprise logic or downloadable application, while in other embodiments servers may include more, fewer, or different elements than computer system1100.

In various embodiments, computer system1100may be a uniprocessor system including one processor1110, or a multiprocessor system including several processors1110(e.g., two, four, eight, or another suitable number). Processors1110may be any suitable processors capable of executing instructions on or across the processors1110. For example, in various embodiments, processors1110may be embedded processors implementing any of a variety of instruction set architectures (ISAs), such as the x86, x86-64, ARM, PowerPC, SPARC, or MIPS ISAs, or any other suitable ISA. In multiprocessor systems, each of processors1110may commonly, but not necessarily, implement the same ISA.

System memory1120may be configured to store instructions and data accessible by processor1110. In various embodiments, system memory1120may be implemented using one or more of any suitable memory technology, such as static random access memory (SRAM), synchronous dynamic RAM (SDRAM), non-volatile/Flash-type memory, or any other type of memory. In the illustrated embodiment, program instructions and data implementing desired functions, such as those methods and techniques described above for the management of securely memory compression are shown stored within system memory1120as program instructions1124. In some embodiments, system memory1120may include data1125which may be configured as described herein. In some embodiments, system memory1120may include database query logic1122. For example, database query logic1122may perform the functions of the client110or the database system120ofFIG.1, the functions of the clients250or the database service210ofFIG.2, the functions of the client302or the query engine304ofFIG.3, or the functions of the client402or the query engine404ofFIG.4.

In one embodiment, I/O interface1130may be configured to coordinate I/O traffic between processor1110, system memory1120and any peripheral devices in the system, including through network interface1140or other peripheral interfaces. In some embodiments, I/O interface1130may perform any necessary protocol, timing or other data transformations to convert data signals from one component (e.g., system memory1120) into a format suitable for use by another component (e.g., processor1110). In some embodiments, I/O interface1130may include support for devices attached through various types of peripheral buses, such as a variant of the Peripheral Component Interconnect (PCI) bus standard or the Universal Serial Bus (USB) standard, for example. In some embodiments, the function of I/O interface1130may be split into two or more separate components, such as a north bridge and a south bridge, for example. Also, in some embodiments, some or all of the functionality of I/O interface1130, such as an interface to system memory1120, may be incorporated directly into processor1110.

Network interface1140may be configured to allow data to be exchanged between computer system1100and other devices attached to a network, such as between client devices (e.g.,1160, etc.) and other computer systems, or among hosts, for example. In particular, network interface1140may be configured to allow communication between computer system1100and/or various other devices1160(e.g., I/O devices). Other devices1160may include scanning devices, display devices, input devices and/or other communication devices, as described herein. Network interface1140may commonly support one or more wireless networking protocols (e.g., Wi-Fi/IEEE 802.11, or another wireless networking standard). However, in various embodiments, network interface1140may support communication via any suitable wired or wireless general data networks1170, such as other types of Ethernet networks, for example. Additionally, network interface1140may support communication via telecommunications/telephony networks such as analog voice networks or digital fiber communications networks, via storage area networks such as Fibre Channel SANs, or via any other suitable type of network and/or protocol.

In some embodiments, system memory1120may be one embodiment of a computer-accessible medium configured to store program instructions and data as described above. However, in other embodiments, program instructions and/or data may be received, sent or stored upon different types of computer-accessible media. Generally speaking, a computer-accessible medium may include computer-readable storage media or memory media such as magnetic or optical media, e.g., disk or DVD/CD-ROM coupled to computer system1100via I/O interface1130. A computer-readable storage medium may also include any volatile or non-volatile media such as RAM (e.g. SDRAM, DDR SDRAM, RDRAM, SRAM, etc.), ROM, etc., that may be included in some embodiments of computer system1100as system memory1120or another type of memory. Further, a computer-accessible medium may include transmission media or signals such as electrical, electromagnetic, or digital signals, conveyed via a communication medium such as a network and/or a wireless link, which may be implemented via network interface1140.

In some embodiments, I/O devices may be relatively simple or “thin” client devices. For example, I/O devices may be configured as dumb terminals with display, data entry and communications capabilities, but otherwise little computational functionality. However, in some embodiments, I/O devices may be computer systems configured similarly to computer system1100, including one or more processors1110and various other devices (though in some embodiments, a computer system1100implementing an I/O device1150may have somewhat different devices, or different classes of devices).

In various embodiments, I/O devices (e.g., scanners or display devices and other communication devices) may include, but are not limited to, one or more of: handheld devices, devices worn by or attached to a person, and devices integrated into or mounted on any mobile or fixed equipment, according to various embodiments. I/O devices may further include, but are not limited to, one or more of: personal computer systems, desktop computers, rack-mounted computers, laptop or notebook computers, workstations, network computers, “dumb” terminals (i.e., computer terminals with little or no integrated processing ability), Personal Digital Assistants (PDAs), mobile phones, or other handheld devices, proprietary devices, printers, or any other devices suitable to communicate with the computer system1100. In general, an I/O device (e.g., cursor control device, keyboard, or display(s) may be any device that can communicate with elements of computing system1100.

The various methods as illustrated in the figures and described herein represent illustrative embodiments of methods. The methods may be implemented manually, in software, in hardware, or in a combination thereof. The order of any method may be changed, and various elements may be added, reordered, combined, omitted, modified, etc. For example, in one embodiment, the methods may be implemented by a computer system that includes a processor executing program instructions stored on one or more computer-readable storage media coupled to the processor. The program instructions may be configured to implement the functionality described herein (e.g., the functionality of the data transfer tool, various services, databases, devices and/or other communication devices, etc.).

Various modifications and changes may be made as would be obvious to a person skilled in the art having the benefit of this disclosure. It is intended to embrace all such modifications and changes and, accordingly, the above description to be regarded in an illustrative rather than a restrictive sense.

Various embodiments may further include receiving, sending, or storing instructions and/or data implemented in accordance with the foregoing description upon a computer-accessible medium. Generally speaking, a computer-accessible medium may include storage media or memory media such as magnetic or optical media, e.g., disk or DVD/CD-ROM, volatile or non-volatile media such as RAM (e.g. SDRAM, DDR, RDRAM, SRAM, etc.), ROM, etc., as well as transmission media or signals such as electrical, electromagnetic, or digital signals, conveyed via a communication medium such as network and/or a wireless link.