Dynamic synchronization of tables

• US 20030172054A1
• Filed: 03/04/2003
• Published: 09/11/2003
• Est. Priority Date: 06/29/1999
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Berkowitz, Brian T., Christofferson, Peter A.
• Granted Patent: US 7,363,332 B2
• Time in Patent Office: Days
• US Class Current: 707/1
• CPC Class Codes: G06F 16/273 Asynchronous replication or reconciliation
• CPC Class Codes: Y10S 707/99931 Database or file accessing
• CPC Class Codes: Y10S 707/99936 Pattern matching access
• CPC Class Codes: Y10S 707/99952 Coherency, e.g. same view to multiple users
• CPC Class Codes: Y10S 707/99953 Recoverability
• CPC Class Codes: Y10S 707/99955 Archiving or backup

Abstract

Each node in a network accessing a common database caches a copy of the database tables it uses and updates those tables based on changes made by other nodes in a coherent cache, i.e., those node that also have a copy of the tables in their cache. When a new node joins the coherent cache, dynamic synchronization of the table is performed by having one of the existing nodes act as a source to populate the table(s) required on the new (destination) node from its own copy. The dynamic synchronization controls the population operation and allows for the populating of tables on the destination node from partially populated tables on the source node. The dynamic synchronization of the tables permits database updates to continue to be made to the tables by the existing nodes in the coherent cache and provides a mechanism to propagate the committed updates to the tables on the destination node. Once the tables on the destination node are fully populated, all pending updates are suspended while a snapshot of the state of the table on the source node is taken. Once the destination node has processed the snapshot, active transactions on the source node are initiated on the destination node, and all transactions are allowed to modify the table on the destination node.

Claims

1. A method of dynamically synchronizing a table from a source node to a destination node comprising:

streaming, to the destination node, static data in the table on the source node;

streaming, to the destination node, committed changes to the table on the source node interspersed with the static data;

creating, on the destination node, a copy of the table from the static data and the committed changes;

pausing, on the source node, active transactions that involve the table;

streaming, to the destination node, uncommitted changes associated with the active transactions on the source node;

resuming, on the source node, each active transaction when the associated uncommitted changes have been sent to the destination node; and

initiating, on the destination node, remote transactions that correspond to a set of transactions active on the source node.

2. The method of claim 1, further comprising:

streaming, to the destination node, any committed changes resulting from the resumption of each transaction on the source node interspersed with the uncommitted changes for the active transactions; and

applying, to the copy of the table on the destination node, any committed changes resulting from the resumption of each transaction.

3. The method of claim 1, wherein remote transactions are initiated on the destination node in response to a message from the source node that all changes for the active transactions have been sent.

4. The method of claim 1, further comprising:

sending, to the destination node, an identity for any active transaction on the source node that terminates before the corresponding transaction is initiated on the destination node; and

aborting, on the destination node, all changes identified as associated with the terminated transaction.

5. The method of claim 1, wherein the static data in the table comprises metadata and table records.

6. The method of claim 1, wherein streaming the static data in the table comprises populating the table on the source node from a backend.

7. The method of claim 1, wherein streaming the static data in the table comprises synchronizing the table on the source node from a third node.

8. The method of claim 1, wherein the uncommitted changes form a snapshot of the table.

9. The method of claim 1, wherein the committed changes are evaluated based on a comparison of a key value in each committed change with a key value of a last record sent to the destination node.

10. The method of claim 1, wherein the acts are performed in the order recited.

12. The computer-readable medium of claim 10, further comprising determining when a change is committed to the table while transmitting the static data;

and

transmitting the committed change in the synchronization stream.

13. The computer-readable medium of claim 10, wherein obtaining the static data comprising:

synchronizing the table data from a backend.

14. The computer-readable of claim 10, wherein obtaining the static data comprising:

synchronizing the table data from another node.

11. A computer-readable medium having computer-executable instructions to a cause a source computer on a network to perform a method providing a synchronization stream comprising:

obtaining static data from a table in key order;

transmitting the static data in the synchronization stream;

identifying changes to the table that are uncommitted after transmitting the static data;

transmitting the uncommitted changes in the synchronization stream;

determining when an uncommitted change commits after transmitting the uncommitted change in the synchronization stream;

transmitting information regarding the commit of the uncommitted change on the network; and

transmitting an message to initiate active transactions.

