Patent Publication Number: US-2021165789-A1

Title: Dynamically adjusting performance of materialized view maintenance

Description:
BACKGROUND 
     As the technological capacity for organizations to create, track, and retain information continues to grow, a variety of different technologies for managing and storing the rising tide of information have been developed. Database systems, for example, provide clients with many different specialized or customized configurations of hardware and software to manage stored information. However, the increasing amounts of data that organizations must store and manage often correspondingly increases both the number, size and complexity of data storage and management technologies that are used to perform various operations and services, such as utilizing the features of database systems, object stores, and data streams, which in turn escalate the cost of maintaining the information. Moreover, as different data storage technologies offer different performance benefits and features, tailoring the location of data to a data storage technology that provides performance and analysis benefits for that data may result in different data sets being spread across many different locations and types of storage systems. While utilizing such a deployment strategy for individual data sets offers some benefit to the individual data sets, some systems or applications may need access to multiple different data sets in order to operate, which can be challenging given the various interfaces, languages, and other technological hurdles that occur when accessing multiple data storage systems. Thus, techniques that can obtain and co-locate data from disparate data storage systems for systems or applications that use data from the disparate storage systems, without removing the data from their optimized source storage locations, may be highly desirable. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  illustrates a logical block diagram illustrating adjusting performance of materialized view maintenance, according to some embodiments. 
         FIG. 2  is a logical block diagram illustrating a provider network offering a materialized view management platform and various services, including various data storage and processing services, according to some embodiments. 
         FIG. 3  is a logical block diagram illustrating a materialized view management platform that implements managed materialized views created from heterogeneous data sources, according to some embodiments. 
         FIG. 4  is a sequence diagram illustrating interactions for creation and maintenance phases for a materialized view managed by a materialized view management platform, according to some embodiments. 
         FIG. 5  is a logical block diagram illustrating materialized view creation, according to some embodiments. 
         FIG. 6  is a logical block diagram illustrating materialized view maintenance, according to some embodiments. 
         FIG. 7  is a logical block diagram illustrating an optimizer for performing maintenance plans, according to some embodiments. 
         FIG. 8  is a logical block diagram illustrating performance of updates to a target data store for a materialized view, according to some embodiments. 
         FIG. 9  is a logical block diagram illustrating control plane performance adjustments for performing updates to a materialized view, according to some embodiments. 
         FIG. 10  is logical block diagram illustrating interactions supported by an example interface for a materialized view management platform, according to some embodiments. 
         FIG. 11  is a high-level flowchart illustrating various methods and techniques to adjusting performance of materialized view maintenance, according to some embodiments. 
         FIG. 12  is a high-level flowchart illustrating various methods and techniques to rewrite maintenance plans to optimize performance of materialized view maintenance, according to some embodiments. 
         FIG. 13  illustrates an example system configured to implement the various methods, techniques, and systems described herein, according to some embodiments. 
     
    
    
     While embodiments are described herein by way of example for several embodiments and illustrative drawings, those skilled in the art will recognize that 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. The headings used herein are for organizational purposes only and are not meant to be used to limit the scope of the description or the 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. 
     It will also be understood that, although the terms first, second, etc. may be used herein to describe various elements, these elements should not be limited by these terms. These terms are only used to distinguish one element from another. For example, a first contact could be termed a second contact, and, similarly, a second contact could be termed a first contact, without departing from the scope of the present invention. The first contact and the second contact are both contacts, but they are not the same contact. 
     DETAILED DESCRIPTION OF EMBODIMENTS 
     Various techniques of managed materialized views created from heterogeneous data sources are described herein. Different systems, applications, or services store data in multiple purpose-built databases or other data storage or processing technologies to ensure they use the right tool for the job at hand. However, there are many use cases that combine data from multiple such databases, data stores, or other types of data sources. For example, an application implementing an online multi-player game may need to track player profile data, player behavior, and offer in-game promotions. The application might keep player profile data in a low-latency non-relational (e.g., NoSQL) database, game events in an indexing service, player behavior analytics in a data warehouse service, and promotion catalog in a document database. To build a dashboard of top players and their game activities, an Extract Transform and Load (TEL) service could be used to set up pipelines that extract, transform, and combine data from these disparate systems into a single data store, such as a data caching service, in order to host the dashboard and do activities such as in-game promotion targeting. While such an approach may work for batch updates, keeping the dashboard updated in near real-time would have to rely upon writing significant custom code. The costs to create the custom code for complex integration and pre-computation workflows may increase as fast changing underlying data sources would cause further refinements or changes. Use cases and patterns like the example above exist in virtually every industry, decreasing system performance and increasing implementation costs. 
     In various embodiments, a materialized view management platform may simplify operational workloads by making it easy to create materialized views that integrate data from multiple sources, storing these views in a specified target database, and keeping the views up-to-date in near real-time as the underlying data changes (instead of, for instance, relying upon making batch-based sets of changes). As discussed in detail below with regard to  FIGS. 2-7 , a materialized view management platform can offer a serverless experience for client applications while also offering for high performance. For example, in various embodiments, the materialized view management platform can scale automatically to ingest large volumes of source data changes and to perform computations to construct the views. Because the materialized view management platform may be serverless, in some embodiments, a client application (or developers for the client application) will not have to setup infrastructure, provision capacity or configure read and write limits. The materialized view management platform may instead receive a materialized view definition that specifies data sources, the integration of data from the different data sources and a target (or multiple targets) to store the materialized views. 
       FIG. 1  illustrates a logical block diagram illustrating adjusting performance of materialized view maintenance, according to some embodiments. Materialized view management  110 , may be a materialized view manage platform  210  as discussed below with regard to  FIGS. 2-10  implemented as part of a provider network or implemented as part of a private or on-premise network. Materialized view management  110  may create materialized views, such as materialized view  132 , from different numbers and types of data sources, performing source data capture  112 , initial and update view computation  114 , and view materialization  116  to store a materialized view  132  (as well as updated or new versions  160  in a target data store  130 . Materialized views created and updated (or maintained) by materialized view management  110 , such as materialized view  132 , may be a continuously updated result set of an analysis over data sources that are specified in a materialized view definition to materialized view management  110 . For example, a request to create a managed materialized view  102  may be sent to materialized view management  110  that provides materialized view definition  118  for materialized view  132 . 
     Materialized view management  110  can offer various properties or guarantees to a consumer of a materialized view, in some embodiments. For example, a publisher of a materialized view can constrain the data by defining schemas and typing in a creation request and/or materialized view definition  118 . For example, the definitions may allow semi-structured data, i.e., data where there are significant degrees of freedom on the types. For example, the publisher specify features such as “the SSN attribute is either a string or a number” or that “the additional notes attribute allows for any type of (SQL) content”, or “the dimensions (of a data source record) include an attribute sensor id and potentially other undeclared attributes.” In some embodiments, materialized view management  110  can specify transactional consistency properties of the incoming data sources. For example, when capturing changes, materialized view management  110  can guarantee that the changes have no holes (missing changes). In some embodiments, the publisher may guarantee deduplication. In some embodiments, the publisher of the view may be able to guarantee order of arrivals or an approximation. These guarantees may be supported by various features of materialized view management  110  (as discussed in the various example embodiments below). 
     The materialized view can be accessed using the target data store, such as target data store  130  via queries or other target data store access interfaces. In this way, a desired type or style of data store, for example, for integrating the materialized can be specified. The interface supported by target data store  130  may be used to access the materialized view, in various embodiments. For example, a SQL query may be made to access materialized view  132  if target data store  130  is a relational database that supports SQL. If however target data store  132  were stored in a non-relational database, then a request according to the programming language or interface of the non-relational database may be used to access the materialized view instead. In this way, materialized views can be deployed to targets that support the desired features for analyzing and accessing the materialized view, in some embodiments. 
     A materialized view can be defined  132  in various ways. For example, in some embodiments a structured query language (SQL) statement can be used to specify the one or more data sources, such as data sources  120   a  through  120   n,  and a target, such as target data store  130 . In some embodiments, a user interface or other type of interface (e.g. an Application Programming Interface (API)) can be used to specify the materialized view, including the desired results (e.g., scan, get, join, aggregate, etc.), sources (e.g., by selecting data sources from a list of offered sources), and targets (e.g., by selecting target(s) from a list of offered targets). In some embodiments, target data store  130  can be one of the data sources (e.g., with the view stored in a different location, such as a different table in a same database). 
     Data sources  120  may be many different types of data storage, processing, and/or management technologies, in some embodiments. For example, data sources  120  may be various types of databases (including relational databases, non-relational databases, graph databases, document databases, time series databases, data warehouses, or various other types of databases). In another example, data sources  120  may include various data streaming platforms or services (e.g., data streams for data feeds, events, or other stream processing techniques). In some embodiments, data sources  120  may be messaging, notification, or other communication services or platforms. Various combinations of the different example data sources may be used or combined to create a materialized view (e.g., a materialized view that joins a database table with a data stream). Similarly target data store  130  can be various types of data storage, processing, and/or management technologies, such as the examples given above. 
     Once materialized view management  110  creates materialized view  132  in target data store  130 , materialized view management  110  may also maintain materialized view  132  to provide near real-time updates. In this way, materialized view  132  may provide up-to-date changes when queries or analyzed. For example, as different changes are made to (or by) data sources  120 , these changes may be obtained  150  a materialized view  110 . Source data capture  112  may be implemented at materialized view management  110  to handle the capture and ingestion of changes to data sources. For example, as discussed below with regard to  FIG. 5 , source data capture  112  may implement the protocols or techniques to receive or obtain the updates when they occur at data sources  120 . 
     Materialized view management  110  may implement view update computation  114 , in various embodiments. View update computation  114  may perform various queries or other operations to obtain data (in addition or based) the captured changes (e.g., query to obtain data to join with received changes). View update computation  114 , which may implement the techniques or components discussed below with regard to  FIG. 6 , may perform a plan or procedure (e.g., generated by a federated query engine or other data processing engine) to provide a stream of changes and/or set of changes to view materialization  116 . View materialization  116  (e.g., a target connector discussed below in regard to  FIG. 8 ) may reformat, package, encapsulate, or otherwise translate the changes to the materialized view  138 , and perform one or more requests to target data store  130  (e.g., via an interface for accessing target data store  130 ) to update materialized view  160  with a new version of the materialized view. For example, view materialization may collect or identify a set of changes as a new snapshot (e.g., a state of a materialized view as of a point in time) to update in target data store  130  as a new version of materialized view  132 . 
     Materialized view management  110  may monitor the update performance  140  of the various stages of materialized view maintenance. For example, various performance criteria regarding maintenance throughput (e.g., lag time) between source data capture  112  (or performance of changes at data source  120 ) and view materialization  116  may be measured. Similarly, the speed at which individual stages are performed may be compared with the load on the individual stages (e.g., how fast source data capture  112  ingests updates compared with the rate of changes received). Materialized view management  110  may make various adjustments, to capture  142 , computation  144 , and materialization  146 , as discussed in detail below with regard to  FIGS. 9 and 11 . 
     Please note that the previous description of materialized view management is a logical illustration and thus is not to be construed as limiting as to the implementation of data sources, targets, materialized views, or various other features. Different combinations or implementations may be implemented in various embodiments. 
     This specification begins with a general description of a provider network that implements a materialized view management platform. Then various examples of a materialized view management platform including different components/modules, or arrangements of components/module that may be employed as part of implementing adjusting performance of materialized view maintenance are discussed. A number of different methods and techniques to adjusting performance of materialized view maintenance are then discussed, some of which are illustrated in accompanying flowcharts. Finally, a description of an example computing system upon which the various components, modules, systems, devices, and/or nodes may be implemented is provided. Various examples are provided throughout the specification. 
       FIG. 2  is a logical block diagram illustrating a provider network offering a materialized view management platform and various services, including various data storage and processing services, according to some embodiments. Provider network  200  may be a private or closed system or may be set up by an entity such as a company or a public sector organization to provide one or more services (such as various types of cloud-based storage) accessible via the Internet and/or other networks to clients  270 , in some embodiments. Provider network  200  may be implemented in a single location or may include numerous data centers hosting various resource pools, such as collections of physical and/or virtualized computer servers, storage devices, networking equipment and the like (e.g., computing system  2000  described below with regard to  FIG. 13 ), needed to implement and distribute the infrastructure and services offered by the provider network  200 . In some embodiments, provider network  200  may implement various computing systems, platforms, resources, or services, such as a materialized view management platform  210 , compute services  220 , database service(s)  230 , (e.g., relational or non-relational (NoSQL) database query engines, map reduce processing, data flow processing, and/or other large scale data processing techniques), data storage service(s)  240 , (e.g., an object storage service, block-based storage service, or data storage service that may store different types of data for centralized access), data stream and/or event services  250 , and other services  260  (any other type of network based services (which may include various other types of storage, processing, analysis, communication, event handling, visualization, and security services not illustrated). 
     In various embodiments, the components illustrated in  FIG. 2  may 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 of  FIG. 2  may 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 in  FIG. 13  and described below. In various embodiments, the functionality of a given system or service component (e.g., a component of data storage service  230 ) 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). 
     Compute services  210  may be implemented by provider network  200 , in some embodiments. Compute services  210  may offer instances, containers, and/or functions according to various configurations for client(s)  270  operation. A virtual compute instance may, for example, comprise one or more servers with a specified computational capacity (which may be specified by indicating the type and number of CPUs, the main memory size, and so on) and a specified software stack (e.g., a particular version of an operating system, which may in turn run on top of a hypervisor). A container may provide a virtual operation system or other operating environment for executing or implementing applications. A function may be implemented as one or more operations that are performed upon request or in response to an event, which may be automatically scaled to provide the appropriate number computing resources to perform the operations in accordance with the number requests or events. A number of different types of computing devices may be used singly or in combination to implement the compute instances, containers, and/or functions and of provider network  200  in different embodiments, including general purpose or special purpose computer servers, storage devices, network devices and the like. In some embodiments instance client(s)  270  or other any other user may be configured (and/or authorized) to direct network traffic to a compute instance. 
     Compute instances, containers, and/or functions may operate or implement a variety of different platforms, such as application server instances, Java™ virtual machines (JVMs), general purpose or special-purpose operating systems, platforms that support various interpreted or compiled programming languages such as Ruby, Perl, Python, C, C++ and the like, or high-performance computing platforms) suitable for performing client(s)  270  applications, without for example requiring the client(s)  270  to access an instance. Applications (or other software operated/implemented by a compute instance and may be specified by client(s), such as custom and/or off-the-shelf software. 
     In some embodiments, compute instances, containers, and/or functions have different types or configurations based on expected uptime ratios. The uptime ratio of a particular compute instance may be defined as the ratio of the amount of time the instance is activated, to the total amount of time for which the instance is reserved. Uptime ratios may also be referred to as utilizations in some implementations. If a client expects to use a compute instance for a relatively small fraction of the time for which the instance is reserved (e.g., 30%-35% of a year-long reservation), the client may decide to reserve the instance as a Low Uptime Ratio instance, and pay a discounted hourly usage fee in accordance with the associated pricing policy. If the client expects to have a steady-state workload that requires an instance to be up most of the time, the client may reserve a High Uptime Ratio instance and potentially pay an even lower hourly usage fee, although in some embodiments the hourly fee may be charged for the entire duration of the reservation, regardless of the actual number of hours of use, in accordance with pricing policy. An option for Medium Uptime Ratio instances, with a corresponding pricing policy, may be supported in some embodiments as well, where the upfront costs and the per-hour costs fall between the corresponding High Uptime Ratio and Low Uptime Ratio costs. 
     Compute instance configurations may also include compute instances, containers, and/or functions with a general or specific purpose, such as computational workloads for compute intensive applications (e.g., high-traffic web applications, ad serving, batch processing, video encoding, distributed analytics, high-energy physics, genome analysis, and computational fluid dynamics), graphics intensive workloads (e.g., game streaming, 3D application streaming, server-side graphics workloads, rendering, financial modeling, and engineering design), memory intensive workloads (e.g., high performance databases, distributed memory caches, in-memory analytics, genome assembly and analysis), and storage optimized workloads (e.g., data warehousing and cluster file systems). Size of compute instances, containers, and/or functions, such as a particular number of virtual CPU cores, memory, cache, storage, as well as any other performance characteristic. Configurations of compute instances, containers, and/or functions may also include their location, in a particular data center, availability zone, geographic, location, etc. . . . and (in the case of reserved compute instances, containers, and/or functions) reservation term length. 
     In various embodiments, database services  230  may be various types of data processing services that perform general or specialized data processing functions (e.g., analytics, big data querying, time-series data, graph data, document data, relational data, non-relational data, structured data, semi-structured data, unstructured data, or any other type of data processing operation) over data that is stored across multiple storage locations, in some embodiments. For example, in at least some embodiments, database services  210  may include various types of database services (e.g., relational) for storing, querying, and updating data. Such services may be enterprise-class database systems that are scalable and extensible. Queries may be directed to a database in database service(s)  230  that is distributed across multiple physical resources, as discussed below, and the database system may be scaled up or down on an as needed basis, in some embodiments. The database system may work effectively with database schemas of various types and/or organizations, in different embodiments. In some embodiments, clients/subscribers may submit queries or other requests (e.g., requests to add data) in a number of ways, e.g., interactively via an SQL interface to the database system or via Application Programming Interfaces (APIs). In other embodiments, external applications and programs may submit queries using Open Database Connectivity (ODBC) and/or Java Database Connectivity (JDBC) driver interfaces to the database system. 
     In some embodiments, database service(s)  230  may include services that process requests to data that is not stored in fully structured storage (e.g., non-relational or NoSQL databases). Database services  230  may access the data that is semi-structured or not-structured in storage, such as data objects of unstructured or semi-structured data in a separate data storage service, in one embodiment. In other embodiments, database services  230  may locally store, managed, and access semi-structured or not-structured data. 
     In some embodiments, database services  220  may be various types of data processing services to perform different functions (e.g., query or other processing engines to perform functions such as anomaly detection, machine learning, data lookup, or any other type of data processing operation). For example, in at least some embodiments, database services  230  may include a map reduce service that creates clusters of processing nodes that implement map reduce functionality over data stored in one of data storage services  240 . Various other distributed processing architectures and techniques may be implemented by database services  230  (e.g., grid computing, sharding, distributed hashing, etc.). Note that in some embodiments, data processing operations may be implemented as part of data storage service(s)  230  (e.g., query engines processing requests for specified data). 
     Data storage service(s)  240  may implement different types of data stores for storing, accessing, and managing data on behalf of clients  270  as a network-based service that enables clients  270  to operate a data storage system in a cloud or network computing environment. For example, one data storage service  230  may be implemented as a centralized data store so that other data storage services may access data stored in the centralized data store for processing and or storing within the other data storage services, in some embodiments. Such a data storage service  240  may be implemented as an object-based data store, and may provide storage and access to various kinds of object or file data stores for putting, updating, and getting various types, sizes, or collections of data objects or files. Such data storage service(s)  230  may be accessed via programmatic interfaces (e.g., APIs) or graphical user interfaces. A data storage service  240  may provide virtual block-based storage for maintaining data as part of data volumes that can be mounted or accessed similar to local block-based storage devices (e.g., hard disk drives, solid state drives, etc.) and may be accessed utilizing block-based data storage protocols or interfaces, such as internet small computer interface (iSCSI). 
     In various embodiments, data stream and/or event services  250  may provide resources to ingest, buffer, and process streaming data in real-time. In some embodiments, data stream and/or event services  250  may act as an event bus or other communications/notifications for event driven systems or services (e.g., events that occur on provider network  200  services and/or on-premise systems or applications). 
     Generally speaking, clients  270  may encompass any type of client configurable to submit network-based requests to provider network  200  via network  280 , including requests for materialized view management platform  210  (e.g., a request to create a materialized view from different data sources of the other provider network services and identify one or more as a target data source). For example, a given client  270  may 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 client  270  may encompass an application such as a database application (or user interface thereof), a media application, an office application or any other application that may make use of resources in in provider network  200  to implement various features, systems, or applications. (e.g., to store and/or access the data to 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, client  270  may be an application may interact directly with provider network  200 . In some embodiments, client  270  may 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 client  270  may provide access to provider network  200  to other applications in a manner that is transparent to those applications. For example, client  270  may integrate with an operating system or file system to provide storage on one of data storage service(s)  240  (e.g., a block-based storage service). 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(s)  240  may be coordinated by client  270  and the operating system or file system on behalf of applications executing within the operating system environment. 
     Clients  270  may convey network-based services requests (e.g., materialized view creation requests) to and receive responses from provider network  200  via network  280 . In various embodiments, network  280  may encompass any suitable combination of networking hardware and protocols necessary to establish network-based-based communications between clients  270  and provider network  200 . For example, network  280  may generally encompass the various telecommunications networks and service providers that collectively implement the Internet. Network  280  may 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 client  270  and provider network  200  may be respectively provisioned within enterprises having their own internal networks. In such an embodiment, network  280  may 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 client  270  and the Internet as well as between the Internet and provider network  200 . It is noted that in some embodiments, clients  270  may communicate with provider network  200  using a private network rather than the public Internet. 
       FIG. 3  is a logical block diagram illustrating a materialized view management platform that implements managed materialized views created from heterogeneous data sources, according to some embodiments. Client(s)  302  (which may be similar to client(s)  270  in  FIG. 2  above or other types of client systems, services or applications). Client(s)  302  may access materialized view management platform  210  via interface  310 . Interface  310  may be a graphical user interface (e.g., implemented as a console or other graphical control view a website). Interface  310  may be implemented as a command line interface, in some embodiments. Interface  310  maybe implemented as one or multiple programmatic interfaces, (e.g., one or more APIs). As discussed with regard to  FIGS. 4-8 , various types of requests may be received and/or responses sent via interface  310 . 
     Materialized view management platform  210  may implement control plane  320 . Control plane  320  may implement various features for managing the resources and operations for creating and maintaining materialized views. For example, control plane  320  may implement various access control mechanisms or authentication techniques to ensure that requests to create materialized views are made with appropriate authorization (e.g., to create or delete a materialized view). Control plane  320  may implement various health or other system monitoring features to ensure that various features or components of materialized view management platform are functioning correctly, repaired, or replaced. For example, control plane  320  may monitor a number nodes or instances used to implement view creation processing nodes  530  in  FIG. 5  and view maintenance processing nodes  620  in  FIG. 6 ), such as may be collected in pools or groups of instances, and replace, increase, or decrease the number of nodes or instances in order to meet demand or handle failures. 
     As indicated in  FIG. 3 , control plane  320  may implement view performance monitoring  322  in order to monitor the performance of creating and maintaining a materialized view, in some embodiments. For example, view performance monitoring  322  may collect or request performance metrics for change data capture, view computation, and view materialization to send the results to target data stores, and determine whether or not performance criteria for the view has been met. For example, performance criteria may include a lag time or other indicator for the time between when a change occurs at a source and when the change is included in an update made to a target. If the lag time exceeds a threshold amount of time (e.g., 10 minutes), then an adjustment event to reduce the lag time may be triggered. Other performance criteria may include the amount of data that is being received as a change (e.g., how many records, items or objects, or the size of data, such as 5 megabytes). Performance criteria may include criteria specified for the materialized view by a user, owner, developer, or operator via view interface  310 . IN some embodiments, the specified requirements may include limitations or other restrictions on the utilization of some resources (e.g., a limit on the amount of read or write load placed on a data source or target). 
     Control plane  320  may implement view performance adjustments  324  to dynamically scale the resources associated with creating and maintaining a materialized view. In this way, a serverless experience can be provided, as the provisioning, management, allocation of resources may be handled by materialized view management platform  210  (instead of by a user that is manually specifying the amount resources to implement for a materialized view. View performance adjustments  324  may determine responsive actions to adjust materialized view creation and performance according to view performance monitoring  322  (e.g., according to the number and/or type of events detected). For example, view performance adjustments  324  may increase (or decrease) the number of nodes assigned to view maintenance processing in order to keep pace with an increased number of changes received from data sources. a 
     In various embodiments, control plane  320  may maintain, update, and/or access managed view state  326 . Managed view state  326  may indicate the state of various materialized views as the progress between creation and maintenance phases, as discussed below with regard to  FIG. 4 , as well as other state information that informs operations or workflows performed on behalf of a materialized view. For example, managed view state may indicate in state information for a materialized view that the target for that the last maintenance operation to update a materialized view occurred 10 minutes ago and that another check for updates should be performed. Managed view state  326  may identify and/or provide information for various features of materialized view creation  340  and materialized view maintenance  350 , as discussed detail below with regard to  FIGS. 4-7 . 
     In various embodiments, data store  330  may be implemented as part of materialized view management platform  210 . For example, materialized view management platform  332  may implement a managed view catalog  332 . Managed view catalog  332  may store information related to materialized views, including a name, definition, access controls or configuration, maintenance and/or other historical information to indicate the progress or performance of a materialized view (e.g., last time updated). In some embodiments, data store  330  may provide view data and computation storage  334 . For example, various intermediate tables or data, including a final internal version may be generated and stored at  334 . In some embodiments, storage  334  may provide a storage space for perform maintenance operations (e.g., storing data for performing joins or other information). 
     Materialized view management platform  210  may implement data source connectors  360 , in various embodiments. As discussed in detail below with regard to  FIG. 5 , data source connectors  360  may communicate with and obtain changes from data source(s)  304 . In some embodiments, a data source connector  360  may facilitate a change capture protocol or interface for a particular type of data store (e.g., a My SQL connector, a data stream connector, an object store connector) for a corresponding one of data source(s)  304 . As discussed above data source(s)  304  can be various services (or resources hosted within services) of provider network  200 . 
     In various embodiments, materialized view management platform  210  may implement target connector(s)  370 . Target connector(s)  370  may connect to and interact with a target for a materialized view, as discussed in detail below with regard to  FIG. 7 . Similar to a data source connector  360 , a target connector  370  can be respectively implemented for different types of targets (e.g., a target connector for a data warehouse or a target connector for a NoSQL database). As discussed above materialized view target(s)  306  can be various services (or resources hosted within services) of provider network  200 . In some embodiments data source(s)  304  and/or materialized view target(s)  306  can be implemented partially or completely external to provider network  200  (e.g., at an on-premise network or at another provider service network). In some embodiments, materialized view management platform  210  may allow for custom or user-implemented target or source connectors to be provided (e.g., uploaded via an interface and deployed for a requested materialized view) to customize the change data capture or materialized view export (e.g., from on-premise or custom data sources or targets). 
     Materialized view management platform  210  may operate in different phases for a materialized view.  FIG. 4  is a sequence diagram illustrating interactions for creation and maintenance phases for a materialized view managed by a materialized view management platform, according to some embodiments. For example, creation phase  402  may begin with a request to create a materialized view  430  received at materialized view  210  (e.g., via interface  310 ). The creation request  430  may include or specify the data source(s), data target(s), and result definition that the materialized view is to provide, in some embodiments. In some embodiments, the creation request may provide the access credentials (e.g., user id, password, etc.) or other permissions to allow the creation of the materialized view and update of the materialized view in the target. In some embodiments, an identity and access management service may coordinate authentication of materialized view management platform and other services for creation and maintenance of a materialized view. 
     In some embodiments, a graphical interface may provide options of selectable data sources, operations to perform to determine a result from the selectable data sources, and selectable targets to which materialized view management platform  210  is capable of accessing. Once the various materialized view definition parameters are selected, a create user interface element may be selected, which triggers the “create managed materialized view request  430 ” (using the selected parameters and result definition). Alternatively an API may utilized, allowing for a query language or other notation (e.g., JSON, ION, etc.) to specify the data source(s), target(s), and result definition. Similar parameters or inputs can be provided by a command via a command line interface. 
     Materialized view management platform  210  may receive the request  430  and invoke the various features of a view creation process or workflow, as discussed in more detail below with regard to  FIG. 5 . For example, materialized view management platform  210  may send one or more requests  432  to get source data from the data source(s)  410 . These source requests may be formatted according to the language, protocol and/or interface implemented by the respective data sources. In some embodiments, a data source may push the data (e.g., a stream of data) to materialized view management platform  210 . Alternatively, some data sources may allow for materialized view management platform  210  to query or send requests to access the desired data for the materialized view (e.g., according to a result set definition for the materialized view). Materialized view management platform  210  may perform one or multiple requests to store the materialized view(s)  434  in the data target(s)  420 , in various embodiments. For example, materialize view management platform  210  may access (or create) a table that for the materialized view to insert records for the materialized view as rows in the table. 
     The requests to get source data  432  and store data  434  may continue until the materialized view is created. Then, the materialized view may begin maintenance phase  404 . Maintenance phase  404  may allow for materialized view management platform  210  to get  452  or otherwise respond to changes to the data sources (e.g., additional data, removed data, modified data, etc.) in order to compute or otherwise determine an update to a materialized view. For example, if a materialized view provides an aggregation function (e.g., summary, average, count, deviation, etc.) then materialized view management platform  210  may add, divided, subtract, union, join, or other perform various other operations to determine updated values corresponding to the obtained changes. Materialized view management platform  210  may then perform one or more requests to update the new version(s) of the materialized view(s)  454  to include those changes at target(s)  420 . 
     As discussed above with regard to  FIG. 3 , materialized view management platform may implement materialized view creation  340  to handle operations or workflows to create a first instance of a materialized view (which can be subsequently updated).  FIG. 5  is a logical block diagram illustrating materialized view creation, according to some embodiments. Materialized view creation validation  340  may implement view creation validation  510 , in various embodiments. When a creation request, like creation request  502  is received, creation job validation  510  may apply one (or multiple validation) rules to determine whether various features of the materialized view to be created and maintained are valid. For example, view creation validation  510  may validate the existence of and names/identifiers for specified data sources and targets (e.g., according to verification requests to the sources/targets, or from internal metadata maintained for potential sources/targets). View creation validation  510  may validate the syntax or features specified in a result set definition for the materialized view (e.g., what types of joins, inserts, Boolean expressions, merges, updates, etc.) are allowed/supported. An error indication  504  may be provided for invalid creation requests, in some embodiments (e.g., specifying the type of validation error). View creation validation  510  may store the materialized view definition  516  for subsequent access in managed view catalog  332 , in some embodiments. View creation validation  510  may also provide an indication to identify a new view  522  to be created to control plane  320 , in some embodiments. 
     In various embodiments, control plane  320  may perform one or more requests  524  to direct view creation. For example, control plane  320  may dispatch an instruction to begin a materialize view creation to one or more view creation processing nodes  530  which may be provisioned from a fleet or pool of available view creation processing nodes to be dedicated to the creation of the materialized view. View creation processing node(s)  530  may get the materialized view definition  542  from managed view catalog  332 . View creation processing node(s)  530  may implement a creation engine  532  to generate a result set according to the definition of a materialized view from the data sources. For example, creation engine  532  may be a query processor that can process large volumes data from multiple sources, push computation (e.g. joins and aggregations) to sources that can perform such computations efficiently, work over multiple schemas (or not impose a schema requirement) on the sources (e.g., structured, semi-structured, not-structured. In some embodiments, a creation engine may include a rewriting processor prior to a query processor that can rewrite the defining query of the result set for the materialized view definition into subqueries that will be delegated to the sources. In some embodiments, view creation processing nodes may then a source query and fetch back its result. In other embodiments, a source connector (discussed below with regard to  FIG. 6 ) may perform the source queries. In some embodiments, creation engine  532  can deduce from the functions of the query and from the explicit casts that are user provided, the minimum necessary schema needed for the operation of creation engine over schemaless sources (e.g., semi-structured or not-structured sources). For additional ease-of-use, some attributes or portions of data for a materialized view that are just “passing through” materialized view management platform (e.g., without alteration or operation), such as without being arguments of predicates and functions, may be encoded in a schemaless format, like ION. The results of the materialized view creation engine  532  may be stored  554  to a materialized view in the specified targets  554 . 
     As discussed in detail below, in some instances, view creation processing nodes(s)  530  may create and store intermediate tables and/or an internal materialized view version (as indicated at  544 ) in intermediate data storage  334 . In some embodiments, view creation processing nodes(s)  530  may implement maintenance plan creation  534 . Maintenance plan creation  534  may generate a plan (e.g., a query plan) to perform maintenance on a materialized view when a change is received (e.g., when updates to a table are made, when new items in a stream are received, etc.). For instance, maintenance plan creation  534  may also be a federated query engine or other type of query processor that can determine what queries or operations are needed to obtain a result set from the sources as specified in the materialized view when a change to one or more of the data sources is obtained. Maintenance plan creation  534  may store the maintenance plan, as indicated at  546 , for subsequent use, to save computation time when performing updates to maintain a materialized view (e.g., as updates may occur frequently and be made in near continuous fashion to provide a materialized view at a target that is updated in near real-time). 
     View creation processing nodes(s)  530  may report view creation status  526  to control plane  320 . In some embodiments, performance information or other provided information may allow control plane  320  to make adjustments in resources (e.g., increase or decrease view creation processing nodes). 
     Once materialized view creation is complete, control plane  320  may begin the maintenance phase of the materialized view. The maintenance phase may provide near real-time updates for a materialized view, by continuously updating the materialized view when changes are obtained, in some embodiments. Although some lag between a source and materialized view can occur, various techniques to adjust the performance of components of the materialized view maintenance  350  may be performed to decrease lag.  FIG. 6  is a logical block diagram illustrating materialized view maintenance, according to some embodiments. 
     Control plane  320  may dispatch or otherwise direct maintenance of a managed view  612 . For example, control plane  320  may assign  612  one or more connectors  612  to begin obtaining changes from corresponding sources for a materialized view. Connectors  610  may be a separate fleet of nodes or resources that implement protocols, interfaces, or other support for interacting or communication with data sources. Alternatively, in some embodiments, view maintenance processing nodes  620  may implement some or all of the features of connector(s)  610 . 
     Connector(s)  622  may implement change data capture feature  622  to support obtaining changes from a data source. For example, change data capture  622  may enable a changed data capture stream supported by a source database, and register as a recipient, authorized reader, or other component capable of obtaining updates to that source as a change stream  602 . In some embodiments, the data source may be a data stream, and thus the connector  610  may register or request to be a recipient of the data stream. In some embodiments, change data capture may poll for source changes, as indicated at  604 . For example, connector(s)  610  may record or maintain the state of previously received changes from a source (e.g., by timestamp, version identifier, etc.) and use the state to request changes that occurred since the last received state. The changes may be directly sent to view maintenance processing nodes  620 , in some embodiments. In some embodiments, the captured changes may be written to a delta table  633  that corresponds to a data source. 
     Connectors  610  may report source progress or performance information, as indicated at  614 , to control plane  320 . In this way, control plane  320  can make performance determinations to adjust the performance of connectors, in some embodiments. 
     Control plane  320  may direct the maintenance of a managed view, as indicated at  616 , to one or more view maintenance processing nodes  620 . For example, a maintenance task may be assigned to view maintenance processing nodes that cause view maintenance processing node(s)  620  to obtain the maintenance plan  631  (or alternatively view maintenance processing node(s)  620  may generate a view maintenance processing plan). View maintenance processing node(s)  620  may receive indications of new updates or may periodically poll data, such as delta table(s)  633 , to determine when changes have been received. In some embodiments, view maintenance processing node(s)  620  may perform maintenance according to maintenance events or refresh rates that cause materialized view processing node(s)  620  to check for additional changes from delta tables. Alternatively, receiving new changes from connectors  610  can be a maintenance event that triggers performance of a maintenance plan to update a materialized view. 
     In some embodiments, view maintenance processing node(s)  620  may generate a maintenance plan  631  for updating a created materialized view or may obtained a previously created maintenance plan. A maintenance plan may describe the various operations for combining changes to various ones of the data sources to provide an updated view without regenerating the entire materialized view (e.g., by re-querying all sources to obtain all of the materialized view information). In some embodiments, view maintenance processing nodes  620  may implement maintenance plan optimization  632  to rewrite or utilize various features, such as intermediate results stored in intermediate tables  635  and/or utilization local computational capabilities and storage, such as maintenance computation data  637  (instead of using source computational storage and/or capabilities). In this way, view maintenance processing nodes  620  can adapt to the capabilities of the data sources (e.g., supported or unsupported processing operations, such as supporting or not supporting joins, aggregations, etc.) or limitations on the data sources (e.g., read or write limitations on the data sources). 
       FIG. 7  is a logical block diagram illustrating an optimizer for performing maintenance plans, according to some embodiments. Maintenance plan optimization  632  may receive changes for updating a view  702  and a maintenance plan for a view  704 , in various embodiments. Maintenance plan optimization  632  may implement remote or local operation assignment  710  to account for the capabilities and conditions of the different components involved in determining updates to a materialized view. For example, remote/local operation assignment  710  may apply various rewrite rules to detect scenarios when local or remote operation performance is permitted and/or more performant and/or less or more costly. For example, data source computation capabilities  733  may be considered by remote/local operation assignment  710 . If, for instance, a data source cannot perform certain operations (e.g., joins, aggregations, or other data computation operations), then even if such an operation could be pushed down to the remote data source, assignment  710  will make a local operation assignment. 
     In another example, data source computation performance  735  may be considered by remote/local operation assignment  710 . If, for instance, a data source has high or low performance of a certain operation types (e.g., fast single item lookup, slow scan, low single item lookup, fast scan, etc.), then these performance attributes  735  may be considered when rewriting to increase speed or performance of maintenance. (e.g., by assigning slow remote operations locally or fast remote operations remotely). In another example, data source utilization limits  739  maybe considered. For instance, if a read limit for a remote data source would be exceeded (or likely to be exceeded) then, the operation may be assigned locally (as much as possible). For example, data source data locations  731  may indicate when local data can service a maintenance plan instead of a remote query to the data source for that data. Update performance criteria  737  may also be considered when performing rewrites, in some embodiments. If, for instance, a target data system has limited bandwidth to accept updates, then less costly performance operations may be utilized. 
     In various embodiments, some optimizations may be performed to choose whether to utilize local computation data storage, acting as a “scratch pad” for computation view calculations instead of remote queries. If, for instance, the cost of performing an aggregation remotely is very slow or utilizes too much computational capacity on the data source, then local operations may be assigned and local storage utilized store the values that make up the aggregate value to be used. In this way, local compute storage can be used to adjust for the capacities and/or capabilities of remote data sources independent the remote data sources (e.g., by not being dependent upon only the capabilities of the remote data sources to create a materialized view). For example, if the only data sources included in a query cannot perform a join (e.g., two streaming data sources), then data needed to perform the join can be stored for computing the join in the materialized view at the materialized view management platform. Such techniques enhance the materialized view generation capabilities beyond those provided by data sources, in various embodiments. 
     Operation selections  706  may be provided along with maintenance plan for the view  704  to plan rewriter  720 . Plan rewriter  720  may then rewrite the plan and provide the optimized maintenance plan  706  for execution, in some embodiments. 
     View maintenance processing nodes  620  may implement maintenance plan execution  634 . In some embodiments, view maintenance plan execution may be a query engine or processor that can perform the maintenance plan to obtain the changed data (as well as other data needed to make the update). If, for instance, a change is to a value that is joined with other data sources, then even if the other data sources are unchanged, the change may still need to be joined with the data from the unchanged sources, so a query (as indicated at  662 ) may be performed to obtain that unchanged data from the data sources (or in the event it is stored as part of maintenance computation  637 , the local copy can be utilized). In some embodiments, an internal version of the materialized view may be generated which can be used to identify or indicate the changes to be made to the materialized view, as indicated at  639 , or in some embodiments, the materialized view updates may be streamed or sent, as indicated at  660  for export to the target. 
     In some embodiments, view maintenance processing node(s)  620  may rely upon external computation resources (e.g., compute function resource as discussed above with regard to  FIG. 2  of compute services  220 ), which may perform an operation or determine a value used as part of updating a materialized view. Similarly, some data or query operations can be performed by data source resources, and thus queries, such as query  662 , may be performed as part of determining updates to a materialized view. 
     View maintenance processing nodes  620  may report progress and performance information  618  to control plane  320 . In this way, control plane  320  can evaluate the performance of operations to determine updates and make adjustments to scale the resources allocated to maintaining the materialized view to satisfy performance criteria. For example, directing the maintenance of managed view  616  may include operations to add or remove the number view maintenance processing nodes  620 , or modify the criteria or parameters for performing features like maintenance plan optimization  632  (e.g., assigning local or remote operations to optimize for speed, which may incur greater cost, or to optimize for cost, which may incur slower speeds). 
     Once changes to a materialized view have been computed from the changes of a data source, then changes to the materialized view may be materialized by materialized view management platform  210 .  FIG. 8  is a logical block diagram illustrating performance of updates to a target data store for a materialized view, according to some embodiments. As noted in  FIG. 3 , target connector(s)  810  may be implemented to interact with a target for a materialized view. Target connector(s)  810  may be assigned, dispatched or otherwise directed by control plane  320 , as indicated at  812 . For example, target connector(s)  810  may be a separate fleet of nodes or resources that implement protocols, interfaces, or other support for interacting or communication with targets. Alternatively, in some embodiments, view maintenance processing nodes  620  may implement some or all of the features of target(s)  810 . 
     Target connector(s)  810  may obtain the changes to be made to a materialized view, in various embodiments. For example, materialized view update(s)  660  may be sent as computed by a virtual maintenance processing node  620 . In some embodiments, internal version of materialized view  639  may be read to identify the new or changed portions of the materialized view to update at targets. In some embodiments, the updates to a materialized view may be grouped or associated with a snapshot in order to indicate what version of a materialized view should include what changes. When performing updates, such as update requests  830 , target connector(s)  810  may record the progress of making the updates for a particular snapshot (e.g., by submitting checkpoint indications or other progress markers). For instance, a target connector  810  may wait to receive a success acknowledgement  840  for an update request  830  before advancing the progress information (e.g., advancing the checkpoint). If instead a failure response  840  is received, then target connector  810  may retry the update request  830 . In some embodiments, target performance adjustments  830  may track or handle the number of success or response failures (or other feedback from target systems) to adjust the rate of performing update requests  830 . 
     In various embodiments, target connector(s)  810  may implement target-specified update translation  820 . For example, target-specific update translation may perform data type conversions, operation conversions, and/or generate the request parameters needed to perform an update request  830  to make a corresponding change in the materialized view according to the interface of the target system. In some embodiments, target connector(s)  810  may enforce ordering constraints. For example, before performing update request(s)  830 , target connector(s)  810  receive the updates associated with a snapshot and perform the updates in order. In some embodiments, target connector(s)  810  may ensure that a later snapshot is not applied before an earlier snapshot. In some embodiments, target connector(s)  810  may perform deduplication to prevent duplicate updates from being performed. For example, target connector(s)  810  may track the updates successfully performed (as discussed above) in order to prevent a failure from causing an already performed update from being re-performed. 
       FIG. 9  is a logical block diagram illustrating control plane performance adjustments for performing updates to a materialized view, according to some embodiments. As discussed above, view performance monitoring  322  may perform monitoring for various performance conditions or criteria and adjust the performance of various portions of materialized view maintenance. For example, as indicated at  912 , view performance monitoring  912  may detect the unavailability of a target data system (e.g., in response to an error indication received for another materialized view also stored at the target data system). View performance adjustments  324  may instruct the target connector(s)  910  for that materialized view to begin storing or buffering  914  updates. In this way, when the target system becomes available again, target connectors can start from the last performed update and complete the updates to be made. 
     In some embodiments, view performance monitoring  322  may detect when the target update rate is above or below a threshold, as indicated  922 . For example, a target system may have a specified limit for performing updates, in some embodiments, which may be specified by the system itself (or by a user who doesn&#39;t want to over utilize resources in the target just for updating the materialized view). Consequently view performance monitoring  322  can detect when the threshold is exceeded and request a decrease to update rate  924  to target connectors  910 . Source connectors  940  can also be instructed to decrease the change capture rate, as indicated at  926 . In some embodiments, a minimum threshold for target updates (e.g., to meet a lag goal or to fully utilize dedicated resources at the target system) may be evaluated and cause instructions to increase the target update rate to target connectors  910  and/or increase the change capture rate at source connectors  940 , respectively, in some embodiments. 
     In some embodiments, view performance monitoring  322  may detect an increase or decrease in the rate of received changes. View performance adjustments  324  may then send instructions or cause an increase or decrease in maintenance vents  934  to view maintenance processing node(s)  930 . In some embodiments, view performance adjustments  324  may increase the number of view maintenance processing nodes  930  (or decrease them) according to the increase or decrease in the rate of received changes. In this way, view management platform can dynamically respond to the various events or conditions noted above and respond accordingly. 
     Various requests or interactions with a materialized view management platform may be supported to configure creation and maintenance of materialized view and/or obtain information for materialized views.  FIG. 10  is logical block diagram illustrating interactions supported by an example interface for a materialized view management platform, according to some embodiments. 
     As indicated at  1010 , a request to view a materialized view definition  1010  may be received, in some embodiments. In this way, a definition can be inspected or analyzed to understand how the materialized view is achieved (e.g., if received from another system or application that is not the publishing application that requested the creation of the materialized view). As indicated at  1012 , a request to drop a materialized view may be received, in some embodiments, which may cause materialized view management platform  210  to stop obtaining changes, release or reassign resources for performing maintenance, delete any internal data and/or delete the materialized view at a target. 
     As indicated at  1020 , a request to configure view access controls may be received. Such requests  1020  may enable or disable the access rights of different applications or systems to receive a materialized view, in some embodiments. For example, a publisher/subscriber model may be implemented for a materialized view generated by materialized view management platform  210  that may allow for a publishing entity to specify or allow which target systems receive a materialized view. The publisher can then later modify the configuration to disable or add subscribers, in some embodiments. 
     As indicated at  1030 , requests(s) to configure performance scaling  1030  may be received. For example, minimum performance requirements (e.g., maximum allowed lag time, frequency of maintenance events, etc.) may be specified as a request  1030 , which may serve as a trigger for adjustment actions to scale the resources allocated to a materialized view by materialized view management platform  210  to be sized to satisfy the minimum performance requirements. In some embodiments, cost limitations for maintaining the materialized view and/or upper bounds upon the utilization of data sources may also be used to configure performance scaling. In some embodiments, trigger events may be configured for a materialized view, as indicated  1040 , such as notifications of an update or to perform further processing of data at another service (e.g., at a function computation resource), in some embodiments. 
     As indicated at  1050 , requests to get pending change(s)  1050  that have not yet been stored to a materialized view in a target system, in some embodiments. For example, view data/computations storage  334  can be accessed to determine these changes (or they may be determined by a target connector, view maintenance processing node, or other component). In some embodiments, requests  1050  may be distinguish between the various phases of processing, such as an example “GetPendingCommits( )” call that can return the part of the view that has not yet been committed to the target, a “GetTargetCommits( ) call that can return the latest source transaction ids or source timestamps reflected in the external view committed to the target,” and/or a “GetMVPlatformCommits ( )” that can return the latest source transaction ids or source timestamps reflected in the internal view, maintained by materialized view management platform (if any such internal version is maintained). 
     Although  FIGS. 2-10  have been described and illustrated in the context of a provider network implementing a materialized view management platform, the various components illustrated and described in  FIGS. 2-10  may be easily applied to other materialized view management techniques, systems, or devices that manage the creation and management of materialized views across different sources and targets. As such,  FIGS. 2-10  are not intended to be limiting as to other embodiments of a system that may implement managed query execution.  FIG. 11  is a high-level flowchart illustrating various methods and techniques to adjusting performance of materialized view maintenance, according to some embodiments. 
     Various different systems and devices may implement the various methods and techniques described below, either singly or working together. For example, a materialized view management platform such as described above with regard to  FIGS. 2-10  may implement the various methods. Alternatively, a combination of different systems and devices may implement these methods. Therefore, the above examples and or any other systems or devices referenced as performing the illustrated method, are not intended to be limiting as to other different components, modules, systems, or configurations of systems and devices. 
     As indicated at  1110 , performance of updates to a materialized view in a target data store received as a result of changes from different data sources, according to some embodiments. For example, performance criteria for the materialized view maintenance may be specified by a user (e.g., as part of a materialized view definition or separately by one or more requests as discussed above with regard to  FIG. 10 ). The performance criteria may include various computation performance aspects of maintaining the materialized view, such as criteria related to throughput (e.g., lag between the updates to the materialized view and initial change of updates at the data source(s), cost (e.g., demand placed data sources or targets), or other performance impacts of maintaining the materialized view. Some events may be triggered to meet internal performance guarantees or service-level agreements, such as ensuring that updates to a materialized view may not exceed an lag maximum of 10 minutes. Other detected events may include changes in the incoming rate of changes from data sources or backpressure or dropped requests to perform updates from a target data store. Various ones of these performance information may be compared with performance criteria to detect adjustments to return performance of maintenance to a materialized view within the boundaries of desired or specified performance. 
     As indicated at  1120 , the monitoring of performance may be continuously performed, if an event is not detected then monitoring may continue. Moreover, as indicated by the exit from  1130 , if an adjustment is made, then monitoring may continue. in this way, materialized view updates may be dynamically adjusted to compensate for performance changes over time, both internal changes to the materialized view management platform and external changes, experienced at or by data sources or data targets. 
     As discussed above with regard to  FIGS. 1, 7, and 9 , various kinds of adjustments may be made to different portions of the workflow for maintaining a materialized view. For example, in some embodiments an adjustment may be made to the performance of obtaining changes from data sources. Polling rates for changes may be increased as well as the amount of data asked for in a polling request. In some embodiments, data connectors or other ingestion components may increase the rate at which ingestion processing is performed (e.g., decreasing batch sizes before sending a notification of changes or updating a delta table). In some embodiments, a request to data sources to increase the rate of sending changes (e.g., frequency) may be performed. In some embodiments, similar techniques may be used to reduce, throttle, or otherwise slow down the obtaining of changes. 
     In some embodiments, the adjustment may be made to the performance of determining updates. For example, maintenance events that cause update computations to proceed may be increased (or decreased). In some embodiments, additional resources may be added or removed, such as additional or fewer view maintenance processing nodes. 
     In some embodiments, the adjustment may be made to the performance of updates to a materialized view in a target data store. For example, the rate at which requests are sent may be increased, or decreased. In some embodiments, in the event of the failure of a target data store, the changes may be buffered, queued, or otherwise stored until the target data store becomes available again. 
     Adjustments may also be made when computing updates to the materialized view, as discussed above with regard to  FIG. 7 .  FIG. 12  is a high-level flowchart illustrating various methods and techniques to rewrite maintenance plans to optimize performance of materialized view maintenance, according to some embodiments. As indicated at  1210 , changes from data sources may be received for a materialized view. A determination to assign operations for local or remote execution may be performed to update the materialized view to include the changes, as indicated at  1220 , in some embodiments. Then, as indicated at  1230 , the maintenance plan may be rewritten based on the operation assignments, in some embodiments. As indicated at  1240 , the rewritten maintenance plan may be executed to include the changes in an internal version of the materialized view, in various embodiments. 
     The methods described herein may in various embodiments be implemented by any combination of hardware and software. For example, in one embodiment, the methods may be implemented by a computer system (e.g., a computer system as in  FIG. 13 ) that includes one or more processors executing program instructions stored on a computer-readable storage medium coupled to the processors. The program instructions may be configured to implement the functionality described herein (e.g., the functionality of various servers and other components that implement the network-based virtual computing resource provider described herein). The various methods as illustrated in the figures and described herein represent example embodiments of methods. The order of any method may be changed, and various elements may be added, reordered, combined, omitted, modified, etc. 
     Embodiments of managed materialized views created from heterogeneous data sources as described herein may be executed on one or more computer systems, which may interact with various other devices. One such computer system is illustrated by  FIG. 13 . In different embodiments, computer system  2000  may be any of various types of devices, including, but not limited to, a personal computer system, desktop computer, laptop, notebook, or netbook computer, mainframe computer system, handheld computer, workstation, network computer, a camera, a set top box, a mobile device, a consumer device, video game console, handheld video game device, application server, storage device, a peripheral device such as a switch, modem, router, or in general any type of computing device, computing node, compute node, computing system compute system, or electronic device. 
     In the illustrated embodiment, computer system  2000  includes one or more processors  2010  coupled to a system memory  2020  via an input/output (I/O) interface  2030 . Computer system  2000  further includes a network interface  2040  coupled to I/O interface  2030 , and one or more input/output devices  2050 , such as cursor control device  2060 , keyboard  2070 , and display(s)  2080 . Display(s)  2080  may include standard computer monitor(s) and/or other display systems, technologies or devices. In at least some implementations, the input/output devices  2050  may also include a touch- or multi-touch enabled device such as a pad or tablet via which a user enters input via a stylus-type device and/or one or more digits. In some embodiments, it is contemplated that embodiments may be implemented using a single instance of computer system  2000 , while in other embodiments multiple such systems, or multiple nodes making up computer system  2000 , may host different portions or instances of embodiments. For example, in one embodiment some elements may be implemented via one or more nodes of computer system  2000  that are distinct from those nodes implementing other elements. 
     In various embodiments, computer system  2000  may be a uniprocessor system including one processor  2010 , or a multiprocessor system including several processors  2010  (e.g., two, four, eight, or another suitable number). Processors  2010  may be any suitable processor capable of executing instructions. For example, in various embodiments, processors  2010  may be general-purpose or embedded processors implementing any of a variety of instruction set architectures (ISAs), such as the x86, PowerPC, SPARC, or MIPS ISAs, or any other suitable ISA. In multiprocessor systems, each of processors  2010  may commonly, but not necessarily, implement the same ISA. 
     In some embodiments, at least one processor  2010  may be a graphics processing unit. A graphics processing unit or GPU may be considered a dedicated graphics-rendering device for a personal computer, workstation, game console or other computing or electronic device. Modern GPUs may be very efficient at manipulating and displaying computer graphics, and their highly parallel structure may make them more effective than typical CPUs for a range of complex graphical algorithms. For example, a graphics processor may implement a number of graphics primitive operations in a way that makes executing them much faster than drawing directly to the screen with a host central processing unit (CPU). In various embodiments, graphics rendering may, at least in part, be implemented by program instructions configured for execution on one of, or parallel execution on two or more of, such GPUs. The GPU(s) may implement one or more application programmer interfaces (APIs) that permit programmers to invoke the functionality of the GPU(s). Suitable GPUs may be commercially available from vendors such as NVIDIA Corporation, ATI Technologies (AMD), and others. 
     System memory  2020  may store program instructions and/or data accessible by processor  2010 . In various embodiments, system memory  2020  may be implemented using any suitable memory technology, such as static random access memory (SRAM), synchronous dynamic RAM (SDRAM), nonvolatile/Flash-type memory, or any other type of memory. In the illustrated embodiment, program instructions and data implementing desired functions, such as those described above are shown stored within system memory  2020  as program instructions  2025  and data storage  2035 , respectively. In other embodiments, program instructions and/or data may be received, sent or stored upon different types of computer-accessible media or on similar media separate from system memory  2020  or computer system  2000 . Generally speaking, a non-transitory, computer-readable storage medium may include storage media or memory media such as magnetic or optical media, e.g., disk or CD/DVD-ROM coupled to computer system  2000  via I/O interface  2030 . Program instructions and data stored via a computer-readable medium may be transmitted by transmission media or signals such as electrical, electromagnetic, or digital signals, which may be conveyed via a communication medium such as a network and/or a wireless link, such as may be implemented via network interface  2040 . 
     In one embodiment, I/O interface  2030  may coordinate I/O traffic between processor  2010 , system memory  2020 , and any peripheral devices in the device, including network interface  2040  or other peripheral interfaces, such as input/output devices  2050 . In some embodiments, I/O interface  2030  may perform any necessary protocol, timing or other data transformations to convert data signals from one component (e.g., system memory  2020 ) into a format suitable for use by another component (e.g., processor  2010 ). In some embodiments, I/O interface  2030  may 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 interface  2030  may be split into two or more separate components, such as a north bridge and a south bridge, for example. In addition, in some embodiments some or all of the functionality of I/O interface  2030 , such as an interface to system memory  2020 , may be incorporated directly into processor  2010 . 
     Network interface  2040  may allow data to be exchanged between computer system  2000  and other devices attached to a network, such as other computer systems, or between nodes of computer system  2000 . In various embodiments, network interface  2040  may support communication via wired or wireless general data networks, such as any suitable type of Ethernet network, for example; 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. 
     Input/output devices  2050  may, in some embodiments, include one or more display terminals, keyboards, keypads, touchpads, scanning devices, voice or optical recognition devices, or any other devices suitable for entering or retrieving data by one or more computer system  2000 . Multiple input/output devices  2050  may be present in computer system  2000  or may be distributed on various nodes of computer system  2000 . In some embodiments, similar input/output devices may be separate from computer system  2000  and may interact with one or more nodes of computer system  2000  through a wired or wireless connection, such as over network interface  2040 . 
     As shown in  FIG. 13 , memory  2020  may include program instructions  2025 , may implement the various methods and techniques as described herein, and data storage  2035 , comprising various data accessible by program instructions  2025 . In one embodiment, program instructions  2025  may include software elements of embodiments as described herein and as illustrated in the Figures. Data storage  2035  may include data that may be used in embodiments. In other embodiments, other or different software elements and data may be included. 
     Those skilled in the art will appreciate that computer system  2000  is merely illustrative and is not intended to limit the scope of the techniques as described herein. In particular, the computer system and devices may include any combination of hardware or software that can perform the indicated functions, including a computer, personal computer system, desktop computer, laptop, notebook, or netbook computer, mainframe computer system, handheld computer, workstation, network computer, a camera, a set top box, a mobile device, network device, internet appliance, PDA, wireless phones, pagers, a consumer device, video game console, handheld video game device, application server, storage device, a peripheral device such as a switch, modem, router, or in general any type of computing or electronic device. Computer system  2000  may also be connected to other devices that are not illustrated, or instead may operate as a stand-alone system. In addition, the functionality provided by the illustrated components may in some embodiments be combined in fewer components or distributed in additional components. Similarly, in some embodiments, the functionality of some of the illustrated components may not be provided and/or other additional functionality may be available. 
     Those skilled in the art will also appreciate that, while various items are illustrated as being stored in memory or on storage while being used, these items or portions of them may be transferred between memory and other storage devices for purposes of memory management and data integrity. Alternatively, in other embodiments some or all of the software components may execute in memory on another device and communicate with the illustrated computer system via inter-computer communication. Some or all of the system components or data structures may also be stored (e.g., as instructions or structured data) on a computer-accessible medium or a portable article to be read by an appropriate drive, various examples of which are described above. In some embodiments, instructions stored on a non-transitory, computer-accessible medium separate from computer system  2000  may be transmitted to computer system  2000  via 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. 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. Accordingly, the present invention may be practiced with other computer system configurations. 
     It is noted that any of the distributed system embodiments described herein, or any of their components, may be implemented as one or more web services. For example, leader nodes within a data warehouse system may present data storage services and/or database services to clients as network-based services. In some embodiments, a network-based service may be implemented by a software and/or hardware system designed to support interoperable machine-to-machine interaction over a network. A network-based service may have an interface described in a machine-processable format, such as the Web Services Description Language (WSDL). Other systems may interact with the web service in a manner prescribed by the description of the network-based service&#39;s interface. For example, the network-based service may define various operations that other systems may invoke, and may define a particular application programming interface (API) to which other systems may be expected to conform when requesting the various operations. 
     In various embodiments, a network-based service may be requested or invoked through the use of a message that includes parameters and/or data associated with the network-based services request. Such a message may be formatted according to a particular markup language such as Extensible Markup Language (XML), and/or may be encapsulated using a protocol such as Simple Object Access Protocol (SOAP). To perform a web services request, a network-based services client may assemble a message including the request and convey the message to an addressable endpoint (e.g., a Uniform Resource Locator (URL)) corresponding to the web service, using an Internet-based application layer transfer protocol such as Hypertext Transfer Protocol (HTTP). 
     In some embodiments, web services may be implemented using Representational State Transfer (“RESTful”) techniques rather than message-based techniques. For example, a web service implemented according to a RESTful technique may be invoked through parameters included within an HTTP method such as PUT, GET, or DELETE, rather than encapsulated within a SOAP message. 
     The various methods as illustrated in the FIGS. and described herein represent example embodiments of methods. The methods may be implemented in software, hardware, or a combination thereof. The order of method may be changed, and various elements may be added, reordered, combined, omitted, modified, 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 that the invention embrace all such modifications and changes and, accordingly, the above description to be regarded in an illustrative rather than a restrictive sense.