Patent Grant
9396242
A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
One or more implementations relate generally to replication in a multi-tenant database system in a database network system.
The subject matter discussed in the background section should not be assumed to be prior art merely as a result of its mention in the background section. Similarly, a problem mentioned in the background section or associated with the subject matter of the background section should not be assumed to have been previously recognized in the prior art. The subject matter in the background section merely represents different approaches, which in and of themselves may also be inventions.
In conventional database systems, users access their data resources in one logical database. A user of such a conventional system typically retrieves data from and stores data on the system using the user's own systems. A user system might remotely access one of a plurality of server systems that might in turn access the database system. Data retrieval from the system might include the issuance of a query from the user system to the database system. The database system might process the request for information received in the query and send to the user system information relevant to the request. The rapid, secure, and efficient retrieval of accurate information and subsequent delivery of this information to the user system has been and continues to be a goal of administrators of database systems.
Unfortunately, conventional database approaches sometimes have difficulty with replication, and with processing updates to database tables.
Accordingly, it is desirable to provide techniques enabling improved replication within a database system.
In the following drawings like reference numbers are used to refer to like elements. Although the following figures depict various examples, the one or more implementations are not limited to the examples depicted in the figures.
As used herein, the term multi-tenant database system refers to those systems in which various elements of hardware and software of the database system may be shared by one or more customers. For example, a given application server may simultaneously process requests for a great number of customers, and a given database table may store rows for a potentially much greater number of customers.
Environment 1110 is an environment in which an on-demand database service exists. User system 1112 may be any machine or system that is used by a user to access a database user system. For example, any of user systems 1112 can be a handheld computing device, a mobile phone, a laptop computer, a work station, and/or a network of computing devices. As illustrated in
An on-demand database service, such as system 1116, is a database system that is made available to outside users that do not need to necessarily be concerned with building and/or maintaining the database system, but instead may be available for their use when the users need the database system (e.g., on the demand of the users). Some on-demand database services may store information from one or more tenants stored into tables of a common database image to form a multi-tenant database system (MTS). Accordingly, “on-demand database service 1116” and “system 1116” will be used interchangeably herein. A database image may include one or more database objects. A relational database management system (RDMS) or the equivalent may execute storage and retrieval of information against the database object(s). Application platform 1118 may be a framework that allows the applications of system 1116 to run, such as the hardware and/or software, e.g., the operating system. In an embodiment, on-demand database service 1116 may include an application platform 1118 that enables creation, managing and executing one or more applications developed by the provider of the on-demand database service, users accessing the on-demand database service via user systems 1112, or third party application developers accessing the on-demand database service via user systems 1112.
The users of user systems 1112 may differ in their respective capacities, and the capacity of a particular user system 1112 might be entirely determined by permissions (permission levels) for the current user. For example, where a salesperson is using a particular user system 1112 to interact with system 1116, that user system has the capacities allotted to that salesperson. However, while an administrator is using that user system to interact with system 1116, that user system has the capacities allotted to that administrator. In systems with a hierarchical role model, users at one permission level may have access to applications, data, and database information accessible by a lower permission level user, but may not have access to certain applications, database information, and data accessible by a user at a higher permission level. Thus, different users will have different capabilities with regard to accessing and modifying application and database information, depending on a user's security or permission level.
Network 1114 is any network or combination of networks of devices that communicate with one another. For example, network 1114 can be any one or any combination of a LAN (local area network), WAN (wide area network), telephone network, wireless network, point-to-point network, star network, token ring network, hub network, or other appropriate configuration. As the most common type of computer network in current use is a TCP/IP (Transfer Control Protocol and Internet Protocol) network, such as the global internetwork of networks often referred to as the “Internet” with a capital “I”, that network will be used in many of the examples herein. However, it should be understood that the networks that the one or more implementations might use are not so limited, although TCP/IP is a frequently implemented protocol.
User systems 1112 might communicate with system 1116 using TCP/IP and, at a higher network level, use other common Internet protocols to communicate, such as HTTP, FTP, AFS, WAP, etc. In an example where HTTP is used, user system 1112 might include an HTTP client commonly referred to as a browser for sending and receiving HTTP messages to and from an HTTP server at system 1116. Such an HTTP server might be implemented as the sole network interface between system 1116 and network 1114, but other techniques might be used as well or instead. In some implementations, the interface between system 1116 and network 1114 includes load sharing functionality, such as round-robin HTTP request distributors to balance loads and distribute incoming HTTP requests evenly over a plurality of servers. At least as for the users that are accessing that server, each of the plurality of servers has access to the MTS' data; however, other alternative configurations may be used instead.
In one embodiment, system 1116, shown in
One arrangement for elements of system 1116 is shown in
Several elements in the system shown in
According to one embodiment, each user system 1112 and all of its components are operator configurable using applications, such as a browser, including computer code run using a central processing unit such as an Intel Pentium® processor or the like. Similarly, system 1116 (and additional instances of an MTS, where more than one is present) and all of their components might be operator configurable using application(s) including computer code to run using a central processing unit such as processor system 1117, which may include an Intel Pentium® processor or the like, and/or multiple processor units. A computer program product embodiment includes a machine-readable storage medium (media) having instructions stored thereon/in which can be used to program a computer to perform any of the processes of the embodiments described herein. Computer code for operating and configuring system 16 to intercommunicate and to process webpages, applications and other data and media content as described herein are preferably downloaded and stored on a hard disk, but the entire program code, or portions thereof, may also be stored in any other volatile or non-volatile memory medium or device as is well known, such as a ROM or RAM, or provided on any media capable of storing program code, such as any type of rotating media including floppy disks, optical discs, digital versatile disk (DVD), compact disk (CD), microdrive, and magneto-optical disks, and magnetic or optical cards, nanosystems (including molecular memory ICs), or any type of media or device suitable for storing instructions and/or data. Additionally, the entire program code, or portions thereof, may be transmitted and downloaded from a software source over a transmission medium, e.g., over the Internet, or from another server, as is well known, or transmitted over any other conventional network connection as is well known (e.g., extranet, VPN, LAN, etc.) using any communication medium and protocols (e.g., TCP/IP, HTTP, HTTPS, Ethernet, etc.) as are well known. It will also be appreciated that computer code for implementing embodiments can be implemented in any programming language that can be executed on a client system and/or server or server system such as, for example, C, C++, HTML, any other markup language, Java™, JavaScript, ActiveX, any other scripting language, such as VBScript, and many other programming languages as are well known may be used. (Java™ is a trademark of Sun Microsystems, Inc.).
According to one embodiment, each system 1116 is configured to provide webpages, forms, applications, data and media content to user (client) systems 1112 to support the access by user systems 1112 as tenants of system 1116. As such, system 1116 provides security mechanisms to keep each tenant's data separate unless the data is shared. If more than one MTS is used, they may be located in close proximity to one another (e.g., in a server farm located in a single building or campus), or they may be distributed at locations remote from one another (e.g., one or more servers located in city A and one or more servers located in city B). As used herein, each MTS could include one or more logically and/or physically connected servers distributed locally or across one or more geographic locations. Additionally, the term “server” is meant to include a computer system, including processing hardware and process space(s), and an associated storage system and database application (e.g., OODBMS or RDBMS) as is well known in the art. It should also be understood that “server system” and “server” are often used interchangeably herein. Similarly, the database object described herein can be implemented as single databases, a distributed database, a collection of distributed databases, a database with redundant online or offline backups or other redundancies, etc., and might include a distributed database or storage network and associated processing intelligence.
User system 1112, network 1114, system 1116, tenant data storage 1122, and system data storage 1124 were discussed above in
Application platform 1118 includes an application setup mechanism 1238 that supports application developers' creation and management of applications, which may be saved as metadata into tenant data storage 1122 by save routines 1236 for execution by subscribers as one or more tenant process spaces 1204 managed by tenant management process 1210 for example. Invocations to such applications may be coded using PL/SOQL 1234 that provides a programming language style interface extension to API 1232. A detailed description of some PL/SOQL language embodiments is discussed in commonly owned U.S. Pat. No. 7,730,478 entitled, METHOD AND SYSTEM FOR ALLOWING ACCESS TO DEVELOPED APPLICATIONS VIA A MULTI-TENANT ON-DEMAND DATABASE SERVICE, by Craig Weissman, filed Sep. 21, 2007, which is incorporated in its entirety herein for all purposes. Invocations to applications may be detected by one or more system processes, which manage retrieving application metadata 1216 for the subscriber making the invocation and executing the metadata as an application in a virtual machine.
Each application server 1200 may be communicably coupled to database systems, e.g., having access to system data 1125 and tenant data 1123, via a different network connection. For example, one application server 12001 might be coupled via the network 1114 (e.g., the Internet), another application server 1200N-1 might be coupled via a direct network link, and another application server 1200N might be coupled by yet a different network connection. Transfer Control Protocol and Internet Protocol (TCP/IP) are typical protocols for communicating between application servers 1200 and the database system. However, it will be apparent to one skilled in the art that other transport protocols may be used to optimize the system depending on the network interconnect used.
In certain embodiments, each application server 1200 is configured to handle requests for any user associated with any organization that is a tenant. Because it is desirable to be able to add and remove application servers from the server pool at any time for any reason, there is preferably no server affinity for a user and/or organization to a specific application server 1200. In one embodiment, therefore, an interface system implementing a load balancing function (e.g., an F5 Big-IP load balancer) is communicably coupled between the application servers 1200 and the user systems 1112 to distribute requests to the application servers 1200. In one embodiment, the load balancer uses a least connections algorithm to route user requests to the application servers 1200. Other examples of load balancing algorithms, such as round robin and observed response time, also can be used. For example, in certain embodiments, three consecutive requests from the same user could hit three different application servers 1200, and three requests from different users could hit the same application server 1200. In this manner, system 1116 is multi-tenant, wherein system 1116 handles storage of, and access to, different objects, data and applications across disparate users and organizations.
As an example of storage, one tenant might be a company that employs a sales force where each salesperson uses system 1116 to manage their sales process. Thus, a user might maintain contact data, leads data, customer follow-up data, performance data, goals and progress data, etc., all applicable to that user's personal sales process (e.g., in tenant data storage 1122). In an example of a MTS arrangement, since all of the data and the applications to access, view, modify, report, transmit, calculate, etc., can be maintained and accessed by a user system having nothing more than network access, the user can manage his or her sales efforts and cycles from any of many different user systems. For example, if a salesperson is visiting a customer and the customer has Internet access in their lobby, the salesperson can obtain critical updates as to that customer while waiting for the customer to arrive in the lobby.
While each user's data might be separate from other users' data regardless of the employers of each user, some data might be organization-wide data shared or accessible by a plurality of users or all of the users for a given organization that is a tenant. Thus, there might be some data structures managed by system 1116 that are allocated at the tenant level while other data structures might be managed at the user level. Because an MTS might support multiple tenants including possible competitors, the MTS should have security protocols that keep data, applications, and application use separate. Also, because many tenants may opt for access to an MTS rather than maintain their own system, redundancy, up-time, and backup are additional functions that may be implemented in the MTS. In addition to user-specific data and tenant specific data, system 1116 might also maintain system level data usable by multiple tenants or other data. Such system level data might include industry reports, news, postings, and the like that are sharable among tenants.
In certain embodiments, user systems 1112 (which may be client systems) communicate with application servers 1200 to request and update system-level and tenant-level data from system 616 that may require sending one or more queries to tenant data storage 1122 and/or system data storage 1124. System 1116 (e.g., an application server 1200 in system 1116) automatically generates one or more SQL statements (e.g., one or more SQL queries) that are designed to access the desired information. System data storage 1124 may generate query plans to access the requested data from the database.
Each database can generally be viewed as a collection of objects, such as a set of logical tables, containing data fitted into predefined categories. A table is one representation of a data object, and may be used herein to simplify the conceptual description of objects and custom objects. It should be understood that “table” and “object” may be used interchangeably herein. Each table generally contains one or more data categories logically arranged as columns or fields in a viewable schema. Each row or record of a table contains an instance of data for each category defined by the fields. For example, a CRM database may include a table that describes a customer with fields for basic contact information such as name, address, phone number, fax number, etc. Another table might describe a purchase order, including fields for information such as customer, product, sale price, date, etc. In some multi-tenant database systems, standard entity tables might be provided for use by all tenants. For CRM database applications, such standard entities might include tables for Account, Contact, Lead, and Opportunity data, each containing pre-defined fields. It should be understood that the word “entity” may also be used interchangeably herein with “object” and “table”.
In some multi-tenant database systems, tenants may be allowed to create and store custom objects, or they may be allowed to customize standard entities or objects, for example by creating custom fields for standard objects, including custom index fields. U.S. patent application Ser. No. 10/817,161, filed Apr. 2, 2004, entitled “Custom Entities and Fields in a Multi-Tenant Database System”, and which is hereby incorporated herein by reference, teaches systems and methods for creating custom objects as well as customizing standard objects in a multi-tenant database system. In certain embodiments, for example, all custom entity data rows are stored in a single multi-tenant physical table, which may contain multiple logical tables per organization. It is transparent to customers that their multiple “tables” are in fact stored in one large table or that their data may be stored in the same table as the data of other customers.
While one or more implementations have been described by way of example and in terms of the specific embodiments, it is to be understood that one or more implementations are not limited to the disclosed embodiments. To the contrary, it is intended to cover various modifications and similar arrangements as would be apparent to those skilled in the art. Therefore, the scope of the appended claims should be accorded the broadest interpretation so as to encompass all such modifications and similar arrangements.
Overview: Replication, Instances, and Chunks
Replication is a process where each instance of a database continually exchanges modified database records for a set of tables, typically a small set, with other instances of the database. It is a goal for replicated tables to be identical everywhere. For example, a database instance may contain the most recent copy of all users from all instances, and is used to ensure that users can log in regardless of which instance they arrive at.
“Database instances” are disjointed (sharded) sets of customer data, each of may resides on a physically and logically distinct, shared-nothing database servers. Data is often not the same across different instances. Instead, each database has different data in every table. The cross-instance data replication described herein forms an exception to that situation. Instead, the environment 1110 comprises a multi-master replication system, which allows a large set of peer instances (multiple masters) to collaboratively replicate data to each other.
An arrangement 100 of instances is shown in
An instance may detect changes made directly on that instance. Instances package these changes into chunks, which store metadata about a set of changed records. These chunks are then sent to other instances where they are persisted locally and applied (upserted) to the underlying table. Lists of chunk metadata are passed around between instances and copied locally to each instance; then, each chunk is requested and the records contained in it are persisted (upserted) to the underlying replicated table. In a LIST command, the result obtained is a list of chunks with their IDs and metadata, but no data from the underlying tables.
All instances need to find out about and obtain modifications to shared tables. The chunks described herein provide a single consistent unit to deal with both change detection and transport.
The embodiments disclosed herein promote and enhance reliable database replication. For the purposes of this disclosure, replication consists of 4 main processes: I Change Detection, II Serving Changes, III Requesting Changes, and IV Upserting Changes. Within any given instance, responsibility for these four processes will belong to either the client or server, and will be so designated below.
I Change Detection (Responsibility of Server)
Detecting changes properly within a database system is a subtle process. The desired end result of a change detection process is that any modification to an underlying table results in one or more chunks being created, which an instance's server will then serve upon request. In an embodiment, a change detection process utilizes an indexer framework.
An example change detection process is shown in
As shown in
Detecting deletes is slightly different from detecting changes (e.g. writes). In addition to triggering the indexer to run, deletes also fire a trigger that writes the deleted key to a separate delete record/table. These delete markers are then treated the same as inserts and updates. Any query that gets modifications from the underlying table always gets both modifications together.
During the change detection process, the underlying records may be selected from a database in order to determine a chunk's properties. At this time, if so configured, such a change detection process can immediately cache a serialized version of the chunk.
II Serving Changed Data (Responsibility of the Server)
Serving data is a passive process. Requests for data may be made over HTTP and served by a servlet running on standard front-end web servers. The data itself may be returned in binary format, serialized into binary format using any desired serialization library on a server, and deserialized via the same serialization library into java objects on a client.
In an embodiment, two HTTP operations are used to serve the changed data: LIST, which returns a set of the available chunks, by entity, date, etc, and GET, which returns the underlying data for exactly one chunk, by ID. An example 400 of such a serving process is shown in
In
Servers can return requested chunks in one of two ways: either directly from the underlying tables, or from the cache referred to earlier.
Any instance can honor requests from any other instance, about their own data or data from another instance (as in the case of leaders, which will be explained in more detail below). If an instance's server can not answer the request, it returns an HTTP error status code indicating the nature of the problem. Generally, this indicates an unexpected error, but there are some cases where it can indicate an expected condition (such as asking a leader for a remote chunk that is so old that leader no longer has it).
III Requesting Changed Data (Responsibility of the Client)
It is important that the current state of the distributed database system always be available. The following is one non-limiting example of achieving this.
To formulate requests, a client looks at its map of who the instances and leaders are in each data center, in order to decide who to ask for which data. This information can be maintained as a standard part of instance deployment via XML files that are created and maintained as part of the source code configuration tree (configs). Each instance contains pointers to all other instances, including a unique one-character instance ID, a URL, and a few other pieces of information. This configuration information exists separately on each physical machine in the cluster, and should be (but is not guaranteed to be) identical.
To maintain a consistent view of this information across the entire distributed database system, a replication process exists that synchronizes this XML configuration information into a single instance configuration table within the distributed database system. All database updates—whether related to changes in the underlying XML files during releases, or related to run-time changes in state like discovering that a particular instance is currently unreachable—are routed into this instance configuration table, so that every actor (whether client or server) shares the same view of the current state of the instance list.
The source of truth for the instance configuration table is the information in the XML files. The information contained therein is static, in that it only changes when a human (presumably a developer or operations person) manually changes it (for example, when bringing an entirely new instance online).
In addition, the instance configuration table also holds a set of dynamic information that is equally important. This information includes at least the following (not a close-ended list): whether the instance is currently known to be reachable, the last date when the instance was successfully reached by the current instance, and a data structure containing the most recently applied chunk date for each replicated entity.
This information is critical to successful operation of the embodiments described herein, and thus is stored in a database table (rather than simply being read from read-only XML files at run time). When an instance becomes unreachable, for example because of a network partition between data centers, it is important that all the individual machine nodes within an instance share the same view, and get the same results from the leader election algorithm.
A database table is used to store the instance configuration information because doing so is inexpensive and expedient, but other forms of shared coordination are also contemplated within the embodiments disclosed herein.
In an embodiment, replication logic is also held within the client. An example client replication flow 500 is shown in
The local chunk table mentioned above is a database table that maintains information about each chunk of replicated records, both those created on the local instances as well as those obtained from remote instances and applied locally. This is expected to have into the hundreds of thousands of records over time (though this number is kept finite by regular chunk truncation and compaction, as discussed elsewhere herein).
Replication, Leaders, and Non-Leaders
Database replication can be extremely complex, with significant overhead. Each instance produces a stream of modifications (updates, inserts, and deletes) affecting its local database tables. Those modifications must then be applied to every other instance in the set of peer instances. As an example, consider 12 peer instances; a single insert into each instance will result in a total of 144 inserts once everything is replicated (i.e., the 12 original inserts, plus all 12 instances also inserting the row from each of their 11 peers).
Naturally, these modifications must also be transported between the instances, via the network. At a minimum, every row must make at least N−1 hops, from the source to the destination (for a total of 132 hops, in this scenario).
An example arrangement 600 of data centers 604X and instances is shown in
To facilitate this, as shown in
Leader selection is done by looking at a configured value for each known instance (called “leaderID”, stored in the instance XML configuration files explained above), and picking the lowest-numbered reachable instance in each data center to be the leader. In the event of a tie, where two instances have the same number, the tie is broken by referring to the instance name in ascending order. LeaderIDs are assigned manually in the XML configuration files. These monitor general instance health, and choose leaders in order of desirability based on load. It is preferred that leaders be instances that are not already operating at their maximum capacity.
“Unreachable” means “temporarily inactive”. If an instance attempts to communicate with another instance and receives an I/O error (any kind of error saying that the connection couldn't be completed), that instance immediately marks the other instance as “unreachable” and then re-runs the leader election algorithm to determine whether the removal of this instance changes who the currently configured leaders are.
Reachability of all instances is constantly being re-evaluated. Instances will continue to attempt to reach instances they previously marked as unreachable, and as soon as a connection can be made again, the instance is marked as reachable again, thereby re-initiating another leader election process.
If an instance is not a leader, that instance communicates directly with everyone in its data center. From the other non-leader instances, that non-leader instance can request only their local updates. A leader instance can request data for all remote instances. A leader communicates with everyone in its data center, plus the leaders in other data centers. Local instances request updates directly from all other local instances. It is possible to request data for all the instances in from a remote leaders' data center.
In addition to serving their own changes, in one embodiment, instances can also act as a proxy for changes made elsewhere, particularly if they are acting as the leader for their data center. In that case, other peer instances may ask them for changes that are not their own, and that instance's server can reply with their local copy of the changed data. For example, from
Upserts don't trigger a change detection process on a destination instance because the source instance ID is different from the destination instance ID. As such, the change detection triggers do fire, but nothing is written to the indexer queue or delete log.
IV Upserting Changed Data (Responsibility of Client)
Once a client receives new data from a remote server, that client seeks to push that data into its own local database tables as quickly as possible. In this upsert process (which is really more of an “upselete” process, since it includes deletes), the blob (binary large object) of records is passed into a PL/SQL procedure. Two core PL/SQL statements are used within the upsert process: MERGE (for the inserts and updates) and DELETE (for the deletes). Both statements check that the modstamp of the new row is strictly later than the existing one; otherwise, the new row is ignored. This makes the upsert process both idempotent and resilient to reordering. Chunks can be processed in any order, and the end state will be the same.
In addition to running a DELETE statement for delete rows, an instance also persists these into its own delete table. This is only necessary for leader instances, who may be called on to resend the upserted chunk to another instance (only if the serialized form of the chunk isn't cached). However, since any instance can become a leader at any time, all upserts store the delete markers.
Managing Chunks, Compaction
Normal operation over the course of a day can cause an instance to create a large number of chunks. The absolute maximum (for a partitioned entity assuming 60 second change detection granularity) would be 32 partitions*1440 runs=46080 chunks/day. It is unlikely that a single instance would see a modification to a record in every partition every minute of the day, so the real number will likely be much smaller than that.
After some period of time, normal system operation will distribute these updates to all other instances, so that it ceases to be necessary to keep all the historical chunks. It is still desired to have the ability to serve the modifications from an earlier period if asked, e.g. if a peer instance was offline for some large period of time, or needs to rebuild its table from scratch.
Accordingly, instead of just truncating the old chunks, they are compacted by combining their definitions and forming a minimum covering set, which are marked as catchup chunks. Assuming there were fewer than 3000 modifications in each partition during the course of the day on that instance, the entire set of chunks would be replaced by a single chunk for that partition. If there were more than 3000 modifications, then the system would create multiple spanning chunks.
An example of this compaction is shown in
Requests for data older than the compaction threshold return these catchup chunks, which are exactly the same as regular chunks, except:
Catchup chunks are only saved on the original source instance; leaders do not save catchup chunks they receive from other instances. So if a LIST request is seeking data that's older than the compaction threshold from a leader, the leader will send a reply saying “this is too old, go ask the instance directly.” An instance will always serve its own chunks, regardless of whether it is a leader. The only difference is that if it's a leader, it will also serve chunks it has cached from other instances.
If an instance falls behind for any reason (say, a network outage), it can still request older data from peers. This is accomplished transparently by the use of catchup chunks, because they cover the entire history of the replication process.
A global catchup (i.e. restart from empty) could occur by doing a catchup with each peer in turn. It is desired to avoid triggering a global catchup process, except perhaps during the creation of a new instance, or the split of one instance into multiple instances. However, there can be times when a global catchup can't be avoided. It's a natural extension of the method of keeping historical data in catchup chunks, so its helpful to implement a facility for global catchup.
Catchup chunks are never totally discarded. At all times, every instance should contain a full history of chunks spanning from the beginning of time (i.e. the earliest modification in the base table), up until the present. This results in extra storage overhead, but is necessary to preserve the integrity of the environment 1110.
Transport Format
The distributed database system serializes the chunks being passed over the wire. The chunks are serialized into binary using any desired serialization library on the server, such as Apache™ Avro, and deserialized via the same serialization library into java objects on the client. The serialized version is smaller than a mere plain text version. Thus, the distributed database system saves both time and space.
Cache v. Recreate
Data can be served in two ways. One way is to use the parameters of the chunk (source instance ID, key prefix, partition number, and time/ID boundaries) to assemble a dynamic SELECT statement which pulls the rows directly from the underlying table and serializes them into binary form. This will always work on the source instance, and will work on leader instances as long as that chunk has first been upserted locally.
An alternative which may be more efficient in some cases is for instances to cache the serialized form of the chunk in a database BLOB field (in addition to upserting it). When the chunk is requested, instead of running a SELECT and serializing the results, the server can simply return the binary blob to the client.
The main difference between these methods, aside from performance, is that the former is susceptible to subsequent changes in the underlying table (i.e. if rows are deleted or updated with a later modstamp, they may no longer fall within the bounds defined by the chunk, and so they wouldn't be “seen” by the SELECT statement).
Within the latter cached version however, the set of changes is frozen and will be resent as-is. Both methods yield the correct result. The former may be slightly more efficient by virtue of removing redundant data, but the latter may be more efficient in reducing processing and contention on the underlying table.
Additionally, caching the serialized form of the chunk removes the need to store deletions in an entity such as replication_record_deletion.
It is not necessary to cache every chunk. Caching everything would amount to keeping an entire second copy of the replicated table on disk, which is inefficient. Even worse; over time, the same records can be updated many times, and caching all chunks permanently would result in many copies of the data, in a way that would grow but never shrink. For that reason, only non-catchup (active) chunks are eligible for caching.
Partitioning
Not all tables within the environment 1110 use a specific physical partitioning. Specifically, optimization commands related to partitions could potentially cause errors. Accordingly, the physical database commands used to get and modify data are slightly different for cases where the table is not partitioned.
Chunks and Immutability
Chunks aren't technically immutable, because for non-cached chunks, the underlying data can change, including changes that add or remove records to the tables covered by the chunk. However, chunks are “functionally immutable” because any version of a specific chunk is just as correct as any other version, from the point of view of the system's eventual state.
For example, imagine that an update to record A at time T2 is covered by Chunk 1, which has time boundaries from T1 to T3. Now suppose that data corresponding to record A is later updated again at time T4, and is covered again by a new chunk, Chunk 2. Performing a SELECT statement for the definition of Chunk 1, which says “WHERE source_system_modstamp>=T1 and source_system_modstamp<=T3” will no longer return this user. The chunk definition hasn't changed, but the set of users it covers has changed.
The opposite problem is less likely, but can still happen due to long-running transactions; User A wasn't originally covered by Chunk 1 because its timestamp was T0. However, at some point after the chunk is defined, a long-running transaction commits that changes the modstamp to T2, so the user is now covered. Clients that requested the chunk before this time would not receive the record, and clients that requested the chunk after this time would.
Fortunately, because of the chunk management described herein, there is no danger of “losing” any updates such as the unusual situation described above, even for long running transactions. This is because such a long-running transaction would eventually cause the creation of another overlapping chunk. Thus, even if other clients have already received the first version of the chunk that didn't have this record, they'll still get the newer version of the chunk that does.
There can be a small set of perverse conditions that could cause an indefinite delay in a record being propagated. For example, a record can be updated over and over again, where these updates always fall after the previous update was detected and packaged, but before it is served. As such, the record would be continually bumped to the next chunk, but no chunks would ever actually contain the record. This bumping is extremely unlikely, but could happen if records were updated by some automatic process that happened to have the same period as change detection and client processing.
One example solution to this problem could be to set the frequency of the change detection and client processes to slightly different values, for example, off by 1 second, so they naturally cycle over time. While it's still theoretically possible that an endless series of updates exactly falls between the detection and serving frequency, this step effectively lowers the probability to near zero.
Advantages of Chunks
Adding the abstraction of the chunks described herein yield a number of benefits. A chunk is a discrete unit of progress which makes reasoning about the state of the system easier. If something is missing, it is possible to trace exactly which chunk(s) were missed, rather than for example figuring out which records may or may not have been included, based on timestamps. This leads to simpler error detection and correction capabilities.
Additionally, a chunk can be either cached or recalculated, depending on which is more efficient. A chunk allows transport logic (requesting, handling, etc.) to be mostly ignorant of what data is contained within the chunk, so the environment 1110 can easily add new replicated entities in the future, and make global optimizations and changes without copying code.
One of the most important benefits of the architecture of the embodiments herein is scalability. Scalability refers to how the environment 1110 behaves as the number of instances grow. Because chunks are specific to a single instance, there's absolutely no overlap between chunks from difference instances. Thus, the use of chunks reduces the raw byte traffic compared to a more naïve approach. The process of replication is still complex and consumes a significant amount of overhead, because each instance needs to fetch and upsert data for every other instance. But, under normal circumstances, the system only needs to obtain that data a single time. Redundancy is reduced.
Referential Integrity
Because each table in this replicated system functions independently of the others, it's not possible to have direct (database-enforced) referential integrity constraints between replicated tables, such as Foreign Keys. This is because the child table in such a relationship could potentially have rows replicated that reference related rows in the parent table, before the corresponding rows in the parent table are replicated. While one could achieve a semblance of integrity by creating ordering constraints on the replication itself (for example, stating that parent table P is replicated before child table C during each iteration of the client process), there are still possible conditions where this would break down. For example, if related rows were simultaneously inserted in P and C at a point between when the replication client ran for P and for C, the rows of C would be included before their referent rows in P.
This “breaking” of referential integrity is a temporary condition, because presumably the rows in the parent table would be replicated in the next iteration of the client process. As such, it is an “eventually consistent” process globally (though, within an entity it is strictly consistent).
Using “Fudge Factor” in Timing of Chunk Requests
In one implementation, certain conditions about the overall state of the system are assumed, by using “up to” dates. The assumption is that there are no gaps in the list of chunks known to exist. These assumptions can be summarized as follows.
However, there are some exceptions to these cases. In the embodiments disclosed herein, an example time granularity for requesting chunks is one second. Consequently, multiple chunks could be created within the same second. An instance could ask for these chunks in between their creation, and only get some of them, such as if one chunk is created at 0 milliseconds, while another chunk is created at 999 milliseconds, but a chunk request occurs at 500 milliseconds.
If for some reason a chunk were to be slow to commit, its timestamp may be an earlier time than was actually available. This is the same as the long running transaction problem for the underlying records that was discussed earlier. This is extremely unlikely for chunks, since chunks are generally created and committed in a short atomic block, but it's theoretically possible. One perverse scenario would be that after the stored procedure to insert the chunk has run, but before the request completes and “commit” is called on the database connection, the server enters a long garbage collection pause. This would be extremely unlucky timing, but in large distributed systems with millions of transactions, this kind of event is not impossible.
To account for these problems, an example client process uses a configurable “fudge factor” on its requests. If the client process thinks it needs chunks more recent than T2, the client process will actually send the request for chunks more recent than (T2−f), where f is some number of seconds. The price of a longer fudge time is receiving a list containing one or more redundant chunks. This is acceptable, because it will be apparent that these redundant chunks were already upserted and thus can be ignored. Remember also that this fudge factor is just for the LIST operation, which returns chunk definitions (metadata) but no underlying data, so it's just comparing chunk IDs which consumes only minimal overhead. No underlying data is sent over the wire.
Other factors could also cause data to not be replicated. For example, it is possible to encounter an exception and not actually insert a chunk obtained from a LIST operation. However, an example client process has a configurable setting that allows it to either continue after a failure and attempt to fetch and upsert the remaining chunks it needs, or to grind to a halt and stop processing altogether. Not surprisingly, continuing after failure is more robust and complete, and will avoid endangering other data's replication. Halting on failure is more globally correct, because if a chunk is missed, the entire distributed database system is compromised. For transient problems, continuing after failure is more desirable because a chunk can be retried later.
In a LIST command, the result obtained is a list of chunks with their IDs and metadata, but no underlying data (e.g. no replicated records from the underlying tables). These chunks are immutable, so if the chunk already exists, it isn't updated, it's simply ignored.
Replication and Change Detection
Another problem with detecting and replicating changes in a distributed database system is that transactions can be uncommitted for any length of time, and when they finally are committed, there may be no way to mark the commit time. For replication, this means that if a transaction is uncommitted while the replication query runs, then its changes won't be seen by the replication query.
In
To resolve this problem, it is possible to use reachback logic, that is, extending the query to cover the same span of time again; for example, extending the reach of the query by 30 minutes, once every 15 minutes. This method still has frequent failures, which become more evident the longer that accessing code holds a transaction open before committing. Without precautions, this would result in records not getting replicated. This approach also has even more severe problems in a multi-hop leader environment.
Consequently, the environment 1110 offers a complex replication mechanism involving multiple queue tables and worker threads that are notified when transactions commit by watching those queue tables. This replication mechanism reads the set of potentially changed records, finds their start and end points, and then writes a new chunk to cover these changes.
Because transactions can commit in an order that doesn't correspond to the recorded timestamps, the resulting set of chunks may overlap each other. This is not optimal, but nonetheless is guaranteed to be complete and correct.
In
There are actually two timelines in
Afterwards, two things happen: a 7th change is made, and roughly at the same time, the change 908 is committed to the database. At that point, the subsequent indexer run (indicated by the 4th black rectangle on the “Indexer Runs” line) would encompass those two changes and produce a chunk that spans between them, as shown by chunk G.
Thus, there exists both the modification timeline and also the change timeline. The commit timeline dictates what appears to the indexer, and the indexer dictates the duration of time of chunks that are generated. Overlap in time can occur, as shown by Chunk F and Chunk G.
One purpose of the arrangement of
Another issue handled by the environment disclosed herein is the case of single modstamps. A modstamp is similar to but not the same as a timestamp. A modstamp is a timestamp of a modification. When changes are packaged into chunks, it is desired to limit to the number of rows that will be covered by a chunk (for example, to 5000 records). Since the chunk is bounded by timestamps, a problem exists if more than 5000 records share the exact same timestamp. An example of this is shown in
In Case 1, the covered set of records is smaller than the row size limit, so that it is likely the resulting chunk covers every modification up to and including the end date of the query. Subsequent chunks can begin strictly after this date, using for example a query stating (“WHERE timestamp>T3”).
In Case 2, if a set of 5000+ records containing multiple timestamps arrives, its not possible to know whether the last timestamp in the set has been exhausted yet. There could be more records with time T3 that haven't been seen. So, rather than issuing the next query with a begin date of ““WHERE timestamp>T3”, it is necessary to use ““WHERE timestamp>T2”, and keep T3 in the set. This could result in getting duplicates of some records already seen, but is a minor inefficiency.
The most significant potential problem is shown in Case 3, wherein every record in a full batch (e.g. ≧5000 records) has the same modstamp. For example, issuing a query “WHERE timestamp>T2” will never make progress, because it will always pull the same 5000 records with timestamp T3. To get around this, the environment 1110 detects this “single modstamp” condition and adds an additional criteria to the chunk metadata definitions, as shown in
The absence of entity ID boundaries in the chunk means that it is simply time-bounded, and that the two timestamps (start and end) represent a range containing a discrete set of modified records.
Within normal operation of the environment 1110, the expectation (not guaranteed) is that the set of records represented contains more than one timestamp, and the count of contained records is less than or equal to a “max records per chunk” threshold. However, this can't be guaranteed, because for example of a potential long-running transaction problem. In such a case, a large series of updates with the same timestamp could always appear in the table in a place that's already covered by another non-single-modstamp chunk. This is an unlikely situation, but the environment 1110 thus includes an extra check (and repair mechanism) for this possibility.
It is possible that after a chunk is created, a later in-process transaction with a large number of rows may commit and thus escalate the chunk to being above the size limit. The chunk would either be served in its too-large state (which is not ideal but will work), or the chunk could be adjusted manually by updating the bounding conditions of the chunk. Regarding updating corrupted or invalid chunks, or even valid chunks, the embodiments disclosed herein include an automated software process that discovers problems with chunks and repairs them. One example solution is to delete the offending chunks, and re-enqeue the entire region for re-indexing.
Appendix: Selected Flags and Default Parameters
The following are examples of flags and parameters that can be set by a user or a developer.
ShouldContinueAfterFailure (default: true)
If set to “true”, failures that happen during the client replication process won't halt the process, but will write to the log and attempt to continue (with the next chunk, or server, as appropriate). Setting this flag to “true” makes the system more robust and resilient to problems, at the expense of potentially missing data if nobody is watching the log. Ultimately, it should be set to “false” in production and all known errors should be handled correctly.
ShouldLeadersCacheLocalChunks (default: true)
If set to “true”, instances that believe themselves to be the current leader will cache all chunks they produce locally. This should generally be true, because all local instances, plus all leaders in other data centers, will ask the leaders for their chunks independently, so serving from cache will be more efficient.
ShouldNonLeadersCacheLocalChunks (default: true)
If set to “true”, instances that do not believe themselves to be the current leader will cache all chunks they produce locally. This should be true if local instances go directly to each other (as opposed to the local leader) for chunks, and the number of local instances is greater than 2. Otherwise, this may be wasted effort (if everyone asks the leader, even for local chunks, or if it's just the leader and one other instance). Such erroneous assumptions by an instance (either leader or not) are a tolerable side-effect of the continual designation and re-designation of new leaders. The embodiments described herein includes safeguards to manage the occasional erroneous assumption.
ShouldLeadersCacheAllChunks (default: true)
If set to “true”, instances that believe themselves to be the current leader will cache all chunks, both those produced locally and those retrieved remotely. This should generally be true, because all local instances, plus all leaders in other data centers, will ask the leaders for all chunks, so serving from cache will be more efficient.
ShouldLookForLostChunks (default: false)
If set to “true”, each iteration of the client will attempt to fetch and upsert not only the most recent chunks returned by the LIST command in this iteration, but also any prior active chunks that have yet to be upserted (for example due to a “server unavailable” error).
MaxRowsPerBatch: 3000
Default batch size, controlling how many records will be allowed in a single chunk. This also impacts single modstamp issues.
This application claims the benefit of U.S. Provisional Patent Application 61/474,157 entitled “Replication in a Multi-Tenant Database System” by Ian Varley et al., filed Apr. 11, 2011, the entire contents of which are incorporated herein by reference.
| Number | Name | Date | Kind |
|---|---|---|---|
| 5577188 | Zhu | Nov 1996 | A |
| 5608872 | Schwartz et al. | Mar 1997 | A |
| 5649104 | Carleton et al. | Jul 1997 | A |
| 5715450 | Ambrose et al. | Feb 1998 | A |
| 5761419 | Schwartz et al. | Jun 1998 | A |
| 5819038 | Carleton et al. | Oct 1998 | A |
| 5821937 | Tonelli et al. | Oct 1998 | A |
| 5831610 | Tonelli et al. | Nov 1998 | A |
| 5873096 | Lim et al. | Feb 1999 | A |
| 5918159 | Fomukong et al. | Jun 1999 | A |
| 5963953 | Cram et al. | Oct 1999 | A |
| 6092083 | Brodersen et al. | Jul 2000 | A |
| 6169534 | Raffel et al. | Jan 2001 | B1 |
| 6178425 | Brodersen et al. | Jan 2001 | B1 |
| 6189011 | Lim et al. | Feb 2001 | B1 |
| 6216135 | Brodersen et al. | Apr 2001 | B1 |
| 6233617 | Rothwein et al. | May 2001 | B1 |
| 6266669 | Brodersen et al. | Jul 2001 | B1 |
| 6295530 | Ritchie et al. | Sep 2001 | B1 |
| 6324568 | Diec | Nov 2001 | B1 |
| 6324693 | Brodersen et al. | Nov 2001 | B1 |
| 6336137 | Lee et al. | Jan 2002 | B1 |
| D454139 | Feldcamp | Mar 2002 | S |
| 6367077 | Brodersen et al. | Apr 2002 | B1 |
| 6393605 | Loomans | May 2002 | B1 |
| 6405220 | Brodersen et al. | Jun 2002 | B1 |
| 6434550 | Warner et al. | Aug 2002 | B1 |
| 6446089 | Brodersen et al. | Sep 2002 | B1 |
| 6532479 | Souder et al. | Mar 2003 | B2 |
| 6535909 | Rust | Mar 2003 | B1 |
| 6549908 | Loomans | Apr 2003 | B1 |
| 6553563 | Ambrose et al. | Apr 2003 | B2 |
| 6560461 | Fomukong et al. | May 2003 | B1 |
| 6574635 | Stauber et al. | Jun 2003 | B2 |
| 6577726 | Huang et al. | Jun 2003 | B1 |
| 6601087 | Zhu et al. | Jul 2003 | B1 |
| 6604117 | Lim et al. | Aug 2003 | B2 |
| 6604128 | Diec | Aug 2003 | B2 |
| 6609150 | Lee et al. | Aug 2003 | B2 |
| 6621834 | Scherpbier et al. | Sep 2003 | B1 |
| 6654032 | Zhu et al. | Nov 2003 | B1 |
| 6665648 | Brodersen et al. | Dec 2003 | B2 |
| 6665655 | Warner et al. | Dec 2003 | B1 |
| 6684438 | Brodersen et al. | Feb 2004 | B2 |
| 6711565 | Subramaniam et al. | Mar 2004 | B1 |
| 6724399 | Katchour et al. | Apr 2004 | B1 |
| 6728702 | Subramaniam et al. | Apr 2004 | B1 |
| 6728960 | Loomans | Apr 2004 | B1 |
| 6732095 | Warshavsky et al. | May 2004 | B1 |
| 6732100 | Brodersen et al. | May 2004 | B1 |
| 6732111 | Brodersen et al. | May 2004 | B2 |
| 6754681 | Brodersen et al. | Jun 2004 | B2 |
| 6763351 | Subramaniam et al. | Jul 2004 | B1 |
| 6763501 | Zhu et al. | Jul 2004 | B1 |
| 6768904 | Kim | Jul 2004 | B2 |
| 6782383 | Subramaniam et al. | Aug 2004 | B2 |
| 6804330 | Jones et al. | Oct 2004 | B1 |
| 6826565 | Ritchie et al. | Nov 2004 | B2 |
| 6826582 | Chatterjee et al. | Nov 2004 | B1 |
| 6826745 | Coker et al. | Nov 2004 | B2 |
| 6829655 | Huang et al. | Dec 2004 | B1 |
| 6842748 | Warner et al. | Jan 2005 | B1 |
| 6847971 | Balaraman et al. | Jan 2005 | B1 |
| 6850895 | Brodersen et al. | Feb 2005 | B2 |
| 6850949 | Warner et al. | Feb 2005 | B2 |
| 7340411 | Cook | Mar 2008 | B2 |
| 7620655 | Larsson et al. | Nov 2009 | B2 |
| 8214329 | Gilder et al. | Jul 2012 | B2 |
| 8365185 | Bobak et al. | Jan 2013 | B2 |
| 20010044791 | Richter et al. | Nov 2001 | A1 |
| 20020022986 | Coker et al. | Feb 2002 | A1 |
| 20020029161 | Brodersen et al. | Mar 2002 | A1 |
| 20020029376 | Ambrose et al. | Mar 2002 | A1 |
| 20020035577 | Brodersen et al. | Mar 2002 | A1 |
| 20020042264 | Kim | Apr 2002 | A1 |
| 20020042843 | Diec | Apr 2002 | A1 |
| 20020072951 | Lee et al. | Jun 2002 | A1 |
| 20020082892 | Raffel et al. | Jun 2002 | A1 |
| 20020095399 | Devine et al. | Jul 2002 | A1 |
| 20020129352 | Brodersen et al. | Sep 2002 | A1 |
| 20020140731 | Subramaniam et al. | Oct 2002 | A1 |
| 20020143997 | Huang et al. | Oct 2002 | A1 |
| 20020152102 | Brodersen et al. | Oct 2002 | A1 |
| 20020161734 | Stauber et al. | Oct 2002 | A1 |
| 20020162090 | Parnell et al. | Oct 2002 | A1 |
| 20020165742 | Robins | Nov 2002 | A1 |
| 20030004971 | Gong et al. | Jan 2003 | A1 |
| 20030009431 | Souder et al. | Jan 2003 | A1 |
| 20030018705 | Chen et al. | Jan 2003 | A1 |
| 20030018830 | Chen et al. | Jan 2003 | A1 |
| 20030066031 | Laane | Apr 2003 | A1 |
| 20030066032 | Ramachandran et al. | Apr 2003 | A1 |
| 20030069936 | Warner et al. | Apr 2003 | A1 |
| 20030070000 | Coker et al. | Apr 2003 | A1 |
| 20030070004 | Mukundan et al. | Apr 2003 | A1 |
| 20030070005 | Mukundan et al. | Apr 2003 | A1 |
| 20030074418 | Coker | Apr 2003 | A1 |
| 20030088545 | Subramaniam et al. | May 2003 | A1 |
| 20030101258 | Parham | May 2003 | A1 |
| 20030120675 | Stauber et al. | Jun 2003 | A1 |
| 20030151633 | George et al. | Aug 2003 | A1 |
| 20030159136 | Huang et al. | Aug 2003 | A1 |
| 20030187921 | Diec | Oct 2003 | A1 |
| 20030189600 | Gune et al. | Oct 2003 | A1 |
| 20030191743 | Brodersen et al. | Oct 2003 | A1 |
| 20030204427 | Gune et al. | Oct 2003 | A1 |
| 20030206192 | Chen et al. | Nov 2003 | A1 |
| 20030225730 | Warner et al. | Dec 2003 | A1 |
| 20040001092 | Rothwein et al. | Jan 2004 | A1 |
| 20040010489 | Rio | Jan 2004 | A1 |
| 20040015981 | Coker et al. | Jan 2004 | A1 |
| 20040027388 | Berg et al. | Feb 2004 | A1 |
| 20040128001 | Levin et al. | Jul 2004 | A1 |
| 20040186860 | Lee et al. | Sep 2004 | A1 |
| 20040193510 | Catahan, Jr. et al. | Sep 2004 | A1 |
| 20040199489 | Barnes-Leon et al. | Oct 2004 | A1 |
| 20040199519 | Gu et al. | Oct 2004 | A1 |
| 20040199536 | Barnes Leon et al. | Oct 2004 | A1 |
| 20040199543 | Braud et al. | Oct 2004 | A1 |
| 20040221030 | Huras et al. | Nov 2004 | A1 |
| 20040243591 | Gu et al. | Dec 2004 | A1 |
| 20040249854 | Barnes-Leon et al. | Dec 2004 | A1 |
| 20040255023 | Motoyama et al. | Dec 2004 | A1 |
| 20040260534 | Pak et al. | Dec 2004 | A1 |
| 20040260659 | Chan et al. | Dec 2004 | A1 |
| 20040268299 | Lei et al. | Dec 2004 | A1 |
| 20050050555 | Exley et al. | Mar 2005 | A1 |
| 20050080765 | Dettinger et al. | Apr 2005 | A1 |
| 20050091098 | Brodersen et al. | Apr 2005 | A1 |
| 20050193024 | Beyer et al. | Sep 2005 | A1 |
| 20060047713 | Gornshtein et al. | Mar 2006 | A1 |
| 20060190497 | Inturi et al. | Aug 2006 | A1 |
| 20060200533 | Holenstein et al. | Sep 2006 | A1 |
| 20060212465 | Fish et al. | Sep 2006 | A1 |
| 20060224479 | Bishop et al. | Oct 2006 | A1 |
| 20070174815 | Chrysanthakopoulos et al. | Jul 2007 | A1 |
| 20070288526 | Mankad et al. | Dec 2007 | A1 |
| 20070294319 | Mankad et al. | Dec 2007 | A1 |
| 20080144601 | Nurminen et al. | Jun 2008 | A1 |
| 20080281846 | Hoang et al. | Nov 2008 | A1 |
| 20080320019 | Bireley et al. | Dec 2008 | A1 |
| 20090164496 | Carnathan et al. | Jun 2009 | A1 |
| 20090171707 | Bobak et al. | Jul 2009 | A1 |
| 20090177710 | Holenstein et al. | Jul 2009 | A1 |
| 20100179940 | Gilder et al. | Jul 2010 | A1 |
| 20110071980 | Patterson | Mar 2011 | A1 |
| 20110153568 | Shang et al. | Jun 2011 | A1 |
| 20110225482 | Chan et al. | Sep 2011 | A1 |
| 20110289508 | Fell et al. | Nov 2011 | A1 |
| Number | Date | Country | |
|---|---|---|---|
| 20120259894 A1 | Oct 2012 | US |
| Number | Date | Country | |
|---|---|---|---|
| 61474157 | Apr 2011 | US |