15. A computer-readable medium having computer-executable instructions to a cause a destination computer on a network to perform a method of applying data received in a synchronization stream to a table comprising:

receiving static table data in the synchronization stream;

creating the table from the static data;

receiving uncommitted changes in the synchronization stream;

queuing the uncommitted changes;

receiving information on the network regarding an uncommitted change in the queue that commits;

deleting the uncommitted change that committed from the queue;

receiving an message to initiate active transactions;

identifying active transactions; and

initiating the identified active transactions.

16. The computer-readable medium of claim 15, further comprising:

receiving a committed change in the synchronization stream while receiving the static data;

applying the committed change to the table.

17. A computer-readable medium having stored thereon a node table data structure comprising:

a first field containing data representing a table identifier; and

a second field containing data representing a coherent table object for the table identified by the data in the first field.

18. A computer-readable medium having stored thereon a node arbitration object data structure comprising:

a first field containing data representing an arbitration object identifier; and

a second field containing data representing a resource identifier for an object being arbitrated by the arbitration object identified in the first field.

19. A computer-readable medium having stored thereon a coherent databases data structure comprising:

a first field containing data representing a data source name for a database; and

a second field containing data representing a database identifier for the database identified by the data in the first field.

20. The computer-readable medium of claim 19, further comprising:

a third field containing data representing a subidentifier that is the highest allocated identifier for a table in the database identified by the second field.

21. A computer-readable medium having stored thereon a coherent table data structure comprising:

a first field containing data representing a database identifier;

a second field containing data representing a table name in the database identified by the first field;

a third field containing a table subidentifier for the table identified by the second field.

22. The computer-readable medium of claim 21, further comprising a fourth field containing data representing an owner name for the table identified by the second field, and wherein the table in the database is further identified by the data in the fourth field.

23. A computer-readable medium having stored thereon a data stream for synchronizing a table comprising:

static data for the table;

a first end-of-stream message;

snapshot data for the table;

an end-of-snapshot message; and

a second end-of stream message.

24. The computer-readable medium of claim 23, wherein the static data comprises:

metadata for the table; and

record data for the table.

25. The computer-readable medium of claim 23, further comprising:

committed changes to the table interspersed with the static data.

26. The computer-readable medium of claim 23, wherein the snapshot data comprises:

uncommitted changes to the table.

27. The computer-readable medium of claim 26, wherein the snapshot data comprises:

committed changes interspersed with the uncommitted changes.

28. A computer-readable medium having stored thereon a control stream for synchronizing a table comprising:

an end-of-snapshot-response message;

an initialize-remote-transaction message; and

an initialize-remote-transaction-response message.

29. The computer-readable medium of claim 28, further comprising:

an end-of-snapshot-transaction message.

30. The computer-readable medium of claim 29, wherein the end-of-snapshot-transaction message comprises:

an identifier for a terminated transaction;

31. The computer-readable medium of claim 28, further comprising:

an end-of-synchronization message; and

an end-of-synchronization-response message.

32. A network comprising:

a source node computer comprising;

a processing unit coupled to the network through a system bus;

a system memory coupled to the processing unit through a system bus, wherein a table shared among computers on the network is cached in the system memory;

a computer-readable medium coupled to the processing unit through a system bus; and

a synchronization source process executed from the computer-readable medium of the source by the processing unit of the source node, wherein the synchronization source process causes the processing unit of the source node to create an synchronization stream from data for the shared table and to transmit the synchronization stream on the network; and

a destination node computer comprising;

a processing unit coupled to the network through a system bus;

a system memory coupled to the processing unit through a system bus;

a computer-readable medium coupled to the processing unit through a system bus; and

a synchronization destination process executed from the computer-readable medium of the destination node by the processing unit of the destination node, wherein the synchronization destination process causes the processing unit of the destination node to receive then synchronization stream from the network and to create the shared table in the system memory.

33. The network of claim 32, wherein the synchronization source process further causes the processing unit of the source node to place a first message on the network, and the synchronization destination process further causes the processing unit of the destination node to initiate a process associated with the first message and to respond to the first message when the process is complete.

34. The network of claim 33, wherein the synchronization source process further causes the processing unit of the destination node to place a second message on the network in response to receiving the response to the first message from the destination node.

35. The network of claim 33, wherein the synchronization stream is transmitted on a dedicated channel and the messages sent between the synchronization source and destination are transmitted on a normal messaging channel.