A multi-user, elastic, on-demand, distributed relational database management system. The database is fragmented into distributed objects called atoms. Any change to a copy of an atom at one location is replicated to all other locations containing a copy of that atom. transactional managers operate to satisfy the properties of atomicity, consistency, isolation and durability.
|
1. A database management system for a logical database comprised of data records organized into tables that is to be accessed from multiple transactional nodes that process transactions related to the logical data base, said system comprising:
A) means for parsing the database into a plurality of fragments wherein each fragment corresponds to a different metadata and/or data element pertaining to the logical data base and collectively the fragments define all the metadata and data in the database management system,
B) means for transferring a copy of a fragment within the database management system as a serialized message and for storing a copy of a fragment as a de-serialized message,
C) at least one archival node that stores a copy of all the fragments in a de-serialized form in persistent storage thereby to constitute a single store for the metadata and data for the entire data-base, and
D) each transactional node comprises:
i) means for responding to queries from users connected to said transactional node by establishing a sequence of low-level commands for identifying fragments that are relevant to the query,
ii) means for responding to the low-level commands by obtaining copies of only those fragments that are relevant to the query being processed thereat whereby a copy of a given fragment is stored at an archival node and other copies of that fragment might exist at another transactional node, and
iii) means for replicating any change to a copy of a fragment in the at least one archival node and in each transactional node in which a copy of that fragment resides whereby changes in response to a query made to a fragment at one transactional node are replicated in other nodes with a copy of that fragment on a peer-to-peer basis and whereby any transactional node only contains copies of those fragments that pertain to the queries being made for users accessing the data base through that transactional node.
2. A database management system as recited in
3. A database management system as recited in
4. A database management system as recited in
i) a table fragment for each table that contains a list of fields,
ii) a schema fragment that establishes a correspondence between a schema and the named tables relevant to that schema, and
iii) a database fragment that establishes a correspondence between the database and the named schema.
5. A database management system as recited in
6. A database management system as recited in
7. A database management system as recited in
8. A database management system as recited in
9. A database management system as recited in
i) messaging means for generating and receiving predefined messages in response to system level commands, and
ii) means for selecting one of the communications paths for transmitting the message.
10. A database management system as recited in
11. A database management system as recited in
12. A database management system as recited in
13. A database management system as recited in
14. A database management system as recited in
i) means for establishing a connection between the joining node and a selected one of the active nodes,
ii) means in the joining node for asking the selected node for connection,
iii) means in the selected node for updating its master catalog fragment to indicate the joining node as an active node,
iv) means in the selected node for transferring a message to the joining node including the selected node's identification and for broadcasting a message indicating the availability of the joining node to all other nodes in the system and persistent storage,
v) means in said joining node for responding to the message by requesting a copy of the master catalog fragment from the selected node, and
vi) means in the selected node for transferring its updated master catalog fragment to the joining node.
15. A database management system as recited in
16. A database management system as recited in
17. A database management system as recited in
i) means in said catalog fragment that will track the new fragment responsive to the interface request for causing the catalog fragment to create that new fragment with no content and to designate the new fragment as a chairman for that fragment,
ii) means in the catalog fragment that assigns an object identification to the new fragment,
iii) means in the catalog fragment for establishing a status for the new fragment that indicates there is no redundant copy of the new fragment and that the new fragment is not available to other nodes,
iv) means in the catalog fragment for broadcasting to all other corresponding catalog fragments in the system the existence of the new fragment,
v) means for populating the new fragment and for making the new fragment available on the system.
18. A database management system as recited in
19. A database management system as recited in
i) means in the requesting catalog fragment responsive to the interface request that will track the requested fragment responsive to the interface request for creating that empty fragment,
ii) means in the requesting catalog fragment for establishing selecting the most responsive node and requesting a copy of the fragment from the most responsive node,
iii) means in the selected node for sending a copy of the requested fragment in an object message to the requesting node and for broadcasting the availability of the fragment to other nodes in which the fragment,
iv) means for assessing the validity of the received object message, for populating the empty fragment and for forwarding an object acknowledgment message to the selected node.
20. A database management system as recited in
21. A database management system as recited in
|
1. Field of the Invention
This invention generally relates to database management systems. More specifically this invention relates a method and apparatus for implementing a multi-user, elastic, on-demand, distributed relational database management system characterized atomicity, performance and scalability.
2. Description of Related Art
Over the past years the use of databases for storing and retrieving messages has emerged as an important tool in a wide variety of commercial applications. Initially, many database systems operated on a single server installation with multiple users. However, various factors have developed over the past years that have required the basic nature of database architecture to change. As a first factor, database storage requirements have become extremely large. Second, the number of users trying to access such databases has also become large. Third, the use of databases to retrieve relatively stable data with minimal updates has been replaced by transactional processing.
A transaction is a unit of work must be completed in its entirety. A single transaction may include multiple data manipulations. As an example a single transaction may include a reading operation followed by a write operation. In recent years significant effort has been directed to enabling relational databases to support ever increasing rates of transaction processing.
Databases are now judged by a standard that defines ACID properties, namely: atomicity, consistency, isolation and durability. Atomicity guarantees that all transaction tasks will be completed in their entireties. Consistency assures is that only valid data is written to the database. Isolation assures that other operations cannot access or “see” data in an intermediate state during a transaction. Durability assures that once a transaction has been processed successfully, it cannot be undone.
Consistency is particularly important in multi-user systems where it is possible for two or more users to seek concurrent access to shared volatile data. Early multi-user systems used locking operations to assure consistency. Locks could be exclusive, or write, locks, or non-exclusive, or read, locks and could be applied to individual records or to pages. However, as databases have grown in size and as transaction rates have increased, the overhead for managing locks has become significant and, in some cases, prohibitive.
Multi-version concurrency control (MVCC) is an alternative process for assuring concurrency. MVCC can be more effective than locks with complex databases. MVCC uses timestamps or increasing transaction identifications (IDs) to serialize different versions of a record. Each version permits a transaction to read the most recent version of an object which precedes the timestamp or ID. With this control method, any change to a record, for example, will not be seen by other users until the change is committed. MVCC also eliminates locks with other attendant overhead and establishes a system in which read operations can not block write operations.
In addition to meeting the ACID tests, there now is a requirement for continuous availability to users. Some database systems dedicate one computer system to transaction processing and another to decision support and other reporting processes. They are interconnected so that other functions can be supported simultaneously. As databases grow in size and complexity, existing data processing systems are replaced by more powerful data processing system. Another approach for accommodating growth involves replicated systems where one machine is designated as a “head” machine that keeps all the replicated machines in synchronism. If a head machine were to fail, a process would assign that function to another replicated machine. Different replicated machines are available to certain users. This approach is not scalable because all the machines have to have the same capability.
As another approach, multiple autonomous database systems can be integrated into a single “federated” database with a computer network interconnecting the various individual databases. Federated databases require “middleware” to maintain the constituent databases in synchronism. This “middleware” can become very complex. As the database size increases, the resources required for operating the middleware may impose such a sufficiently great overhead that overall system performance degrades.
“Partitioning” is another approach for implementing databases in which a logical database or its constituent elements are divided into distinct independent parts. In a distributed database management system, each partition may be spread over multiple nodes. Users at given node can perform local transactions on the partition. Partitioning also can be implemented by forming smaller databases or by splitting selected elements of just one table.
There are two general approaches to partitioning. In horizontal partitioning, also called “sharding”, different rows are placed in different tables and different servers. Generally they have a certain commonality such as a range of zip codes or last names which are divided into different tables by ranges. For example a first database might contain all the records for last names in the range A through M; a second database, in the range N through Z. Sharding, which is a form of horizontal partitioning, involves locating rows of a database on separate servers. Sharding does reduce the number of rows in each table and increases search performance. However, sharding uses a hash code at an application level that makes it much more difficult to implement. It also incorporates a two-phase commit. The complexities of sharding make it suitable for particular applications as the basis for defining the shards is quite well defined.
Vertical partitioning involves the creation of tables with fewer columns and splitting columns across tables. Like a federated database, vertical partitioning requires middleware to determine how to route any request for a particular field to an appropriate partition. In addition these systems operate using a two-phase commit sequence which is complicated to implement.
In still another approach, known as a “shared-nothing” architecture, each node is independent and self-sufficient. Shared-nothing architecture is popular for web development because it can be scaled upward simply by adding nodes in the form of inexpensive computers. This approach is popular in data warehousing applications where updates tend to be less frequent than would occur with transaction processing. However, the processing of joins is very complex over large data sets from different partitions or machines.
Some database systems are referred to as “distributed” systems. One implementation of a distributed system incorporates “clusters” and two communications paths. A high-speed Internet path carries data among the clusters. High-speed dedicated communications paths are required for various control functions, such as lock management. While this approach solves the redundancy and availability issues for databases, lock management, as previously discussed, can limit system performance.
In a “shared everything” system, super high-speed communications keep the system in synchronism. However lock management can require significant bandwidth resources. To avoid this, such systems incorporate point-to-point communications channels and a very sophisticated disk controller.
Collectively, those prior art systems satisfy some but not all of the known requirements for a database system. What is needed is a database architecture that is scalable, that meets the ACID properties of atomicity, consistency, isolation and durability. What is also needed is a database system that operates over the Internet without the need for dedicated high-speed communications paths, that provides transaction processing and that is operable over a wide geographic area.
Therefore, it is an object of this invention to provide an elastic, scalable, on-demand, distributed data processing system.
Another object of this invention is to provide an elastic, scalable, on-demand, distributed data processing system that is fault tolerant.
Still another object of this invention is to provide an elastic, scalable, on-demand, distributed data processing system that has a high degree of availability.
Yet another object of this invention is to provide an elastic, scalable, on-demand, distributed data processing system that is platform independent.
Still yet other object of this invention is to provide an elastic, scalable, on-demand, distributed data processing system that is atomic, consistent, isolated and durable.
Yet still another object of this invention to provide an elastic, scalable, on-demand, distributed data processing system that operates over the Internet without a need for dedicated high-speed communications paths.
Still yet another object of this invention is to provide an elastic, scalable, on-demand, distributed data processing system that provides transaction processing and that is adapted for implementation over a wide geographic area.
In accordance with one aspect of this invention a database management system that enables users to interact with a database comprised of data and metadata comprises a plurality of nodes and persistent storage with communications paths therebetween. Each node includes an interface between high level-input and output commands at a user level and input and output commands at the system level that control a sequence of operations for interacting with the database, wherein, in response to certain system level commands, atom objects generate atoms, each atom containing a specified fragment of data or metadata whereby a set of all instances of atoms collectively define all the metadata and data in the database. Each node additionally includes a communications control for establishing a communications path with each other node in the system, a method responsive to a system command from the interface for requesting from a selected node copy of an atom that is relevant to the query but is not present in that node, a method responsive to a request for an atom from another node for replicating the requested atom for transfer to the requesting node whereby only atoms required to complete a query need be located in any transaction node at any given time, and a method responsive to a change in an atom at that node for replicating that atom for transfer to every other node in the system in which that atom is resident. The persistent storage contains a collection of atoms that collectively contain all the data and metadata in the database.
In accordance with another aspect of this invention database management system that enables users to interact with a database comprised of data and metadata, said system includes at least one transactional node that provide users with access to the database and at least one archival node that maintains an archive of the entire database. Each transactional node includes a database request engine that provides an interface between high level-input and output query commands at a user level and input and output commands at the system level that control a sequence of operations for interacting with the database. In response to certain system level commands, atom objects generate atoms. Each atom contains a specified fragment of data or metadata whereby a set of all instances of atoms collectively define all the metadata and data in the database. A database system network interconnects all the nodes. A communications control in each of the nodes for establishes a communications path with each other node in the system. A method in each transactional node responds to a system command from the database request engine for requesting a copy of an atom that is relevant to the query command but is not present in that node. Another method in each node responds to a request for an atom from another node for replicating the requested atom for transfer to the requesting node whereby only atoms required to complete a query command need be located in any transactional node at any given time. Another method in each transactional node responds to a change in an atom at that node for replicating that change to every other node in the system that contains a copy of that atom
In accordance with yet another aspect of this invention a database management system for a logical database comprised of data records organized into tables that is to be accessed from multiple transactional nodes that process transactions related to the logical data base wherein the database is parsed into fragments wherein each fragment stores a portion of the metadata and/or data pertaining to the logical data base for transfer within the database management system as serialized messages and for storage as a de-serialized message. The system includes at least one archival node that stores all the fragments in a de-serialized form in permanent storage thereby to constitute a single store for the entire data base. Each transactional node responds to queries from users by establishing a sequence of low-level commands for identifying fragments that are relevant to the query and responds to the low-level commands by obtaining only those copies of existing fragments that are relevant to the query being processed thereat whereby a given fragment might exist at some other node or only at an archival node. Each transactional node replicates any changed fragment to the at least one archival node and each transactional node in which a copy of that fragment resides whereby changes are made to fragments in other nodes on a peer-to-peer basis and whereby any transactional node only contains those fragments that pertain to the queries being made users accessing the data base through that transactional node.
The appended claims particularly point out and distinctly claim the subject matter of this invention. The various objects, advantages and novel features of this invention will be more fully apparent from a reading of the following detailed description in conjunction with the accompanying drawings in which like reference numerals refer to like parts, and in which:
Each node in
The database request engine 41 only exists on transactional nodes and is the interface between the high-level input and output commands at the user level and system level input and output commands at the system level. In general terms, its database request engine parses, compiles and optimizes user queries such as SQL queries into commands that are interpreted by the various classes or objects in the set 42.
For purposes of the explanation of this invention, the set classes/objects set 42 is divided into a subset 43 of “atom classes,” a subset 44 of “message classes” and a subset 45 of “helper classes.” Additional details of these classes are described later.
As will become apparent and in accordance with this invention, at any given time a transactional node only contains those portions of the total database that are then relevant to active user applications. Moreover, the various features of this invention enable all portions of database in use to be resident in random access memory 38. There is no need for providing supplementary storage, such as disk storage, at a transactional node during the operation of this system.
Referring to
A preferred embodiment of this invention uses object-oriented programming (OOP) wherein, as known in the art, classes and subclasses such as shown in
This invention will now be described in several phases. An “Atoms” section defines the hierarchy and function of objects produced by the atom classes 43 and 63 in
As previously stated, each of the atom classes 43 in
Atoms have certain characteristics. In a transactional node, an atom exists only in non-persistent memory and in the form of a de-serialized message that has populated a particular atom type to provide an efficient memory resident format for the atom. Each atom has means for encoding its content into a serialized message and means for decoding a serialized message to retrieve the contents of the atom. Such serialized messages are used in connection with a number of operations as will be described later.
Each serialized message transmitted from a node for replicating an atom includes the content of that atom with an appended node identification and the most recent transaction commit sequence number for that node. When an archival node receives that serialized message, it de-serializes the message, removes the node list and commit sequence number before placing the remaining content of the message (i.e., an atom) in persistent storage.
A number of rules apply to atoms in accordance with this invention. The reasons and implications of those rules will become more apparent. First, each atom must have a unique identification to provide a reliable identification of that atom anywhere in the database processing network 30 in
A “garbage collection” process, described in greater detail later, can occur on archival and transactional nodes. The process removes inactive atoms from transactional and archival nodes. As a result, a transactional node can store those atoms that are then currently relevant to user applications in random access memory at that node. Thus, the database request engine 41 “sees” the entire database as being local and is not aware that it is operating in a multi-node environment and without a complete copy of the database at its node. Archival nodes have the option of purging the contents of an atom after it has been serialized to disk thereby reducing the size of the memory required for storage. If an archival node receives a replication message for such an atom, the archival node must fetch the content from disk storage before applying the information from the atom being replicated.
With this general background, each atom type will now be described at a “logical” or functional level. This information, in conjunction with further discussions of the operation of this invention, will enable a person of ordinary skill in the art to make and use this invention in any of a variety of implementations, including implementations based upon object oriented programming.
Referring to
The Table Catalog atom 75 acts as an active index and creates and monitors Index atoms 76, Record States atoms 77, Data atoms 78, Blob States atoms 80 and Blob atoms 81 associated with a single table. That is, there is one Table Catalog atom 75 for each table.
Still referring to
Each atom has certain common elements and other elements that are specific to its type. Referring to
Each atom must have a chairman. The chairman performs functions as described later. Element 70D is a pointer to that node where the chairman for that atom resides.
Each time a copy of an atom is changed at any transactional node, it receives a new change number. Element 70E records that change number.
Whenever a node requests an atom from another node, there is an interval during which time the requesting node will not be known to other transactional nodes. Element 70F is a list of all the nodes for which the supplying node must relay messages to the requesting node from all other nodes that contain that atom until the request is completed.
Operations of the database system are also divided into cycles. A cycle reference element 70G provides the cycle number of the last access to the atom. Element 70H is a list of all active nodes that contain the atom. Element 70I includes several status indicators.
Still referring to
When a transactional node joins the database system 30 in
The entries at 70P are important because they link all the atoms for which the Master Catalog atom 70 acts as an active index. As previously stated, these include the Database atom 72 and each of Schema atoms 73, Table atoms 74 and Table Catalog atoms 75.
A password entry 70Q is representative of a means for authenticating a connection into the database. Actual and software version entries 70R and 70S allow the system to operate with backward compatibility when a newer version of the software is installed. The actual software entry 70R identifies the software version then in use; the software version entry 70S, the number corresponding to the most recent installed version. This permits individual nodes to be updated to newer versions without requiring other nodes to be updated and without closing the database for access by all nodes.
Still referring to
Referring to
An ID manager 71J provides unique transaction sequence identifications and maintains an active transactions list 71K, a committed transactions list 71L and a failed transactions list 71M. Element 71N stores commit sequence information. The ID manager 71J assigns a transaction ID at the start of each transaction. Each transaction ID is unique, but not necessarily sequential. A local Transaction Manager atom assigns a commit sequence number to element 71N when a transaction commits. Sequence numbers are sequential and each is specific to the node that requested the transaction. A transaction-transition event counter 71P identifies discrete events that occur during each transaction, such as the start of the transaction and the successful committing of the transaction. Such counters are useful when multiple transactions involving the same information overlap.
Referring to
Basically, the Database atom 72 includes elements 72A-72I corresponding to like elements in
Referring to
Each Table atom has several ID managers. A pointer 74L points to an ID manager that provides each field with a unique identification. Pointers 74M, 74N, 74P and 74Q identify separate ID managers for assigning identifications to Index atoms, Data atoms, Blob atoms and subtypes, respectively. Element 74R is a list of the existing subtypes. Arrays 74S and 74T provide the locations of Record States atoms and Blob States atoms, respectively.
Now referring to
Referring to
Referring to
In database applications to which this invention is directed multiple users can produce multiple versions of the same record. A preferred embodiment of this invention uses multi-version concurrency control (MVCC) to ensure that a transaction never has to wait for the database by allowing several versions of a record or other object to exist in the database simultaneously. Consequently, each Record States atom 77 includes metadata about each record version. Entry 77M is a bitmap for identifying the location of each versioned record that is useful in garbage collection.
The Record States atom 77 includes, for each version 77N of a record, a transaction ID 77P to identify the transaction that generated the version. A format version entry 77Q identifies the version number for the table sub-type that existed when the record was inserted. This format identifies the physical order of the record and identifies the subtype to which the record belongs of the database program that was in use at the time the record version was created. Element 77R includes a record version sequence number; element 77S, the location of the next older, or previous, version of the record. An index 77T to the data atom array 77J and the base record identification 77K together provide the address for the actual slot 77U in the Data atom with the record version.
Now referring to
In summary, each atom has a relationship with only a fragment of the database. For example, the Database atom 72 contains metadata that identifies the schema for the database. Each Schema atom 73 contains metadata that identifies all the tables associated with that schema. For each table, a Table atom 74 and a corresponding Table Catalog atom 75 provide metadata about the table including such information as the identification of fields and their properties. Record States atoms include metadata about a group of records. Data atoms include information about each data record with pointers to slots that contain these records and various versions. Blob States and Blob atoms contain similar information about blob records.
As previously indicated, communications between any two nodes is by way of serialized messages which are transmitted asynchronously using the TCP or another protocol with controls to maintain messaging sequences.
As briefly discussed previously, when a message is to be sent, there are different communications paths to different nodes. For example, if one node, as a requesting node, needs to obtain an atom, replications of that atom may be located in multiple other nodes. In this embodiment, “pinging” provides selection information useful for selecting the best path corresponding node. Pinging, as known, involves determining time for a “ping” command to reach its destination and for an acknowledgement message to be received. In this embodiment of the invention, each node periodically uses a helper class to send a Ping message 110 to each of the other nodes to which it connects. Each receiving node uses a helper class to return a Ping Acknowledge message 111 that contains the ping time. Each node accumulates this information about the time to send and receive these messages in a node object described later with respect to
A next set of messages are involved with the connection of a new node into or previously inactive node back into the database system 30 in
Archival nodes can operate in either an active mode or a synchronizing mode when they are synchronizing to another node. A helper class in the archival node transmits a Node State message 115 to alert all other nodes of any status change in that archival node.
A next set of messages are involved when a node, as a requesting node, retrieves a copy of an atom from another node. For example, after a node joins the database system 30 in
Still referring to
In some situations the selected node sends an Object Unavailable message 121 to announce that the selected node has dropped the requested atom. A Bounce Object message from the selected node indicates that the requested atom is not found in the Master Catalog atom or one of the Table Catalog atoms. This may occur when an update transaction is underway and the selected node does not respond to the Object Request message 116 because the garbage collection process has collected that atom before receiving the Object Request message. As a response, the requesting transactional node can select another node in the database system with the atom.
The database request engine 41 in
Whenever a local node is updated or modified, its change number is incremented. Every replication message contains that atom's local change number. Every atom tracks the most recent change number for each node. When an archival node receives a copy of a modified atom, it copies the change numbers for the atoms, clears the change numbers and then serializes the atom to disk. If a change has been made, the change number will not be zero. The archival node sends an Object Written message 126 with the change number written to each node. Each receiving node compares it own change number with that in the message. Then the node can update the status for the atom to note that the atom has been archived and is a potential candidate for garbage collection.
As previously indicated, each atom must have a unique identity. When a first atom of a particular atom type (e.g., a new Table atom) is created, the creating transactional node is designated a Chairman for that Table atom. Rules for governing the “chairmanship” are discussed later. Whenever a transactional node needs to create a new atom type, it sends an ID Request message 127 to the Chairman if it does not have an available identification. The Chairman generally returns an ID Delegation message 128 which includes a block of at least one unique identification from its allocation of free identification values. This process is described in greater detail with respect to the process of
Referring to
Each time a transactional node inserts a new record in a table, it produces a Table Record message 133. Whenever it becomes necessary to create a new index, as when an indexed field is added to a table, the creating Table atom replicates the new Table atom. At this time, the index is set to be a write-only index. After all the related processes involved have been completed, the node sends a Table Index Added message 134.
Any time a Table atom creates a Blob States atom for a blob, the Table atom generates a Table Blobs Object message 135. A Table Blob message 136 indicates that a new blob has been created.
In a database that utilizes types and sub-types, the database request engine 41 in
A Table Record Expunge message 138 provides the record number on specific Record States atom. A Table Garbage Collect message 139 is generated by a Chairman for a Table atom when it is determined that a record within that table contains an unusually long chain of back versions or other criteria. The result is that “unused” atoms are “emptied” of data.
A Record States atom 77 in
A Data atom stores up to some maximum number of records and versions thereof. A corresponding Record States atom monitors the size of the Data atoms it manages. If a Record States atom determines that a managed Data atom has exceeded that size, it generates a new Data atom and replicates that new Data atom by means of a Records Data Object message 143.
A Record States atom generates a Records Record message 144 for replicating any new record version. Periodically, a Table atom Chairman initiates a process by which a Record States atom identifies record versions that are older than the oldest active transaction. When this occurs, the Chairman's Record State atom transmits a Records Prune message 145 that enables those older record versions to be deleted during a subsequent garbage collection process. If a situation arises wherein it becomes necessary to rollback a transaction, a Record States atom generates a Backout Record message 146 that updates the backout record.
There is also a set of index-specific messages. As known an index has an optimum maximum size; and if the index exceeds that size, the index should be split. In accordance with this invention, only a Chairman can split an Index atom. The Chairman can do this unilaterally or in response to an Index Split Request message 147 from another copy of that atom. When the Chairman causes the split, the Chairman generates an Index Split message 148 that contains a split index. After the split, the Chairman sends an Index Prune message 149 to truncate the original Index atom following the split. Each time an index node is added to the index, it generates an Index Node Added message that contains an index key, record identification and other information for the new index. When an index has been fully populated and therefore is ready for use during retrieval operations, a Table Index Ready message 151 is generated. As previously indicated, adding a table index generates an Index atom that is a write only index and that is not readable. The Table Index Ready message 151 makes such a write-only index readable.
A Blob States atom identifies a slot in a Blob atom by generating a Blobs Blob message 152.
A Data Record Message 153 contains the slot number and the record length. It also includes the data record.
As the state of a transaction changes, the Transaction Manager atom 71 for a given transactional node generates Transaction State messages 154. These indicate whether the current status of the transaction is in an active state, a pre-commit state, a commit state or a rollback state. Under certain circumstances it is possible that a request related to one transaction will be blocked by another transaction on another node. In that event, the Transaction Manager atom receives a Transaction Blockage message 155. If a transaction is deadlocked and must be rolled back, the Transaction Manager atom associated with the node causing the deadlock generates a Transaction Deadlock message 156 causing the transaction to be rolled back.
The Master Catalog or any Table Catalog atom on an archival node can request the time an atom was last written. This occurs when a requesting node sends a Request Write Times message 158. The recipient of that message then returns those requested times in a Write Times message 159.
The foregoing messages constitute a set by which the various procedures needed to maintain a database management system incorporating this invention can be handled properly. As will be apparent, each message has a minimum of overhead in a header. Each message can be reasonably short. When used with TCP or other messaging protocol, the messages must be sent sequentially and, at any given node, on receipt they must be handled in the same sequence in which they were sent even by different nodes.
It will now be helpful to a further understanding of this invention to describe some basic methods that relate to various aspects of the operation of this invention. Variations from each will be apparent to those of ordinary skill in the art.
Once the connection is established in step 171, the joining transactional node 170 uses step 174 to send a Connect message to the selected node 172. The selected node 172 responds to the Connect Message at step 175 by updating its Master Catalog atom with its connection manager, assigning a local node ID to the joining transactional node 170 and adding that node to an array of local nodes in its node object, an example is shown in
The node object 400, like all the atoms, includes a global node ID 400F and a local node ID 400G of the node to which this node is listening. Element 400H is a pointer to a queue of messages that are waiting to be sent from the node. Elements 400I and 400J contain the identifications for the local port and the remote ports. Element 400K contains the version number for the software operating at the remote node. A node type element 400L indicates whether the remote node is a transactional node, an archive node undergoing a synchronization process or an on-line archival node.
Element 400M contains the name for the local node; element 400N, the name for the remote node. Element 400P is a pointer to the current message being processed. Elements 400Q and 400R identify the time of the last ping operation and the ping time. As previously indicated, each node generates a sequential commit sequence number in response to each commit operation for a transaction initiated at that node. Element 400S contains this number. Element 400T indicates whether this node object is the node object for this node.
Referring back to
Each node in the group 173 responds to the New Node message by recording the global ID and assigning a local ID of the joining transactional node and updating a local list of all connected nodes in their respective Master Catalog atoms at step 180. Each then uses step 181 to send a Welcome message to the joining transactional node 170. Upon completion of this process, the joining transactional node 170 has a full list of all the active nodes including the selected node 172 and all the nodes in the group 173.
When the joining transactional node 170 receives the Welcome message from the selected node at step 182, it sends an Object Request message (step 183) to the selected node 172 requesting a copy of the Master Catalog atom. After the selected node 172 has updated the various items of information in its Master Catalog atom, the selected node implements step 184 to serialize its Master Catalog atom in an Object message that is sent to the joining transactional node 170 and broadcasts an Object Available message to all the other nodes in the system. Thus, the Master Catalog atoms in each node are updated and synchronized.
Without waiting for the receipt of the Object message, the joining transactional node can also begin the process of step 185 for retrieving a copy of the Database atom and the Transaction Manager atom from the selected node 172.
Each other node that receives the Object Available message responds in step 186 by sending an Object Acknowledged message back to the selected node.
The database request engine in the joining node initiates this sequence. Thus, when the method of
During some operations, a transactional node might create of a new table, necessitating the creation of a new Table atom.
At step 192, the local catalog Z creates that instance of atom Y with no content and designates the local node as the chairman for atom Y. Then a process 193 allows the local catalog Z to assign an object ID to new atom Y. The specifics of such a process are shown and described with respect to
Next, the local catalog Z sets an exclusive lock to allow changes to it to occur without any influences from outside automation. While the lock is in place, the local catalog Z sets the status of new atom Y to a “dirty” status and to a “non-open” status. The “dirty” status indicates that the new atom Y has not been replicated to an archive. The “non-open” status indicates that the new atom Y is not yet available to other nodes. At step 195 the local catalog Z updates itself and then releases the exclusive lock. At step 196 catalog Z broadcasts an Object Available message identifying atom Y to all other instances of catalog Z in the transactional and archival nodes.
At step 197 atom X, as the managing atom for new atom Y, populates the instance of atom Y and sets the status for atom Y to “open” indicating that the new atom can be replicated. Some time thereafter an archival node will save a copy of the new atom to persistent storage. That is, the archival node will respond to the receipt of the Object Available message by requesting a copy of atom Y thereby to provide the redundancy. When this is complete, the receipt of a Object Acknowledged message from the archival node will cause the “dirty” status to be changed and this change will then be reflected to all other nodes that have a copy of atom Y.
The assignment process 193 in
As will be recalled, when at least one other node exists for the particular atom, each atom contains a list of nodes that include copies of the atom being requested. If this were a first request for the atom after that atom had been created in accordance with the process of
When the chairman receives the ID request message at step 205, it obtains a block of available ID numbers (step 206). The chairman identifies the transactional node making the request as the site of this block of available ID numbers (step 207). Then the chairman sends an ID delegation message at step 210 to the requesting node. When the requesting node receives the ID Delegation message from the chairman at step 211, it stores the block of ID numbers at step 212 and then selects the first available ID for assignment in step 201. Referring back to
Whenever the Database engine 41 in
In step 231, the requesting node 221 sends an Object Request message for atom Y to the selected node 222. In response, the selected node 222 uses step 232 to send an Object Message with the requested atom Y in its serialized form with the node and sequence numbers.
At the same time, the selected node 222 broadcasts an Object Available message to all other nodes 223. It also creates a relay list for all other nodes with a copy of atom Y. At this point in the process, the other nodes do not communicate directly with atom Y in the requesting node because they are not aware that they should be sending replication messages for that atom to requesting node. Therefore, when any of the other nodes replicates its atom Y, the selected node 222 will relay the message to the requesting node 221.
When the Requesting node 221 receives the Object message from the selected node 222, it conducts an accessibility analysis of the message at step 233. If the message contains a current atom, atom Y processes the message at step 236 and sends an Object Acknowledged message to the selected node at step 237.
All other nodes 223 use step 240 to respond to the Object Available messages by sending an Object Acknowledged message to the selected node 222. The selected node 222 uses step 241 to monitor the Object Acknowledged messages. Specifically, it removes each of the other nodes from its relay list in response to each Object Acknowledged message and ceases relays to that node. When all the other nodes 223 have been removed from the list, the selected node stops all relaying and broadcasts an Object Complete message.
It is possible for another node to send a replication message that reaches the requesting node 221 during the time between steps 226 and 236 in
As previously indicated, this invention is particularly adapted to a database that interfaces with transactional processing techniques. As such, an appropriate approach for “committing” messages should be involved.
As previously described with respect to the process for requesting a copy of an atom in
With respect to transaction IDs and commit sequence numbers and as previously stated, each transaction identifier is unique across the entire database system of
Consequently, some method must be provided to assure that a transaction can read a record version only if the transaction that created the record version had committed before the reading transaction started. In this invention such a method for determining which record version to read is the transaction commit time for the transaction that created the record version, not the start time. A transaction ID does not contain its commit time, so the Transaction Manager atom on each node assigns a commit sequence number to each transaction based upon the actual commit operation. Each transactional node generates its commit sequence numbers in an increasing sequence. If a transaction from a given node has a commit sequence number of 467, all transactions from that node with lower commit sequence numbers are certain to have been committed. All nodes generate the same commit sequence numbers, so interpreting the numbers requires both the number and the identification of the corresponding node.
When a transaction commits, its Transaction Manager atom sends a Commit message to all nodes that include the corresponding transaction ID and commit sequence number. When an atom serializes itself, it includes the highest commit sequence number that it has seen from each node that holds a copy of that atom. For example, assume nodes A, B and C contain copies of an atom Z and that node A generates a Object message for atom Z. The serialized form of that message will include the highest commit sequence number that node A has seen from itself and the highest commit sequence numbers it has seen from nodes B and C. The serialized message from node A describes the state of transactions on all nodes that share a copy of atom Y as node A sees it. It is possible that node B or node C may have actually issued higher commit sequence numbers for transactions that node A has not yet received or processed.
The Transaction Manager on each node maintains a transaction object for each node in the database system. Each transaction object reflects the state of transactions on all nodes and assigns each object two more numbers that are local and continuously increasing. When the Transaction Manager atom starts a transaction or receives a transaction transition message that indicates that another node has started a transaction, the Transaction Manager atom creates a local transaction object with the new transaction ID and assigns it a start number. When a local transaction commits or when Transaction Manager atom receives a transaction transition message that indicates that a transaction on another node has been committed, a transaction end number is assigned to the transaction object along with the commit sequence number. The start and end numbers come from the same sequence. As an example, if Transaction 123 has a start number that is higher than the end number of Transaction 453, Transaction 123 can read record versions created by Transaction 453 from any node that executed Transaction 453.
Transaction start and end numbers are local; that is, they reflect the state of transactions as seen on the local node. Different nodes assign different values and see different ordering of transactions on other nodes. As will be apparent, delays can exist in receiving and in processing Transaction State messages. Each transaction runs only on its local transactional node. This database system prevents one transaction node from “seeing” a transaction as committed before the transaction commits on its local transactional node. For example, if node A starts Transaction 123 after receiving and processing the commit message from transactional node B for Transaction 453, Transaction 123 can read the changes from Transaction 453, even if a transactional node C that received the transaction commit and start messages in another order and considers the two transactions to be contemporary.
As neither of the transactions runs on transactional node C, the information is not relevant to transactional node C. However, the difference between the view of the database system by each individual transactional node can cause problems in certain circumstances.
With respect to “atom skew”, in accordance with one aspect of this invention, each node must process messages from another node in the order that the other node sent the messages. However, all nodes operate independently. Thus, at any given time, some nodes will have received and processed messages that other nodes have not yet processed. Some copies of atoms will include changes that other copies do not. Those differences do not matter to any node that has a copy because each copy of the atom is in a consistent state for that node. As previously described, whenever a transactional node changes an atom, the node replicates the changed atom to all other nodes that contain a copy of that atom. If transactional nodes B and C each contain a a copy of that atom and transactional node B changes that atom, transactional node B sends replications messages to transactional node C. While transactional node B is processing a transaction, it sends a Transaction State message to transactional node C and replicates any atoms that transactional node B changes. When transactional node B commits the transaction by the process shown in
When viewing transactions from the system level, different transactional nodes are not acting in synchronism. The times for a single message being processed by different nodes can vary due to differences in the efficiency of the communications path and the number of messages that each transactional node needs to process. The differences in processing times at different nodes must be taken into account. Consider three transactional nodes: node A, node B and node C. Assume that node B executes a transaction 768 that changes atom X and that node C has a copy of atom X. Assume that atom X at node B sends change messages to node C and that there is some time lapse before node C processes those changes. Assume also that node B has assigned a commit sequence number of 47 to Transaction 768. The Transaction Manager atom on node B sends a Transaction State message to all nodes in the database system. Also assume that node A requests a copy of atom X from node C after receiving the commit message from node B, but before Node C completes processing the transaction. Node A receives and processes the Transaction State message from node B. From the perspective of node A, transaction 768 is committed and the highest commit sequence number for node B is 47. However, with this timing, the atom returned from node C does not reflect the changes made by the transaction at node B.
In accordance with this invention, when atom X on node C serializes itself for transmission to node A, it includes the highest commit sequence number from each node that has a copy of atom X. In this case, assume that the message would include a commit sequence number 97 for node C and 46 for node B.
Referring to
As previously stated, when node C sent the serialized copy of atom X to node A, it sent an Object Available message to other copies of atom X, in this case, to the copy on node B. Atom X on node B sends an Object Acknowledged message to atom X on node C and adds the copy on node A to its list of copies of itself. Thereafter, atom X on node B will send change messages to its copies on both nodes A and C. Meanwhile, atom X on node C processes the messages from node B, relaying them to node A. Atom X on node A processes the messages, bringing itself more and more up to date. When atom X on node C processes the Object Acknowledged message from atom X on node B and all other copies of atom X on other nodes, it sends an Object Complete message to atom X on node A.
In accordance with this invention each transactional node should operate without having to transfer any atoms to disk or other persistent storage. This requires removal of inactive atoms from each transactional node in an expeditious manner. To achieve this goal, a helper class in each node provides a garbage collection function called by a cycle manager periodically to initiate a new garbage collection cycle independently of other operations. More specifically, the cycle manager performs an aging cycle whereby any atom referenced in a previous cycle is moved to the front on a least recently used (LRU) list in the Master Catalog atom for the node. The cycle manager obtains an exclusive lock to assure that no other threads are active with respect to a previous cycle.
The cycle manager then starts the record garbage collection thread for a table atom that is marked for record garbage collection. If the current amount of memory at the node exceeds a specified amount defined by a configuration object identified by the pointer 70U at
If the garbage collection process determines that all the foregoing conditions have been met, there are two options. If the node is an archival node and there are other instances of the atom at other nodes, the content of the atom is “purged”. Otherwise the atom is requested to drop itself which it does by first checking with its creating catalog atom for a final test. If that test is passed, the catalog atom clears its pointer to the candidate atom which broadcasts an Object Unavailable message to other nodes that contain instances of the candidate atom and then deletes itself. This loop continues on an atom by atom basis until the working memory is within acceptable limits.
Two mechanisms are involved with this process. When a Catalog atom is asked to find an atom for classification, the Catalog atom sets its cycle reference entry to the current cycle number. In addition, Transaction Manager, Database, Schema, Sequence and Table atoms obtain a shared lock on a current cycle so that methods in those atoms can hold atom pointers without having to increment an atom use count to prevent an object or an atom from being garbage collected.
When another node later requests a copy of that atom, the selected node places the identification of the requesting node in the ordered list just after itself, whether it is the chairman or not. As a result, if the node designated as a chairman for any atom becomes inactive for any reason, every other copy of that atom has the ordered list of nodes. Going through the ordered list, the next chairman is the first remaining transactional node on the list. If there are no transactional nodes on the list, the first non-synchronizing archival node is designated.
It may now be helpful as an aid in understanding the interaction among different nodes and atoms within a node to discuss a simple database query. Assume the database request engine at a transactional node receives a database query to select all records in a table “member” with a postal code of “01944.” It is assumed that the Transaction Manager atom and Table atom are located at the local node, that all query processing has been completed and that an Index atom exists for a “zip” field in the “member” table.
Initially the database request engine 41 in
The Table atom for the “member” table utilizes information from the corresponding Table Catalog atom to scan the index. This produces a bitmap that identifies each “record” in the “member” table with the specified zip code. As will be apparent, this bitmap may be limited to a particular field or maybe the result of the logical combination of indexes from multiple fields.
Next, a loop is established based upon the resulting bitmap. For each iteration of the loop, the database request engine issues a call to the Table atom to process a fetch record method specified with the transaction ID in the record. The Table atom selects an appropriate Record States atom that is related to a Record atom by dividing the record number by a fixed number that corresponds to the maximum number of record IDs a Record States atom manages. Next, the Table atom uses a fetch method in the selected Record States atom using the transaction ID and identified record number. For multi-version records, the Record States atom loops through any record versions to find the correct version and the appropriate pointer to the corresponding Data atom. The Record States atom calls that Data atom with the data atom number that points to the record and permits its retrieval. When this process is completed, the database request engine provides the user with a recordset that lists all the records with the specified postal code.
In summary, it will be apparent to those of ordinary skill in the art that a database management system constructed in accordance with this invention provides an elastic, scalable demand-distributed data processing system. The system is fault tolerant and has a high degree of availability. It is platform independent and operates to provide an atomic, consistent, isolated and durable database. Moreover, it can operate over the internet without the need for high speed communications paths and is adapted for transactional processing that can be implemented over a wide geographic area.
In summary this invention achieves all these objectives by implementing one or more of the following features. This invention fragments the database into distributed objects that replicate on a peer-to-peer basis. Each transactional and archival node determines which atoms are to be memory resident on a local basis. Catalog atoms track locations to local and remote copies of various atoms and identify the catalogs of which they are members. Moreover each node can determine the best of multiple nodes from which to request a copy of the atom enabling geographically dispersed systems.
This invention has been disclosed in terms of certain embodiments. It will be apparent that many modifications can be made to the disclosed apparatus without departing from the invention. Therefore, it is the intent of the appended claims to cover all such variations and modifications as come within the true spirit and scope of this invention.
Patent | Priority | Assignee | Title |
10037348, | Apr 08 2013 | DASSAULT SYSTEMES SE | Database management system with database hibernation and bursting |
10067969, | May 29 2015 | DASSAULT SYSTEMES SE | Table partitioning within distributed database systems |
10169440, | Jan 27 2014 | International Business Machines Corporation | Synchronous data replication in a content management system |
10169441, | Jan 27 2014 | International Business Machines Corporation | Synchronous data replication in a content management system |
10180954, | May 29 2015 | DASSAULT SYSTEMES SE | Disconnected operation within distributed database systems |
10282247, | Mar 15 2013 | DASSAULT SYSTEMES SE | Distributed database management system with node failure detection |
10534856, | Oct 17 2016 | International Business Machines Corporation | Atom-based sensible synchronization for information indexing |
10740323, | Mar 15 2013 | DASSAULT SYSTEMES SE | Global uniqueness checking in distributed databases |
10853347, | Mar 31 2017 | Microsoft Technology Licensing, LLC | Dependency-based metadata retrieval and update |
10884869, | Apr 16 2015 | DASSAULT SYSTEMES SE | Backup and restore in a distributed database utilizing consistent database snapshots |
10984190, | Oct 17 2016 | International Business Machines Corporation | Atom-based sensible synchronization for information indexing |
11016956, | Apr 08 2013 | DASSAULT SYSTEMES SE | Database management system with database hibernation and bursting |
11132502, | Oct 17 2016 | International Business Machines Corporation | Atom-based sensible synchronization for information indexing |
11176111, | Mar 15 2013 | DASSAULT SYSTEMES SE | Distributed database management system with dynamically split B-tree indexes |
11182378, | Nov 08 2017 | Walmart Apollo, LLC | System and method for committing and rolling back database requests |
11222008, | May 29 2015 | DASSAULT SYSTEMES SE | Disconnected operation within distributed database systems |
11314714, | May 29 2015 | DASSAULT SYSTEMES SE | Table partitioning within distributed database systems |
11438224, | Jan 14 2022 | Bank of America Corporation | Systems and methods for synchronizing configurations across multiple computing clusters |
11561961, | Mar 15 2013 | DASSAULT SYSTEMES SE | Global uniqueness checking in distributed databases |
11573940, | Aug 15 2017 | DASSAULT SYSTEMES SE | Index splitting in distributed databases |
11709849, | Nov 21 2014 | Red Hat, Inc. | Federation optimization using ordered queues |
9454591, | May 26 2010 | International Business Machines Corporation | Synchronization of sequential access storage components with backup catalog |
9501363, | Mar 15 2013 | DASSAULT SYSTEMES SE | Distributed database management system with node failure detection |
9767168, | Nov 21 2014 | Red Hat, Inc. | Federation optimization using ordered queues |
ER6410, | |||
ER8955, |
Patent | Priority | Assignee | Title |
5555404, | Mar 17 1992 | CLUSTRA SYSTEMS INC | Continuously available database server having multiple groups of nodes with minimum intersecting sets of database fragment replicas |
6401096, | Mar 26 1999 | Paul, Zellweger | Method and apparatus for generating user profile reports using a content menu |
6480857, | Jun 07 2001 | Method of organizing hierarchical data in a relational database | |
6499036, | Aug 12 1998 | Bank of America Corporation | Method and apparatus for data item movement between disparate sources and hierarchical, object-oriented representation |
6523036, | Aug 01 2000 | EMC IP HOLDING COMPANY LLC | Internet database system |
6748394, | Apr 27 2000 | Oracle International Corporation | Graphical user interface for relational database |
6862589, | May 10 2001 | Ranco Incorporated | System and method for performing diagnostics using a portable device displaying diagnostic data using templates |
7028043, | Apr 10 1998 | International Business Machines Corporation | Creation of customized trees |
7080083, | Dec 21 2001 | CHARTOLEAUX KG LIMITED LIABILITY COMPANY | Extensible stylesheet designs in visual graphic environments |
7096216, | Jul 20 2002 | Microsoft Technology Licensing, LLC | Performing operations on a set of objects in a database system |
7219102, | Dec 22 2003 | International Business Machines Corporation | Method, computer program product, and system converting relational data into hierarchical data structure based upon tagging trees |
7233960, | Oct 31 2001 | NUMODA TECHNOLOGIES, INC | System and method for mobile wireless electronic data capture and distribution of a merchant card-processing application |
7293039, | Mar 12 2004 | NetApp, Inc | Storage resource management across multiple paths |
7395352, | Mar 12 2004 | NetApp, Inc | Managing data replication relationships |
7401094, | Dec 28 2001 | ADVANCED DYNAMIC INTERFACES, LLC | Automated generation of dynamic data entry user interface for relational database management systems |
7403948, | Aug 24 1998 | GOOGLE LLC | Workflow system and method |
7853624, | May 02 2006 | International Business Machines Corporation | System and method for optimizing distributed and hybrid queries in imperfect environments |
7890508, | Aug 19 2005 | Microsoft Technology Licensing, LLC | Database fragment cloning and management |
8108343, | Apr 23 2009 | Microsoft Technology Licensing, LLC | De-duplication and completeness in multi-log based replication |
8224860, | Mar 18 2010 | DASSAULT SYSTEMES SE | Database management system |
8266122, | Dec 19 2007 | Amazon Technologies, Inc. | System and method for versioning data in a distributed data store |
20050216502, | |||
20080320038, |
Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
Sep 13 2011 | STARKEY, JAMES A | NUODB, INC | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 028900 | /0826 | |
Jun 18 2012 | NuoDb Inc. | (assignment on the face of the patent) | / | |||
Aug 01 2024 | NUODB, INC | DASSAULT SYSTEMES SE | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 068299 | /0883 |
Date | Maintenance Fee Events |
Feb 06 2017 | M2551: Payment of Maintenance Fee, 4th Yr, Small Entity. |
Feb 08 2021 | M2552: Payment of Maintenance Fee, 8th Yr, Small Entity. |
Date | Maintenance Schedule |
Aug 06 2016 | 4 years fee payment window open |
Feb 06 2017 | 6 months grace period start (w surcharge) |
Aug 06 2017 | patent expiry (for year 4) |
Aug 06 2019 | 2 years to revive unintentionally abandoned end. (for year 4) |
Aug 06 2020 | 8 years fee payment window open |
Feb 06 2021 | 6 months grace period start (w surcharge) |
Aug 06 2021 | patent expiry (for year 8) |
Aug 06 2023 | 2 years to revive unintentionally abandoned end. (for year 8) |
Aug 06 2024 | 12 years fee payment window open |
Feb 06 2025 | 6 months grace period start (w surcharge) |
Aug 06 2025 | patent expiry (for year 12) |
Aug 06 2027 | 2 years to revive unintentionally abandoned end. (for year 12) |