Patent Publication Number: US-2022229814-A1

Title: Maintaining stable record identifiers in the presence of updated data records

Description:
CROSS REFERENCE TO RELATED MATTERS 
     This application is a continuation of U.S. patent application Ser. No. 16/675,789, filed Nov. 6, 2019, which is a continuation of U.S. patent application Ser. No. 15/730,008 filed Oct. 11, 2017, both of which are hereby incorporated by reference in their entirety. 
    
    
     BACKGROUND 
     In the course of business, large amounts of data records are collected and stored in one or more databases. These data records may reflect customer information, business records, events, products, or other records pertinent to a relevant business. These records can accumulate from a number of data sources. For example, a retail company may sell products over different channels such as online e-commerce platforms as well as physical store locations. The retail company may maintain separate customer records for each of its different retail channels. More business transactions can create more business records. As another example, two separate businesses, each maintaining their own data records, may merge. The businesses may maintain data about customers where such data overlaps. 
     Combining data from different sources can be burdensome, time consuming and costly. The present disclosure describes systems and methods of managing a database that overcomes a number of the drawbacks of prior art solutions. The advantages and benefits of the present disclosure will be discussed in further detail. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       Many aspects of the present disclosure can be better understood with reference to the attached drawings. The components in the drawings are not necessarily drawn to scale, with emphasis instead being placed upon clearly illustrating the principles of the disclosure. Moreover, in the drawings, like reference numerals designate corresponding parts throughout several views. 
         FIG. 1  is a drawing of a computing system  100  according to various embodiments of the present disclosure. 
         FIG. 2  is an example of a database table  112  of  FIG. 1  according to various embodiments of the present disclosure. 
         FIG. 3  is an example of clustered records existing within one or more database tables of  FIG. 1  according to various embodiments of the present disclosure. 
         FIGS. 4A-C  are different examples of a database table being updated. 
         FIG. 5  is an example of clustering an updated database table  112  of  FIG. 3  according to various embodiments of the present disclosure. 
         FIGS. 6A and 6B  build on the example of  FIG. 5  by explaining how two sets of clusters are compared to identify new clusters. 
         FIGS. 7A and 7B  build on the example of  FIGS. 6A and 6B  by explaining how to reassign stable identifiers and how to assign new stable identifiers. 
         FIG. 8  builds on the example of  FIGS. 7A and 7B  by showing an example of stable identifiers. 
         FIG. 9  is a flowchart illustrating an example of the functionality of the software application executed in a computing system  100  of  FIG. 1  according to various embodiments of the present disclosure. 
         FIG. 10  is a schematic block diagram that provides one example illustration of a computing system of  FIG. 1  according to various embodiments of the present disclosure. 
     
    
    
     DETAILED DESCRIPTION 
     Various embodiments of the present disclosure relate to providing a software application that optimizes a database as it is updated with records. A database may store multiple records that represent the same thing. For example, “John Doe,” “Jonathan Doe,” and “J. Doe” could be three different records, but in reality these records represent the same entity, a single person named “John Doe.” To avoid redundancy, these records may be grouped using clustering techniques discussed in further detail below. The cluster of records is assigned a stable identifier (ID) that can persist as the database is updated (e.g., changing a preexisting record, adding a new record, deleting a preexisting record). 
     Specifically, the cluster of records represented by a stable ID is maintained and used in conjunction with updates to the database. The use of stable IDs avoids drawbacks relating to collapsing a group of similar records into one surviving record. Using stable IDs also avoids the problem of optimizing an already optimized database, which can be a lossy process. In the following discussion, a general description of the system and its components is provided, followed by a discussion of the operation of the same. 
       FIG. 1  shows a computing system  100  according to various embodiments. The computing system  100  is made up of a combination of hardware and software. The computing system  100  includes a database  103  and a software application  106 . The computing system may be connected to networks such as the Internet, intranets, extranets, wide area networks (WANs), local area networks (LANs), wired networks, wireless networks, or other suitable networks, etc., or any combination of two or more such networks. 
     The computing system  100  may comprise, for example, a server computer or any other system providing computing capability. Alternatively, the computing system  100  may employ a plurality of computing devices that may be arranged, for example, in one or more server banks or computer banks or other arrangements. Such computing devices may be located in a single installation or may be distributed among many different geographical locations. For example, the computing system  100  may include a plurality of computing devices that together may comprise a hosted computing resource, a grid computing resource and/or any other distributed computing arrangement. In some cases, the computing system  100  may correspond to an elastic computing resource where the allotted capacity of processing, network, storage, or other computing-related resources may vary over time. The computing system may implement one or more virtual machines that use the resources of the computing system. 
     Various applications and/or other functionality may be executed in the computing system  100  according to various embodiments. Also, various data is stored in the database  103  or other memory that is accessible to the computing system  100 . The database  103  may represent one or more databases. 
     The data stored in the database  103  includes one or more database tables, such as database table  112 . A database table includes several records, where each record has one or more corresponding fields. A database table  112  may be linked or otherwise associated with one or more relational tables  115 . The components executed on the computing system  100  include software application  106  which is executed to access and optimize the contents of the database  103 . 
     Next, a general description of the operation of the various components of the computing system  100  is provided. Various businesses or other entities utilize the computing system to store information in a database. For example, businesses may want to store records reflecting customers, products, transactions, events, items, or any other piece of information relevant to the business. Records are collected over time and stored in database table  112  (or multiple such database tables). For example, when a business gets a new customer, a software program may create a record reflecting the new customer. This record may include the customer&#39;s name, address, contact information, or any other information that identifies the customer. Such information is stored as fields within a database table. 
     In practice, a single record is sufficient to represent a customer or other real-world entity. However, it is possible that duplicate or redundant records are inadvertently or unintentionally created and/or exist within the database  103 . For example, a customer may register with a business via an online portal which creates a customer record for that customer. Later, the same customer may inadvertently register again with the online portal, thereby creating a redundant customer record. As another example, two businesses maintaining their own customer records may merge such that the same customer may exist in two different database tables. The resulting merged database table could have redundant records. 
     When stored in a relational database, a database table  112  may be linked to one or more relational tables  115 . For example, if an airline company maintained a database table  112  that stored customer records, there may be one or more relational tables  115  storing the flight history for each customer. The contents of the one or more relational tables  115  links to a corresponding record. 
     The software application  106  of the present disclosure optimizes the database by processing one or more database tables using stable IDs. Stable IDs are assigned to clusters of like records. According to various embodiments, rather than assigning random IDs, stable IDs may be assigned by first calculating stable IDs using a deterministic algorithm based on the contents of the records within the cluster. As a database table  112  is updated, the organization of the clusters may change. The software application  106  uses stable IDs to the extent that it does not compromise the accuracy of optimizing a database table. The functionality of the software application  106  is discussed in further detail with respect to the remaining figures. 
       FIG. 2  shows an example of a database table  112  of  FIG. 1 . A database table includes one or more records  201   a - d , where each record has one or more fields  206   a - b . A record may or may not have all its fields populated. Each record is intended to be dedicated to a real-world entity. A real-world entity may be a physical person, place, or thing. In the computing world, a real-world entity can be represented as a record containing information about the real-world entity. For example, “record 1”  201   a  is intended to be the record representing an individual named “Jane Johnson.” “record 3”  201   c  is intended to be the record for “Jonathan Doe.” “record 4”  201   d  may or may not be a redundant record with respect to “record 3”  201   c . One purpose of the software application  106  ( FIG. 1 ) is to cluster records (e.g., records 3 and 4) when it is believed that they reflect the same real-world entity. 
       FIG. 3  shows an initial set of clusters  304 , also referred to as a first-generation set of clusters. The software application  106  ( FIG. 1 ) accesses one or more database tables, identifies the records  201  ( FIG. 2 ) in the database tables and organizes them into clusters. Clustering refers to a technique of grouping records  201  that have a degree of similarity that exceeds a threshold amount. 
     According to one embodiment, the software application  106  performs pairwise comparisons between different record pairs  201  to identify record pairs that are likely to be related. For example, the software application  106  may compare the fields  206  ( FIG. 2 ) between two records. If the information contained in a particular number of fields  206  and/or a particular combination of fields  206  is in common, then the software application  106  may determine that two records  201  subject to the pairwise comparison are considered to be a related pair or unrelated pair. A related pair refers to two records that represent the same real-world entity and an unrelated pair refers to two records that represent different real-world entities. After the related pairs are identified, the software application  106  performs a transitive closure operation to group related pairs. For example, assume that “record 3” and “record 4” are related pairs, and in addition, “record 4” and “record 5” are related pairs. The transitive closure operation may determine that “record 3,” “record 4,” and “record 5” should be contained within the same cluster. After records  201  have been organized into clusters  304 , the software application  106  assigns a stable ID  316   a - f  to each cluster. The software application may determine that a single record is organized within its own cluster. This may be referred to as a singleton cluster. 
     When stable IDs are assigned, the underlying records associated with a common stable ID continue to be stored in the database  103  ( FIG. 1 ). In other words, rather than consolidating like records into a single, surviving record and then destroying the underlying records, the software application  106  maintains both the like records and the corresponding stable ID. This is advantageous when there are updates made to the database table and a new cluster analysis is needed to be performed. 
       FIGS. 4A-C  show examples of updates  402  to a database table  112  ( FIG. 1 ) that take place after determining an initial set of clusters  304  ( FIG. 3 ).  FIG. 4A  shows an update  402  made to a database table  112   a  that adds additional information about a preexisting record. In  FIG. 4A , “record 4” does not have its first field  206  ( FIG. 2 ) populated. After performing an initial clustering operation, it may be determined that “record 4” should not be clustered with any other records  201  ( FIG. 2 ). 
     The database table  112   a  may be updated to generate an updated database table  428   a . The updated database table  428   a  includes additional information about preexisting “record 4.” When performing a subsequent cluster analysis, “record 3” and “record 4” may or may not be clustered depending on the update  402 . 
       FIG. 4B  shows an update  402  made to a database table  112   b  that adds a new record to generate an updated database table  428   b . Here, “record 5” is added as a result of the update  402 . When performing a subsequent cluster analysis, “record 3” and “record 5” may be clustered based on the update  402 , or possibly “record 3,” “record 4,” and “record 5” may be clustered together. The addition of a new record into a cluster may strengthen the chances that another record should also be included through transitive association. 
       FIG. 4C  shows an update  402  made to a database table  112   c  that removes a record to generate an updated database table  428   c . Here, “record 4” is removed as a result of the update  402 . Like the examples in  FIGS. 4A and 4B , a subsequent cluster analysis may be performed in response to the update  402 . 
       FIG. 5  builds on the example of  FIG. 3 .  FIG. 5  shows a subsequent set of clusters  512 , also referred to as a set of next generation clusters. As database tables are updated as discussed in  FIGS. 4A-C , the software application  106  ( FIG. 1 ) performs subsequent cluster analyses. This may lead to an identification of new clusters. A new cluster refers to a new grouping of records  201  ( FIG. 2 ), regardless of whether those records were newly added or not, resulting from an update  402  ( FIGS. 4A-C ). For example, in  FIG. 3 , “record 2” was not grouped with any other record while “record 8” was part of a separate cluster. In  FIG. 5 , in response to an update  402  to the database table  112  ( FIG. 1 ), the software application  106  has organized “record 2” and “record 8” into a new cluster. While records 2 and previously existed, the clustering of records 2 and 8 is new. Similarly, “records 10-13” reflect a new cluster as a result of the update  402  because prior to the update  402 , that specific grouping of records did not exist.  FIG. 5  also shows how some clusters have not changed because of the update  402 . For example, “record 1” continues to not be grouped with any other record. Also “records 3-7” continue to remain grouped without the addition or subtraction of any other records. 
     After the software application  106  performs a subsequent cluster analysis, the software application  106  then determines the stable IDs for the clusters. This is shown with respect to the remaining figures. 
       FIG. 6A  builds on the example of  FIGS. 3 and 5 .  FIG. 6A  shows an example of an initial set of clusters  304  on the left and a subsequent set of clusters  512  on the right. As mentioned above, the software application  106  ( FIG. 1 ) organized the records  201  ( FIG. 2 ) of a database table  112  ( FIG. 2 ) into a subsequent set of clusters in response to an update  402  ( FIGS. 4A-C ). As discussed above, the software application  106  assigned stable IDs  316  to the initial set of clusters  304 . After identifying a subsequent set of clusters  512 , as discussed with respect to  FIG. 5 , the software application  106  assigns temporary IDs  614  to the subsequent set of clusters  512 . Temporary IDs  614  serve as a placeholder as the software application  106  determines which stable IDs will be reassigned to the subsequent set of clusters  512 . 
       FIG. 6B  shows a comparison performed by the software application  106  to identify exact matches of clusters that exist in both the initial set of clusters  304  and the subsequent set of clusters  512 . An exact match occurs when two clusters consist of the same set of records  201 . For example, the values in the fields of two records are identical or practically identical. When the software application  106  identifies an exact match for a given cluster, the stable ID  316  associated with that cluster is inherited by the corresponding cluster of the subsequent set of clusters  512 . For example, “record 1,” which has a stable ID of “A1” has an exact match with a cluster within the subsequent set of clusters  512 . Accordingly, the software application  106  applies the stable ID “A1”  316   a  ( FIG. 3 ) to the exactly matched cluster in the subsequent set of clusters  512 . The same applies to stable IDs “A3”  316   c  and “A6”  316   f . After finding exact matches of clusters, the software application  106  updates the temporary IDs  617  or otherwise transfers the stable IDs of the exactly matched clusters. 
     In various embodiments, prior to performing the comparison, the software application  106  removes from consideration any records that have been deleted with respect to the initial set of clusters  304  and any records that have been added with respect to the subsequent set of clusters  512 . In this respect, only the records that overlap between the initial set of clusters  304  and the subsequent set of clusters  512  are compared to determine an exact match. For any new clusters made up of new records that are not part of the initial set of clusters  304 , such new clusters are assigned new stable IDs that have not been previously assigned. For clusters within the subsequent set of clusters  512  that partially contain new records, the new records do not affect the stable ID reassignment process described below. 
       FIG. 7A  continues the example from  FIGS. 6A-B .  FIG. 7A , depicts an example of how the software application  106  ( FIG. 1 ) reassigns stable IDs to new clusters that were identified based on the comparison between the initial set of clusters  304  and the subsequent set of clusters  512 . The software application  106  identifies new clusters in the subsequent set of clusters  512  that do not exist within the initial set of clusters  304 . For example, the cluster that includes “record 2” and “record 8” has been given a temporary ID of “B2” and does not have an exactly matched cluster within the initial set of clusters  304 . The same applies for “record 9,” having a temporary ID of “B4” as well as “records 10-13,” having a temporary ID of “B5.” Thus, the clusters associated with temporary IDs “B2,” “B4,” and “B5” are considered new clusters with respect to the comparison. 
       FIG. 7B  shows the example continuing from  FIG. 7A , which demonstrates an example of how the software application reassigns stable IDs to new clusters. Here, the software application  106  generates a confusion matrix  731 . The confusion matrix  731  may be a two-dimensional matrix where a first dimension represents at least some of the initial set of clusters and a second dimension represents at least some of the subsequent set of clusters. The example in  FIG. 7B  depicts a confusion matrix  731  that compares clusters within the subsequent set of clusters  512  that are not within the initial set of clusters  304  to clusters that are within the initial set of clusters  304  and that are not within the subsequent set of clusters  512 . The purpose is for the software application  106  to determine which stable IDs  316  should be reassigned to the new clusters within the subsequent set of clusters  512 . 
     The confusion matrix  731  includes matrix elements  734  which have a value based on comparing two respective clusters. These matrix elements  734  within the confusion matrix  731  relate to a quantity of overlapping record elements between a cluster in the initial set of clusters  304  and cluster in the subsequent set of clusters  512 . Specifically, a set made up of records 1-3 and a set made up of records 2-4 will have a quantity of overlapping record elements of two. That is, records 2 and 3 overlap both sets of records, making the quantity two. The larger the overlap of record elements, the more two clusters have in common, and the stronger the match. 
     After creating the confusion matrix  731 , the software application  106  applies an algorithm solving, optimally or approximately, the generalized assignment problem. In one embodiment, the software application  106  orders the clusters from largest to smallest quantity of overlapping record elements. In the example of  FIG. 7B , the comparison of “A4” to “B5” has the largest quantity of overlapping record elements, the quantity being 3. Based on this, the software application  106  assigns the cluster associated with temporary ID “B5” to have the stable ID of “A4.” In this respect, the software application  106  reassigns a stable identifier from the assigned identifiers of the initial set of clusters  304  to a newly identified cluster appearing in the subsequent set of clusters  512 . 
     With “B5” being equated to “A4,” the software application  106  moves to the next highest quantity of overlapping record elements. In the example of  FIG. 7B , “B2” and “A2” overlap by 1 record element, which is “record 2.” Accordingly, the software application  106  assigns the cluster associated with temporary ID “B2” to have the stable ID of “A2.” 
     The remaining clusters that have not been matched are “A5” and “B4.” These have no overlapping record elements. As a result, the software application  106  the cluster associated with the temporary identifier “B4” does not inherit a preexisting stable ID  316 . Instead the software application  106  assigns this cluster a new stable ID after this determination. The new stable ID is unique with respect to the preexisting stable IDs assigned to the initial set of clusters  304 . 
     Ultimately, in the example of  FIG. 7B , the software application  106  attempts to match a cluster from the initial set of clusters  304  to a cluster from the subsequent set of clusters  512 . When there is a match, the corresponding stable ID  316  is reassigned such that the cluster from the subsequent set of clusters inherits the stable ID  316  associated with the matched cluster from the initial set of clusters. Clusters that are not matched will be assigned a new stable ID that is not inherited. This is the case with the cluster represented by “B4.” 
     In various embodiments of the present disclosure, the software application  106  uses a maximum matching algorithm such as, for example, a Hungarian Algorithm, to reassign stable IDs to subsequent sets of clusters. In this case, the software application  106  seeks to maximize the total number of overlapping records. For example, assume that an initial set of clusters includes A1 and A2, where A1=[records 1, 2, 3, and 4] and A2=[record 5]. Further assume that a subsequent set of clusters includes clusters B1 and B2, where B2=[records 1 and 3] and B2=[records 3, 4, and 5]. Each of the B1 and B2 clusters have two overlapping elements with respect to the A1 cluster. If B1 is matched to A1, then B2 is matched to A2, where B2 and A2 have one overlapping record. Under this matching configuration, the total of three records overlap. If B2 is matched with A1, then B1 is matched to A2, where B1 and A2 have no overlapping records. This arrangement results in a total of two overlapping records. By applying a maximum matching algorithm, the arrangement that results in more overlapping records is selected over other arrangements. Accordingly, the B1 cluster will be assigned the stable ID associated with the A1 cluster and the B2 cluster will be assigned the stable ID associated with the A2 cluster. 
       FIG. 8  shows the outcome of the comparison and ID reassignment discussed with respect to  FIGS. 6 and 7 .  FIG. 8  shows a software application  106  that organized records  201  ( FIG. 1 ) of a database table  112  into an initial set of clusters  304  having corresponding stable IDs  316 . In response to an update to the database table  112  ( FIG. 1 ), the software application  106  reorganizes the records  201  in the updated database table  428  ( FIGS. 4A-C ) into a subsequent set of clusters  512 . After performing a comparison between the initial set of clusters  304  and the subsequent set of clusters  512  (as discussed with respect to  FIGS. 6 and 7 ), the software application  106  reassigns the stable IDs  316  associated with the initial set of clusters  304  to identically matched or similarly matched clusters existing within the subsequent set of clusters  512 . In addition, the software application  106  assigns new stable IDs to new clusters that do not sufficiently match a cluster within the initial set of clusters  304 . This results in stable IDs  808 , where at least a portion of which originated from the stable IDs  316  from the initial set of clusters  304 . 
     In various embodiments, the database table  112  is initially linked to one or more relational tables  115  ( FIG. 1 ). Those relational links are maintained after the stable IDs are initially assigned or subsequently reassigned. The use of stable IDs is advantageous in this context because the one or more relational tables  115  do not need to be rebuilt. Specifically, the underlying records are preserved such that the remaining records are linked to one or more relational tables  115 . 
       FIG. 9  is a flowchart that provides an example of the operation of the software application  106  according to various embodiments. It is understood that the flowchart of  FIG. 9  provides merely an example of the many different types of functional arrangements that may be employed to implement the operation of the portion of the software application as described herein. As an alternative, the flowchart of  FIG. 9  may be viewed as depicting an example of elements of a method implemented in the computing system  100  ( FIG. 1 ) according to one or more embodiments. 
     Beginning at  902  a software application  106  accesses one or more database tables (e.g., database table  112  of  FIG. 1 ). Here, the software application  106  identifies records  201  ( FIG. 1 ) included within a database table  112 . While two or more records may occupy separate lines within the database table  112 , it is possible that these records reflect the same real-world entity, whether it be the identity of a customer, an object, an event, or any other real-world entity. The software application  106  is configured to cluster like records, as discussed in more detail below. 
     At  905  the software application  106  organizes records  201  into clusters  304  ( FIG. 3 ) based on a similarity among the records. These clusters may be referred to as an initial set of clusters or first-generation clusters  304 . The software application  106  may use clustering techniques such as pairwise comparisons and transitive closure operations to determine whether the records  201  of a common cluster are similar. 
     When organizing the records into clusters, the software application  106  may begin by performing a blocking operation to coarsely select record pairs that share some related information and which could represent the same real-world entity. For example, a blocking function may operate to determine if two records are sufficiently similar enough that they might be classified as a related record pair. This may involve determining which field values  206  are similar or are the same. One example of a blocking function is to compare a “social security number (SSN)” field. Two records having the same SSN field values likely means that the two records form a related pair. Another example of a blocking function is to compare the first three characters of a first name field and first three characters of a last name field between two records. By performing a plurality of blocking operations, a relatively large set of records is reduced in size to include an over-inclusive set of records that are likely to be a part of a related pair. 
     The software application  106  may then identify groups of related pairs of records from within those blocks where each related pair of records has a degree of similarity that exceeds a threshold amount. Here, the software application  106  compares the different fields between two records to determine whether the two records should be deemed a match. In one embodiment, the software application  106  uses a binary classifier to evaluate whether the fields of two records are sufficiently similar. The binary classifier may be configured to operate according to a threshold amount. A lower threshold may result in more matches with a risk of error while high threshold may result in fewer matches with less risk of error. After records have been paired, the software application  106  may cluster a group of related pairs using transitive closure. Different subsets of related pairs form corresponding clusters. These clusters form an initial set of clusters  304 . 
     At  908  the software application  106  assigns identifiers to the clusters. These identifiers are referred to as stable identifiers  316  ( FIG. 3 ) because they persist through iterations of updates made to the underlying database table  112 . Stable IDs  316  may be named based on the contents of the records. For example, different field values may be concatenated to generate a stable ID that is deterministic. Here, a stable ID name of a cluster of records having a first name field value of “John” and a last name field value Doe” may be “johndoe.” 
     At  911  the software application waits for an update  402  ( FIG. 4 ) to the database. An update may include updating or modifying a preexisting record, adding a new record, or deleting a record. The software application  106  receives a notification that the database or database table  112  has been updated. 
     At  914 , in response to an updated database or database table, the software application  106  accesses the updated database table  112 . The software application  106  identifies records  201  included within the updated database table  428  ( FIG. 4 ). 
     At  917  the software application  106  organizes records  201  in the updated database table  428  into clusters  512  ( FIG. 5 ) based on a similarity among the records. These clusters may be referred to as a subsequent set of clusters or a second (or third, fourth, etc.) generation clusters. The software application  106  may use clustering techniques discussed above to generate the clusters. 
     The database  103  persistently stores the database table  112  along with the updated records after the processor organizes the updated records into the plurality of subsequent clusters. In other words, clustered records are not collapsed into a single record such that the underlying data of each record is destroyed. Thus, the flowchart of  FIG. 9  shows to be a more accurate clustering technique as records are updated. 
     At  921  the software application compares the subsequent set of clusters  512  to the initial set of clusters  304 . Stated another way, the software application compares a current generation of clusters to a prior generation of clusters. By performing the comparison, the software application  106  may identify new clusters that are within the subsequent set of clusters  512  but not within the plurality of initial clusters  304 . 
     The comparison may involve identifying exact matches of clusters between the plurality of initial clusters  304  and the plurality of subsequent clusters  512 , as shown in  FIG. 6B . The software application  106  may remove the exact matches from consideration to isolate the new clusters. 
     At  924  the software application  106  reassigns identifiers to maintain stable IDs. Specifically, the software application determines which stable IDs from a previous generation of clusters can be applied to new clusters identified in response to the comparison. To accomplish this, the software application may generate a confusion matrix  731 , as shown in  FIG. 7B . A purpose of the confusion matrix  731  is to determine strengths of similarity between at least some of the subsequent set of clusters  512  and some of the initial set of clusters  304 . A strength of similarity quantifies the degree in which two clusters within two different sets are similar. This may be calculated by determining the number, percentage, ratio, or other metric that relates to the quantity of overlapping record elements between two clusters. 
     By comparing the new clusters with respect to at least some of the prior generation clusters, the application software  106  determines which stable IDs should be inherited from the prior generation clusters. However, it may be the case that a new cluster should not inherit any of the stable IDs. In that case, a stable ID is not reassigned, but rather, a new stable ID is generated. The new stable ID may be generated based on a deterministic algorithm using the contents of the record as inputs. For example, field values may be concatenated to yield a new stable ID. 
     After stable IDs are reassigned and/or after new stable IDs are assigned, the software application  106  waits for additional updates. In the event there is an additional update, the software application  106  performs another iteration as depicted in reference numbers  914 ,  917 ,  921 , and  924 . According to various embodiments, the software application  106  determines whether a prior generation cluster is faulty, defective, or otherwise inaccurate. In this case, the software application compares one or more current generation of clusters with one or more clusters from a generation of clusters existing before the prior generation cluster. For example, third-generation clusters may be compared with first-generation clusters if updates affecting the second-generation updates are faulty, defective, or otherwise inaccurate. 
       FIG. 10  shows a schematic block diagram of the computing system  100  according to an embodiment of the present disclosure. The computing system  100  includes one or more computing devices  1000 . Each computing device  1000  includes at least one processor circuit, for example, having a processor  1003  and a memory  1006 , both of which are coupled to a local interface  1009  or bus. To this end, each computing device  1000  may comprise, for example, at least one server computer or like device. The local interface  1009  may comprise, for example, a data bus with an accompanying address/control bus or other bus structure as can be appreciated. 
     Stored in the memory  1006  are both data and several components that are executable by the processor  1003 . In particular, stored in the memory  1006  and executable by the processor  1003  is the software application  106 . Also stored in the memory  1006  may be a database  103  and other data. In addition, an operating system may be stored in the memory  1006  and executable by the processor  1003 . 
     It is understood that there may be other applications that are stored in the memory  1006  and are executable by the processor  1003  as can be appreciated. Where any component discussed herein is implemented in the form of software, any one of a number of programming languages may be employed such as, for example, C, C++, C#, Objective C, Java®, JavaScript®, Perl, PHP, Visual Basic®, Python®, Ruby, Flash®, or other programming languages. 
     Several software components are stored in the memory  1006  and are executable by the processor  1003 . In this respect, the term “executable” means a program file that is in a form that can ultimately be run by the processor  1003 . Examples of executable programs may be, for example, a compiled program that can be translated into machine code in a format that can be loaded into a random access portion of the memory  1006  and run by the processor  1003 , source code that may be expressed in proper format such as object code that is capable of being loaded into a random access portion of the memory  1006  and executed by the processor  1003 , or source code that may be interpreted by another executable program to generate instructions in a random access portion of the memory  1006  to be executed by the processor  1003 , etc. An executable program may be stored in any portion or component of the memory  1006  including, for example, random access memory (RAM), read-only memory (ROM), hard drive, solid-state drive, USB flash drive, memory card, optical disc such as compact disc (CD) or digital versatile disc (DVD), floppy disk, magnetic tape, or other memory components. 
     The memory  1006  is defined herein as including both volatile and nonvolatile memory and data storage components. Volatile components are those that do not retain data values upon loss of power. Nonvolatile components are those that retain data upon a loss of power. Thus, the memory  1006  may comprise, for example, random access memory (RAM), read-only memory (ROM), hard disk drives, solid-state drives, USB flash drives, memory cards accessed via a memory card reader, floppy disks accessed via an associated floppy disk drive, optical discs accessed via an optical disc drive, magnetic tapes accessed via an appropriate tape drive, and/or other memory components, or a combination of any two or more of these memory components. In addition, the RAM may comprise, for example, static random access memory (SRAM), dynamic random access memory (DRAM), or magnetic random access memory (MRAM) and other such devices. The ROM may comprise, for example, a programmable read-only memory (PROM), an erasable programmable read-only memory (EPROM), an electrically erasable programmable read-only memory (EEPROM), or other like memory device. 
     Also, the processor  1003  may represent multiple processors and/or multiple processor cores and the memory  1006  may represent multiple memories  1006  that operate in parallel processing circuits, respectively. In such a case, the local interface  1009  may be an appropriate network that facilitates communication between any two of the multiple processors, between any processor and any of the memories  1006 , or between any two of the memories  1006 , etc. The local interface  1009  may comprise additional systems designed to coordinate this communication, including, for example, performing load balancing. The processor  1003  may be of electrical or of some other available construction. 
     Although the software application  106  described herein may be embodied in software or code executed by general purpose hardware as discussed above, as an alternative the same may also be embodied in dedicated hardware or a combination of software/general purpose hardware and dedicated hardware. If embodied in dedicated hardware, each can be implemented as a circuit or state machine that employs any one of or a combination of a number of technologies. These technologies may include, but are not limited to, discrete logic circuits having logic gates for implementing various logic functions upon an application of one or more data signals, application specific integrated circuits (ASICs) having appropriate logic gates, field-programmable gate arrays (FPGAs), or other components, etc. Such technologies are generally well known by those skilled in the art and, consequently, are not described in detail herein. 
     The flowchart of  FIG. 9  shows the functionality and operation of an implementation of the software application  106 . If embodied in software, each box may represent a module, segment, or portion of code that comprises program instructions to implement the specified logical function(s). The program instructions may be embodied in the form of source code that comprises human-readable statements written in a programming language or machine code that comprises numerical instructions recognizable by a suitable execution system such as a processor  1003  in a computer system or other system. The machine code may be converted from the source code, etc. If embodied in hardware, each block may represent a circuit or a number of interconnected circuits to implement the specified logical function(s). 
     Although the flowchart of  FIG. 9  shows a specific order of execution, it is understood that the order of execution may differ from that which is depicted. For example, the order of execution of two or more boxes may be scrambled relative to the order shown. Also, two or more boxes shown in succession in  FIG. 9  may be executed concurrently or with partial concurrence. Further, in some embodiments, one or more of the boxes shown in  FIG. 9  may be skipped or omitted. In addition, any number of counters, state variables, warning semaphores, or messages might be added to the logical flow described herein, for purposes of enhanced utility, accounting, performance measurement, or providing troubleshooting aids, etc. It is understood that all such variations are within the scope of the present disclosure. 
     The software application  106  may also comprises software or code can be embodied in any non-transitory computer-readable medium for use by or in connection with an instruction execution system such as, for example, a processor  1003  in a computer system or other system. In this sense, the logic may comprise, for example, statements including instructions and declarations that can be fetched from the computer-readable medium and executed by the instruction execution system. In the context of the present disclosure, a “computer-readable medium” can be any medium that can contain, store, or maintain the logic or application described herein for use by or in connection with the instruction execution system. 
     The computer-readable medium can comprise any one of many physical media such as, for example, magnetic, optical, or semiconductor media. More specific examples of a suitable computer-readable medium would include, but are not limited to, magnetic tapes, magnetic floppy diskettes, magnetic hard drives, memory cards, solid-state drives, USB flash drives, or optical discs. Also, the computer-readable medium may be a random access memory (RAM) including, for example, static random access memory (SRAM) and dynamic random access memory (DRAM), or magnetic random access memory (MRAM). In addition, the computer-readable medium may be a read-only memory (ROM), a programmable read-only memory (PROM), an erasable programmable read-only memory (EPROM), an electrically erasable programmable read-only memory (EEPROM), or other type of memory device. 
     Further, any logic or application described herein, including software application  106 , may be implemented and structured in a variety of ways. For example, one or more applications described may be implemented as modules or components of a single application. Further, one or more applications described herein may be executed in shared or separate computing devices or a combination thereof. For example, the software application described herein may execute in the same computing device  1000 , or in multiple computing devices in the same computing system  100 . Additionally, it is understood that terms such as “application,” “service,” “system,” “engine,” “module,” and so on may be interchangeable and are not intended to be limiting. 
     Disjunctive language such as the phrase “at least one of X, Y, or Z,” unless specifically stated otherwise, is otherwise understood with the context as used in general to present that an item, term, etc., may be either X, Y, or Z, or any combination thereof (e.g., X, Y, and/or Z). Thus, such disjunctive language is not generally intended to, and should not, imply that certain embodiments require at least one of X, at least one of Y, or at least one of Z to each be present. 
     It should be emphasized that the above-described embodiments of the present disclosure are merely possible examples of implementations set forth for a clear understanding of the principles of the disclosure. Many variations and modifications may be made to the above-described embodiment(s) without departing substantially from the spirit and principles of the disclosure. All such modifications and variations are intended to be included herein within the scope of this disclosure and protected by the following claims.