JP3033444B2 - Database comparison method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to a database having the same key code sequence and a record sequence consisting of records corresponding to the key codes of the key code sequence.
A database comparison method for comparing the pre-update database and the post-update database to confirm the update process, for example, for a plurality of distributed databases using the same device code as a key code in a power system, After remodeling data due to expansion and renovation of
The present invention relates to a database comparison method for verifying the consistency of the processing. Also, for example, the present invention relates to a database comparison method for verifying the consistency of the processing from an old database at the time of the previous comparison and a transaction file for storing the update contents generated thereafter with respect to a database that is updated as needed. .

[0002]

2. Description of the Related Art In a database system such as an electric power system, the data of a database relating to the equipment needs to be remodeled due to the addition, modification or abolition of the equipment. At this time, the same device code is used as a key code, and data remodeling is performed simultaneously on a plurality of databases distributed to several computers. Omission of deletion and omission of record contents occurred,
There was a possibility of inconsistency between the respective databases.

FIG. 34 is a block diagram showing an example of a conventional database comparison method for checking the consistency between new and old data after such data modification of the database. In FIG. The new data section of the new database, 40 is the old data section of the old database before data modification, 70 is a comparing section for comparing these new and old data sections 10 and 40, and 110 is this comparing section 70
Is a comparison result output unit that outputs mismatched data in.

Next, the operation will be described with reference to a flowchart of a conventional database comparison method shown in FIG. First, in steps S1 and S2, the data portions 10 and 40 of the new and old databases are read, and each data portion is divided into units as shown in, for example, Japanese Patent Publication No. Sho 62-30647 (step S3). Then, the contents of the new and old database units are compared for each unit (step S4), and the mismatched portion is printed out (step S5). Such processing is performed for all databases (step S6), and the output of the contents of change of each database is manually analyzed and compared to confirm the consistency of data remodeling. As a conventional database comparison method, for example, Japanese Patent Publication No. 5-43
JP-A-140-140 and JP-A-57-31040 both disclose comparisons between two databases, and do not disclose a method for comparing new and old databases.

[0005]

Since the conventional database comparison method is configured as described above, the result of comparison between a plurality of existing and old databases is output as an enormous number of prints. Checking the consistency of the update status of the old and new databases is extremely difficult and requires a great deal of time, and there is a need to compare the old and new databases with each other and automatically determine whether the update process is normal or abnormal. Did not. In addition, for comparison between the new and old databases, it is necessary to save the old data part before data modification, and a very large storage capacity is required for storing the old database.

SUMMARY OF THE INVENTION The present invention has been made to solve the above-described problems, and has been made in consideration of the above circumstances. The aim is to get the method. It is another object of the present invention to provide a database comparison method capable of easily performing a comparison even when a plurality of databases are distributed and minimizing a storage capacity required for the comparison.

[0007]

According to a first aspect of the present invention, there is provided a database comparison method for a first database and a second database having the same key code sequence before and after updating the first database. Is compared for each key code, the difference is stored in the first storage unit, and before and after updating the second database are compared for each key code,
The difference is stored in the second storage section, the difference stored in the first and second storage sections is compared, and the content of the mismatch is output.

According to a second aspect of the present invention, there is provided a database comparison method, comprising the steps of:
Has only the key code sequence before the update as the data before the update, and compares the key code sequence before the update with the key code sequence of the first database after the update. Is stored in the first storage unit, the key code sequence before the update is compared with the key code sequence in the second database after the update, and the difference is stored in the second storage unit. It compares the differences stored in the first and second storage units and outputs the inconsistency.

According to a third aspect of the present invention, there is provided a database comparison method, wherein each key code has data indicating a point in time when a record corresponding to the key code is updated, and a key code string before update is stored for each database; When comparing with the updated key code sequence, the update time point corresponding to each key code is also compared, and the difference is stored in the storage unit.

According to a fourth aspect of the present invention, in the database comparison method, the key code sequence of the database before the update
Recorded together with the data indicating the storage time, and provided, for each key code of the updated database, data indicating the time at which the record corresponding to the key code was updated. When comparing with the key code strings of the above, the update time and the storage time corresponding to each key code are also compared, and the difference is stored in the storage unit.

According to a fifth aspect of the present invention, in the database comparison method, when comparing before and after updating each database for each key code, the difference is added, deleted,
And stored in the storage unit.

According to a sixth aspect of the present invention, there is provided the database comparison method, wherein there are three or more databases having the same key code string, and the storage unit for storing the difference between before and after update for each database is stored. On the other hand, the difference stored in each storage section is compared for each key code, and the content of the mismatch is output.

According to a seventh aspect of the present invention, there is provided a database comparison method, comprising: a transaction having a key code corresponding to an updated record, data indicating a type of the update, and data indicating a time when the update is performed. A transaction file composed of data is provided, and when storing a difference in comparing each database before and after updating for each key code in the storage unit, the difference is stored together with data indicating a time point of the above-described comparison. If the time points stored in the respective storage units are different from each other for the inconsistency content obtained by comparing the differences stored in the units, the transaction data indicating the update data of the part corresponding to the difference between the comparison points is obtained from the transaction file. By extracting and comparing with these transaction data, It is.

[0014]

According to a first aspect of the present invention, there is provided a database comparison method in which first and second databases having the same key code sequence are associated with each other for each key code. The difference obtained by comparing before and after the update of each of the key codes for each key code and the difference obtained by comparing the second database before and after the update should originally match each other. If they do not match, the contents of the mismatch are output as an update failure.

According to a second aspect of the present invention, there is provided a database comparison method comprising the steps of:
The database is associated with each database for each key code. Since the key code sequence before update is common, the common key code sequence before update and the first database after update are shared. The difference obtained by comparing the key code sequence with the key code sequence before the update and the key code sequence of the second database after the update are essentially the same. Therefore, if they do not match, it is determined that the update is defective, and the content of the mismatch is output.

According to a third aspect of the present invention, in the database comparison method, the key code sequence before update and the key code sequence after update are compared for each database, and the update time point corresponding to each key code is also determined. Then, the difference is stored in the storage unit, the difference is compared for each storage unit, and the content of the mismatch is output.

According to a fourth aspect of the present invention, in the database comparison method, the key code sequence before the update is compared with the key code sequence after the update for each database, and the key code sequence before the update is shared by the databases. The recorded save time is also compared with the updated key code update time, the difference is stored in the storage unit, and the difference is compared for each storage unit, and the content of the mismatch is output. .

In the database comparison method according to a fifth aspect of the present invention, the differences between before and after the update of each database are classified into three for each key code: addition, deletion, and change. The difference is stored in a storage unit provided corresponding to the database, these differences are compared for each storage unit, and the content of the mismatch is output.

According to a sixth aspect of the present invention, in the database comparison method, a difference between data before and after updating of each database is stored in a storage unit provided for each of three or more databases. Then, the difference stored in each storage unit is compared for each key code, and the content of the mismatch is output.

According to a seventh aspect of the present invention, there is provided a database comparing method, wherein a difference between a key code before and after each database is updated is stored for each key code, and a time when the comparison is performed is stored in each storage unit. If the execution time stored in each storage unit is different from the inconsistency content obtained by comparing the differences stored in each storage unit, the update data of the portion corresponding to the difference between the comparison times is read from the transaction file. Is extracted, and the above-mentioned mismatch contents are corrected by comparing the extracted transaction data with these transaction data.

[0021]

[Embodiment 1] FIG. 1 is a configuration diagram of a database comparison method according to a first embodiment of the present invention. In the figure, reference numeral 1 denotes a first database unit, 11 denotes an updated first database, and 21 denotes a key code of the database 11. Column, 31 is a record sequence consisting of detailed data corresponding to each key code of the key code sequence 21, 41 is the first database before update, 5
Reference numerals 1 and 61 denote key code strings and record strings of the database 41 before the update, 71 a comparison unit for comparing the first databases 11 and 41 for each key code, and 81 a comparison result storage for storing a difference between the results. Department. 2 is a second database unit, 12, 22, 32, 42, 5
Reference numerals 2, 62, 72, and 82 denote constituent elements in the second database unit 2, respectively. The last digit 2 of the code indicates the number of the database unit, and the upper digit characters are those of the first database unit. Indicates the same as the corresponding character. Or later,
When there are a plurality of database parts, the last digit of the code indicates the number of the database part. Where 1
Those having a digit of 0 indicate those that are common to a plurality of databases or exist in a single database.

Numeral 90 denotes a result comparing section for comparing the difference between the comparison result storing sections 81 and 82 of the respective database sections.
Numeral denotes a mismatch content storage unit that stores the mismatch content as a result of the result comparison unit 90, and 110 denotes an update failure output unit that outputs a database update failure based on the mismatch content.
FIGS. 2 and 3 are flowcharts illustrating the processing procedure of the database comparison method according to the first embodiment of the present invention, and FIGS. 4 and 5 are data examples for explaining the database comparison method.

Hereinafter, the first embodiment will be described with reference to FIGS.
A database comparison method will be described. First, according to the flowchart of FIG. 2, the difference between before and after updating the database is compared. FIG. 2 shows the comparison unit 71 or 72 of FIG.
When the first database unit is taken as an example, the old and new databases 11 and 41 (hereinafter, the updated database is referred to as a new database and the pre-update database is referred to as an old database) in step S101 in the figure. Key sequences 21 and 51 are compared. Steps S102 and S104 for each key code
Then, whether the corresponding key code exists in each of the new and old databases is compared. In step S103, if the key code exists only in the new database 11,
The code indicating the key code and “addition” indicating the type are stored in the comparison result storage unit 81. In step S105, if the key code exists only in the old database 41,
The code indicating the key code and “delete” indicating the type are stored in the comparison result storage unit 81. In steps S106 and S107, if the key code exists in both the new and old databases, the records 31 and 61 corresponding to the key code are compared to check whether there is any change in the record contents. S1
At 08, the code indicating the key code and “changed” indicating the type are stored in the comparison result storage unit 81. This operation is performed for all the key codes 21 and 51 of the new and old databases. The processing for the second database unit is the same as above.

Next, referring to FIG. 3, the difference between the pre-update database and the post-update database recorded in the comparison result storage units 81 and 82 is compared with the update failure output unit via the result comparison unit 90 and the mismatch content storage unit 100. The operation of outputting to 110 will be described.

In step S111 of FIG. 3, among the differences stored in the comparison result storage units 81 and 82, the key code is compared with that of the type "added" ((step S111). 1) and (2) indicate the numbers of the respective database sections. The same applies to the following.) If there is a key code whose comparison result is found only in one of them (step S112), the code indicating the key code and the defect content "additional NG""And the presence or absence of addition for each database are stored in the mismatched content storage unit 100 (step S113). Next, in step S114, a key code is compared with the difference type stored in the comparison result storage units 81 and 82, and the key code whose comparison result is in only one of them is compared. If there is (step S11
5), the code indicating the key code and the defect content "Delete N"
G ”and the presence or absence of deletion for each database are stored in the inconsistency content storage unit 100 (step S116). Further, in step S117, the type is“ changed ”among the differences stored in the comparison result storage units 81 and 82. The key code is compared with a certain one. If there is a key code in which only one of the comparison results is found (step S118),
The code indicating the key code, the defect content “change NG”, and the presence / absence of change for each database are inconsistent.
(Step S119). Finally, step S1
At 20, the inconsistent content stored in the inconsistent content storage unit 100 is output to the update failure output unit 110.

For example, in the data examples shown in FIGS. 4A to 4D, the old database 41 before the first update is (A) and the new database 11 after the update is (B) It is. If the process is performed according to the flowchart of FIG. 2, the key code (a) is stored in the comparison result storage unit 81 as the type “delete” because the key code (a) is in the old database 41 and not in the new database 11. The contents of the comparison result storage unit 81 are shown in FIG. The key code (b) is processed in the same manner and stored as the type “delete”. The key code (c) exists in both the old database 41 and the new database 11 and compares the record contents. If this content is not changed, this key code (c) is not stored in the comparison result storage unit 81. Since the key code (d) exists in the new database and does not exist in the old database 41, the key code (d) is stored in the comparison result storage unit 81 as the type “added”. The same applies to the key code (e). As for the second database, FIG.
5D, the difference is stored in the comparison result storage unit 82 in FIG.
It is stored as shown in FIG. If the processing is performed according to the flowchart of FIG. 3, by comparing the differences between the first database and the second database in FIG. 5A and FIG. 5B, FIG. Is stored in the mismatch content storage unit 100. By outputting the content of the mismatch to the update failure output unit 110, an update failure due to the data update work can be found.

As described above, according to the first embodiment, even if the contents of the databases are different, the databases are associated with each other by using a common key code for both, so that the update failure portion of the database is updated. Can be detected,
Since the detection process is simple and only the update defective portion is output, the time required for the checking operation can be greatly reduced. Furthermore, since a comparison unit and a comparison result storage unit for comparing the old and new databases are provided in each database unit, even when a plurality of databases are distributed to a plurality of computers, only the comparison results of the respective databases are provided. In this case, the update failure portion can be detected by collecting the above data, so that the amount of data transmitted between computers can be reduced, and the comparison portion between databases can be easily configured.

Embodiment 2 FIG. FIG. 6 is a configuration diagram of a database comparison method according to the second embodiment of the present invention.
1 and 42 are eliminated, and a key code sequence 60 before update common to each database unit is provided. In addition, the number of database units is not limited to two, and a case is shown in which n (n is an integer of 3 or more) database units are provided. In the case of this embodiment, it is assumed that each pre-update database is matched with each other and has the same key code sequence.

A database comparison method according to the second embodiment will be described below with reference to FIGS. First, according to the flowchart of FIG. 7, the difference between before and after updating the database is compared. FIG. 7 shows the operation of the comparison unit 71, 72 or 7n of FIG. 6. Taking the first database unit as an example, in step S201 of FIG. Compare. As in the case of the first embodiment, the presence / absence of each other's key code is compared.
, The deletion is detected as each difference, and the code indicating the key code and the type “add” or “delete” are stored in the comparison result storage unit 81. However, unlike the case of the first embodiment, comparison of records when the same key code exists cannot be performed. The same processing is performed for the second to n-th database units, and the difference between the new and old database units is compared with the comparison result storage units 82 to 8n.
To memorize.

Next, in accordance with the flowchart of FIG. 8, the difference between the pre-update and post-update databases recorded in the comparison result storage units 81 to 8n is compared by the result comparison unit 90, and the unmatched content is compared with the unmatched content storage unit. The data is output to the update failure output unit 110 via the control unit 100. In step S211, all key codes recorded in the comparison result storage units 81 to 8n are compared for each type of "addition" or "deletion". If there is any discrepancy, "additional NG" (step S21)
3) As “deletion NG” (step S216),
The code indicating the key code, the defect content, and the presence / absence of each database are stored in the mismatch content storage unit 100, and the mismatch content is finally output to the update failure output unit 110 (step 217).

For example, looking at the data examples shown in FIGS. 9A to 9D, FIG. 9A shows only the key code string extracted from the first old database before update, which is the data before update. Key code string 60. (B),
(C) and (D) are new databases 11, 12, and 1n after the first, second, and n-th updates, respectively, and (A) and (B), (A) and (C), (A), respectively. ) And (D) in accordance with the flowchart of FIG. 7 become (A), (B), and (C) of FIG.
82, 8n. Next, according to the flowchart of FIG. 8, the result of comparing (A), (B), and (C) of FIG. 10 is (D), which is stored in the mismatch content storage unit 100. In FIG. 10, for the key code (e), "addition" is common to all databases, but for the other key codes, there is a mismatch in the contents of the comparison result storage units of some databases, so that the mismatched contents are output. Have been. By outputting the content of the mismatch to the update failure output unit 110, an update failure due to the data update work can be found.

As described above, according to the second embodiment, since only the key code sequence before the update is commonly used as the database before the update in each database, the old database is used when comparing the databases. Is not required to be stored, and the storage capacity for comparison can be made very small. Further, even in the case where there are three or more databases, it is possible to detect a defective update portion of the database by associating the databases with each other using a common key code for each database.
There is an effect that the detection processing can be easily performed.

Embodiment 3 FIG. FIG. 11 is a configuration diagram of a database comparison method according to the third embodiment of the present invention. In the second embodiment, the key codes of the respective databases have update dates / times 21t and 22t indicating the point in time when the record corresponding to the key code is updated. And,
An update date and time 60t indicating the update time point is provided corresponding to the key code of the key code string 60 before update common to each database unit. Also in the third embodiment, the second embodiment
Similarly to the above, it is assumed that the databases before updating are matched with each other and have the same key code string.

The database comparison method according to the third embodiment will be described below with reference to FIGS. First, FIG.
The differences before and after updating the database are compared in accordance with the flowchart of FIG. FIG. 12 shows the comparison unit 71 of FIG.
In the first database section, the key code sequence 21 and the key code sequence 60 of the new and old databases are compared in step S301. Step 302 to step 305
Is exactly the same as in the second embodiment, the presence or absence of each other's key code is compared, the addition is detected in S303, and the deletion is detected in S305 as the respective differences, and the code indicating the key code and the type “add” are detected. Alternatively, “delete” is stored in the comparison result storage unit 81. However, unlike the case of the second embodiment, when the same key code exists, the update date and time 21t and 60t of the key code are compared in step S306, and
If the update date and time are different, the code indicating the key code and the type “changed” are stored in the comparison result storage unit 81 (step S308). The processing for the second database unit is the same as above.

Next, in accordance with the flowchart of FIG. 13, the difference between the pre-update and post-update databases recorded in the comparison result storage units 81 and 82 is compared by the result comparison unit 90, and the unmatched content is compared with the unmatched content storage unit. The data is output to the update failure output unit 110 via the control unit 100. Step S31
1, S314 or S317, the comparison result storage unit 81
All the key codes recorded in and 82 are compared for each type of "addition", "deletion" or "changed", and if there is a discrepancy between them, "additional NG" (step S31)
3) As "deletion NG" (step S316) or "change NG" (step S319), the code indicating the key code, the defect content, and the presence / absence of each database are stored in the non-coincidence content storage unit 100. The inconsistency is output to the update failure output unit 110 (step S32).
0).

For example, in the data example shown in (A1), (B) and (C) of FIG. 14, (A1) extracts only the key code string and the update date and time from the first old database before update. This is the key code sequence 60 before the update.
And the update date and time 60t. (B) and (C) are new databases 11 and 12 after the first and second updates, respectively. (A1) and (B), and (A1) and (C) are respectively shown in accordance with the flowchart of FIG. FIG. 15 shows the comparison result.
(A) and (B) are stored in the comparison result storage units 81 and 82. Next, according to the flowchart of FIG.
The result of comparing (A) and (B) in FIG. 15 is (C), which is stored in the mismatch content storage unit 100. By outputting the content of the mismatch to the update failure output unit 110, an update failure due to the data update work can be found.

As shown in (A2) of FIG. 14, only the key code sequence is extracted from the first old database before updating, and the storage date and time indicating the extracted time is recorded together with the key code sequence 60. And the storage date and time 60t. In this case, in the flowchart of FIG. 12, when comparing the update date and time in step S307, the storage date and time 60t of the old database is compared with the update date and time 21t of the corresponding key code, and if the update date and time 21t is newer, "
If "changed", the same processing can be performed.

As described above, according to the third embodiment, as the pre-update database, only the key code sequence before the update and the update date and time are subject to comparison in common in each database. There is no need to keep the old database as it is, and the storage capacity for comparison can be made very small. Further, as compared with the case of the second embodiment using only the key code sequence before the update, there is an effect that the consistency can be detected even for the record whose contents are changed.

Previous Example 1 As described in the first to third embodiments, the method of comparing the database before update and the database after update for each key code and checking the consistency of the update process is based on the data updated by the update process. it is also possible to apply to a single database to generate a transaction file, examples of which are illustrated in the preceding example 1.

FIG. 16 is a block diagram of a database comparison method showing the first embodiment of the present invention.
Is a new database after the update, 20 is a key code sequence of the database 10, 30 is a record sequence including detailed data corresponding to each key code of the key code sequence 20,
40 is the old database at the time of the previous comparison, 50 and 60 are the key code strings and record strings of the old database 40, 70 is a comparing unit that compares the databases 10 and 40 for each key code, and 80 is the difference between the results. A comparison result storage unit 120 is a transaction file storing transaction data including a key code, an update date and time, an update type, and a record each time an update is performed on the database. The comparison target key code extraction unit 140 extracts only the key code and the update type of the update data corresponding to the time from the previous comparison time point when the data 40 is stored to the present time, and a comparison target key code storage unit 140 that stores the comparison target key code. Is the key code storage unit 140 for comparison. A result comparison unit that compares the difference between the new data and the old and new databases stored in the comparison result storage unit 80, 100 is a mismatch content storage unit that stores the mismatch content as a result of the result comparison unit 90, and 110 is the mismatch content. An update failure output section that outputs a database update failure based on the update failure.

[0041] Hereinafter, according to FIGS. 17 to 21, this prior
The database comparison method of Example 1 will be described. First, FIG.
According to the flowchart of FIG. 7, the differences between the database before and after the update are compared with respect to the key code selected by the comparison target key code extraction unit 130 from the transaction file 120. FIG. 17 shows the operation of the comparison target key code extraction unit 130 and the comparison unit 70 of FIG. 16, and in steps S401 and S402 of FIG.
(A) Extracts only the transaction data whose update date and time is newer than the previous comparison date and time from the transaction file 120 including the data as shown in (A), and stores the code indicating the key code, the update type, and the Is stored. In step S403, the key codes of the selected transaction data are compared with each other between the updated new database 10 and the old database 40 for the presence or absence of the key codes, and addition is performed in S405 and deletion is performed in S407. Detect each difference,
The code indicating the key code and the type “add” or “delete” are stored in the comparison result storage unit 80. If the same key code exists, the records 30 and 50 corresponding to the key code are compared in step S408, and if the content is changed, the type “changed” is stored in the comparison result storage unit 80 in step S410. (Step S410). The above processing is performed for all data in the transaction file 120, and after the end, the previous comparison date and time of the transaction file 120 is updated in step S412.

Next, according to the flowchart of FIG. 18, the difference between the new and old databases stored in the comparison result storage unit 80 and the data recorded in the comparison target key code storage unit 140 extracted from the transaction file 120 are compared. The difference is compared by the unit 90, and the mismatch content is output to the update failure output unit 110 via the mismatch content storage unit 100. That is, in step S421 in FIG. 18, the key code stored in the comparison result storage unit 80 whose type is "added" is compared with the key code stored in the comparison target key code storage unit 140. For example, as "additional NG", the code indicating the key code and the defect content are stored in the mismatch content storage unit 100 (step S423). Similarly, the type “delete” is compared in step S424. If there is a mismatch, the type is “deleted NG” (step S426). If the type is “changed” in step S427, the type is “change NG”. (Step S429),
The code indicating the key code and the defect content are stored in the mismatch content storage unit 100. Finally, in step S430,
This mismatch content is output to the update failure output unit 110.

For example, in FIG. 19, (A) shows an example of the transaction file 120, and the comparison target keyboard 130 extracts the comparison target key code and stores it in the comparison target key code storage unit 140 according to the flowchart of FIG. An example is (B). At the beginning of the transaction file 120, as shown in (A), the comparison date and time when the database was compared last time is stored. In this example, the update date and time of the key code (f) is older than the comparison date and time. The key codes (b) and below are comparison targets.

FIGS. 20A and 20B show the old database 40 at the time of the previous comparison and the new database 10 after the update, respectively. These databases are compared by the comparing unit 70 according to the flowchart of FIG. The result of the comparison is shown in FIG. Furthermore, this result and FIG.
The key code is compared with the comparison target key code shown in FIG. 9B according to the flowchart of FIG.

As described above, according to the preceding example 1 , the update result of only the updated portion is compared and confirmed with reference to the transaction file.
This has the effect of significantly reducing the time required for the comparison process.

Embodiment 4 FIG. In the first to third embodiments, for a plurality of databases for which data remodeling is performed at the same time, a database before update and a database after update are provided for each key code. A method of comparing and checking the consistency of the update processing between a plurality of databases has been described. In the fourth embodiment , the old database and the update contents at the time of the last comparison are compared with the plurality of databases that perform the update processing as needed. It shows a database comparison method for verifying the consistency of the processing from the stored transaction file. In the fourth embodiment , it is assumed that there are a plurality of databases having the same key code, and that the update of each database is simultaneously reflected in all the databases.

FIG. 22 is a configuration diagram of a database comparison method showing a fourth embodiment of the present invention. When a transaction file is provided in the database of the first embodiment and each database is checked for consistency, the respective databases are compared. Are modified by using a transaction file. Further, unlike the first to third embodiments, an example is shown in which each database unit and result comparison unit are provided in separate computers.

In the figure, 1 is a first database unit provided in the computer (1), 2 is a second database unit provided in the computer (2), and 3 is provided in the computer (3). Database comparison unit, comparison result storage units 81 and 8
2 is the comparison date and time 81a, 82a and the comparison result 81, respectively.
b, 82b, 150 is a difference storage unit that stores the differences between the comparison result storage units 81 and 82 that are compared by the result comparison unit 90, and 160 is a difference confirmation unit that compares this difference with the transaction file 122. The other reference numerals are the same as or equivalent to those of the first embodiment.

Hereinafter, this embodiment will be described with reference to FIGS.
The database comparison method of Example 4 will be described. First, FIG.
The differences between the old database at the time of the previous comparison and the new database at the current time are compared according to the flowchart of FIG. FIG. 23 shows the operation of the comparison unit 71 or 72 of FIG. 22. The first database unit will be described as an example. In step S501, the key code sequence 21 and the key code sequence 61 of the new and old databases are compared. I do.
As in the case of the first embodiment, the presence / absence of each other's key code is compared, the addition is detected in S503, and the deletion is detected as a difference in S505, and the code indicating the key code and the type “add” or “delete” are detected. Is stored in the comparison result storage unit 81. If the same key code exists in both the new and old databases, the records 31 and 51 are compared (step S506).
The code indicating the key code and the type “changed” are stored in the comparison result storage unit 81. Further, after comparing all key codes, the time at this time is stored in the comparison result storage unit 81 as the comparison date and time 81a. The same processing is performed for the second database unit, and the difference between the new and old databases is stored in the comparison result storage unit 82.

Next, according to the flowchart of FIG. 24, the difference between the pre-update and post-update databases recorded in the comparison result storage units 81 and 82 is compared by the result comparison unit 90, and the inconsistent content is compared with the difference storage unit. 150.
In step S511, the comparison result storage units 81 and 82
Are compared for each type of "addition", "deletion" and "changed". If there is any discrepancy, "additional NG" (step S513), "deletion NG" ( As step S516) or “change NG” (step S519), the code indicating the key code, the inconsistent content, and the presence / absence of each database are stored in the difference storage unit 150 (step S520). At this time, the comparison dates and times 81a and 82a of the respective databases are also stored in the difference storage unit 150 in step S521.

Further, the contents stored in the difference storage unit 150 and the transaction file 122 are compared in accordance with the flowchart of FIG. First, step S531
Then, the comparison date and time 81a and 82 of each database
a, and if the comparison date and time match, step S
At 533, all NG information is stored in the mismatch content storage unit 100, and at step S540, the mismatch content is output to the update failure output unit 110. If there is a difference in the comparison date and time in step S532, the difference storage unit 1 is determined in step S534.
The storage contents of the transaction file 122 and the contents of the transaction file 122 are compared for each key code. The update date and time of the transaction data is between the differences of the comparison date and time (step S5
35) If the type of the mismatched content stored in the difference storage unit 150 is the same (step S537), the mismatched content is not stored as the mismatched content due to the difference in the comparison time point, and is not stored as the defective content. Only in the case of NG, the NG information is stored in the mismatch content storage unit 100 in steps S536 and S538. After comparing all the key codes, finally, in step S540, the update failure output unit 11
Outputs non-matching contents to 0.

For example, referring to the data examples of FIGS. 26 and 27, the old and new databases ((B) and (A) of FIG. 26) of the first database unit and the old and new databases (FIG. 26 of FIG. 26) of the second database unit (D) and (C) are compared by the comparison units 71 and 72, respectively. The contents of the comparison result storage units 81 and 82 are as shown in FIGS. 27A and 27B. FIG. 27C shows the result of extracting the differences. When this result is processed in accordance with the flowchart of FIG. 25 according to (E) of FIG. 26 showing a data example of the transaction file 122 of the second database, the deletion NG of the key code (b) is between the difference between the comparison date and time. Since the type of the unmatched content is the same, this is not stored, and as a result, the fault content shown in FIG. 27D is obtained.

As described above, according to the fourth embodiment , the transaction file is used for confirming the comparison result with respect to a plurality of databases for which the update process is performed at any time, so that even if the comparison timing is different, the update failure occurs. There is an effect that a part can be detected. Further, in this embodiment, the case where the transaction file is placed in the second database unit has been described. However, if a similar transaction file is provided in the first database unit, the same operation can be performed without being aware of the order of comparison. Detection of a defective update portion.

Embodiment 5 FIG. The fifth embodiment shows an embodiment of a transaction file data compression method for efficiently holding the transaction file shown in the first and fourth embodiments .

FIG. 28 is a diagram showing the configuration of a method of compressing a transaction file according to the fifth embodiment . In FIG. 28, reference numeral 120 denotes a transaction file before compression, 120a, 120b, 120c and 120d.
Are the components of the transaction file 120, and are provided for each transaction data indicating the update content of each database update. The key code, the update date and time, the update type and the record indicating the update content of the database are respectively 170. A compressible period input unit 180 for inputting a compressible period of the transaction file, 180 extracts data having a compressible update date and time 120b from the transaction file 120 and deletes data having a plurality of updates for the same key code. A comparison unit 200 stores the key code storage unit 190, and a compression unit 200 compresses the transaction file 120 based on the data stored in the key code storage unit 190.

Next, this embodiment will be described with reference to FIGS.
A method of compressing the transaction file of Example 5 will be described. First, the compressible date and time are input from the compressible period input unit 170 according to the flowchart of FIG. 29 (step S601). The transaction data corresponding to this period is extracted from the transaction file 120 in step S602 with reference to the update date and time 120b, and the key code, the update type, and the data NO (serial number) of the transaction data are arranged for each same key code. To the key code storage unit 190 (step S6).
03). Next, from the stored data, only those having a plurality of updates for the same key code are left, and others are deleted (step S606).

From the data stored in the key code storage section 190, the data of the transaction file 120 is compressed according to the flowchart of FIG. In step S611, the data stored in the key code storage unit 190 is read for each key code, and if there is a deletion in the update type (step S612), the transaction data with the update type of the key code "change" is read from the transaction file. It is deleted (step S613).
If "update" is included in the update type and "delete" is not included (step S614), steps S615 and S61 are performed.
At step 6, the contents of the "change" record are written to the "add" record, and the "change" transaction data is deleted. Further, for the update type having only "change", only the last "change" transaction data is left, and the others are deleted (step S618). In this way, the transaction data to be deleted is extracted from the transaction file, and the free data is compressed (step S620).

For example, taking the transaction file shown in FIG. 31A as an example, to explain, only the compressible transaction data is extracted at the compressible date and time shown in FIG. FIG. 32 (A) shows an example of data arranged for each, and FIG. 32 (B) shows an example of data obtained by extracting only data obtained by performing a plurality of update processes on the same key code.
According to the flowchart of FIG.
FIG. 33 is a table showing the result of the processing, and the result of finally compressing the transaction file is as shown in FIG.

[0059] As described above, according to this embodiment, the prior
The transaction file shown in Example 1 and Example 4 can be compressed and stored, and the storage capacity for the transaction file can be reduced.

[0060]

Since the present invention is configured as described above, it has the following effects.

In the database comparison method according to the first aspect of the present invention, even if the contents of the databases are different, the databases are associated with each other using a common key code to detect a defective update portion of the database. Can be performed, the detection process is simple, and only the defective update portion is output without manual intervention, so that the time required for the checking operation can be greatly reduced.

In the database comparison method according to the second aspect of the present invention, since only the key code sequence before update is commonly used as the database before update for each database, the old database is retained when the databases are compared. There is no need to keep this, and the storage capacity for comparison can be made very small. In addition, even if the contents of the databases are different, it is possible to detect a defective update portion of the database by associating the databases with each other using a common key code, so that the detection process is simple, Because only the defective update portion is output without going through the process, there is an effect that the time for the checking operation can be greatly reduced.

In the database comparison method according to the third aspect of the present invention, since only the key code string before update and the update date and time are to be compared in common as the database before update in each database, when comparing the databases,
There is no need to keep the old database as it is, and the storage capacity for comparison can be made very small. In addition, as compared with the case where only the key code sequence before the update is used, there is an effect that the consistency can be detected even for the record whose contents are changed. Further, even if the contents of the databases are different, the database can be associated with each other using the common key code to detect the defective update portion of the database, so that the detection process is simple, and Because only the defective update portion is output without going through the process, there is an effect that the time for the checking operation can be greatly reduced.

According to a fourth aspect of the present invention, in the database comparison method, only the key code sequence before the update and the storage date and time when the key code sequence was stored are compared as the databases before the update. Therefore, when comparing databases, it is not necessary to keep the old database as it is, and the storage capacity for comparison can be made very small. In addition, as compared with the case where only the key code sequence before the update is used, there is an effect that the consistency can be detected even for the record whose contents are changed. Further, even if the contents of the databases are different, the database can be associated with each other using the common key code to detect the defective update portion of the database, so that the detection process is simple, and Because only the defective update portion is output without going through the process, there is an effect that the time for the checking operation can be greatly reduced.

According to a fifth aspect of the present invention, in the database comparison method, before and after the database is updated are classified into three types of update, namely, addition, deletion, and change for each key code, and are compared. Therefore, even if the contents of the databases are different, there is an effect that the association between the databases can be easily performed by using a common key code for both.

According to a sixth aspect of the present invention, in the database comparison method, even when there are three or more databases, the databases are associated with each other by using a common key code for each database, and the database update failure portion is determined. Can be detected, so that the detection processing can be easily performed.

The database comparison method according to claim 7 of the present invention has an effect that, by using a transaction file for checking the comparison result, an update defective portion can be detected even when the comparison timing is different.

[Brief description of the drawings]

FIG. 1 is a configuration diagram illustrating a database comparison method according to a first embodiment of the present invention.

FIG. 2 is a flowchart illustrating a processing procedure for comparing a new and old database in the database comparison method according to the first embodiment of the present invention.

FIG. 3 is a flowchart illustrating a processing procedure for detecting and outputting update failure contents of a database in the database comparison method according to the first embodiment of the present invention.

FIG. 4 is a diagram illustrating a data example of a database for explaining a database comparison method according to the first embodiment of the present invention.

FIG. 5 is a diagram illustrating a data example of a database comparison result for explaining a database comparison method according to the first embodiment of the present invention.

FIG. 6 is a configuration diagram illustrating a database comparison method according to a second embodiment of the present invention.

FIG. 7 is a flowchart showing a processing procedure for comparing a new and old database in the database comparison method according to the second embodiment of the present invention.

FIG. 8 is a flowchart illustrating a processing procedure for detecting and outputting update failure contents of a database in the database comparison method according to the second embodiment of the present invention.

FIG. 9 is a diagram illustrating a data example of a database for explaining a database comparison method according to the second embodiment of the present invention.

FIG. 10 is a diagram illustrating a data example of a database comparison result for explaining a database comparison method according to the second embodiment of the present invention.

FIG. 11 is a configuration diagram illustrating a database comparison method according to a third embodiment of the present invention.

FIG. 12 is a flowchart illustrating a processing procedure for comparing a new database with an old database in the database comparison method according to the third embodiment of the present invention.

FIG. 13 is a flowchart showing a processing procedure for detecting and outputting update failure contents of a database in the database comparison method according to the third embodiment of the present invention.

FIG. 14 is a diagram illustrating a data example of a database for explaining a database comparison method according to the third embodiment of the present invention.

FIG. 15 is a diagram illustrating a data example of a database comparison result illustrating a database comparison method according to the third embodiment of the present invention.

FIG. 16 is a configuration diagram showing a database comparison method of the first prior art.

FIG. 17 is a flowchart illustrating a processing procedure for comparing a new database with an old database in the database comparison method of the first example .

FIG. 18 is a flowchart illustrating a processing procedure for detecting and outputting update content of a database in the database comparison method of the first prior art;

FIG. 19 is a diagram showing an example of data of a transaction file for explaining the database comparison method of the first example.

20 is a diagram illustrating a data example of a database that describes the database comparison method of the preceding Example 1.

21 is a diagram illustrating a data example of a database comparison results illustrating the database comparison method of the preceding Example 1.

FIG. 22 is a configuration diagram illustrating a database comparison method according to a fourth embodiment of the present invention.

FIG. 23 is a flowchart showing a processing procedure for comparing a new database with an old database in the database comparison method according to the fourth embodiment of the present invention.

FIG. 24 is a flowchart showing a processing procedure for detecting non-coincidence contents of a database in the database comparison method according to the fourth embodiment of the present invention.

FIG. 25 is a flowchart showing a processing procedure for detecting and outputting the contents of a database update failure in the database comparison method according to the fourth embodiment of the present invention.

FIG. 26 is a diagram illustrating a data example of a database for explaining a database comparison method according to the fourth embodiment of the present invention.

FIG. 27 is a diagram illustrating a data example of a database comparison result illustrating a database comparison method according to the fourth embodiment of the present invention.

FIG. 28 is a configuration diagram showing a method of compressing a transaction file according to Embodiment 5 of the present invention.

FIG. 29 is a flowchart showing a processing procedure up to key code storage in the transaction file compression method according to the fifth embodiment of the present invention.

FIG. 30 is a flowchart illustrating a compression processing procedure of a transaction file compression method according to Embodiment 5 of the present invention.

FIG. 31 is a diagram illustrating a data example of a transaction file for explaining a transaction file compression method according to a fifth embodiment of the present invention.

FIG. 32 is a diagram illustrating an example of data for explaining processing of a transaction file compression method according to a fifth embodiment of the present invention.

FIG. 33 is a diagram showing an example of data for explaining a process based on a combination of update types of a transaction file compression method according to the fifth embodiment of the present invention.

FIG. 34 is a configuration diagram of a conventional database comparison method.

FIG. 35 is a flowchart illustrating a processing procedure of a conventional database comparison method.

[Explanation of symbols]

11 first database after update 21 key code sequence of first database after update 31 record sequence of first database after update 41 first database before update 51 key code of first database before update Column 61 Record column of first database before update 81 Comparison result storage section 81a before and after update of first database 81a Date and time of comparison between before update and after update of first database 81b Date of first database Comparison result between before and after the update 12 Second database after the update 22 Key code column of the second database after the update 32 Record column of the second database after the update 42 Second database 52 before the update 52 Update Key code column 62 of the second database before update Record column of the second database before update 82 Second database Comparison result storage section 82a between before and after update of database 82a Comparison date and time between before and after update of second database 82b Comparison result between before and after update of second database 60 Key code string of old database 60t Update date and time of old database record 90 Result comparison unit 100 Mismatch content storage unit 110 Update failure output unit 120 Transaction file

────────────────────────────────────────────────── ─── Continuation of the front page (56) References JP-A-4-172543 (JP, A) JP-A-6-195251 (JP, A) (58) Fields investigated (Int. Cl. ⁷ , DB name) G06F 12/00

Claims (7)

(57) [Claims] 1. A first database having a key code sequence and a record sequence consisting of records corresponding to each key code of the key code sequence, and a first database provided separately from the first database, In a database comparison method for confirming data update contents, a second database having a key code string having the same contents and a record string composed of records corresponding to each key code of the key code string is used. The pre-update and post-update are compared for each key code, the difference is stored in the first storage unit, the pre-update and post-update of the second database are compared for each key code, and the difference is determined. A database ratio stored in a second storage unit, comparing the differences stored in the first and second storage units, and outputting the inconsistent content. Comparison method. 2. A first database having a key code sequence and a record sequence consisting of records corresponding to each key code of the key code sequence, and a first database provided separately from the first database. In a database comparison method for confirming data update contents, a key code before updating is performed for a second database having a key code string having the same contents and a record string including records corresponding to the respective key codes of the key code string. The column and the updated key code sequence of the first database are compared, the difference is stored in the first storage unit, and the key code sequence before the update and the key of the second database after the update are compared. The difference is compared with the code string, and the difference is stored in the second storage unit.
And comparing the differences stored in the second storage unit and outputting the content of the mismatch. 3. A method according to claim 1, wherein data indicating a time point at which a record corresponding to the key code is updated is provided for each key code, and a key code sequence before update is compared with a key code sequence after update for each database. 3. The database comparison method according to claim 2, further comprising comparing update times corresponding to the respective key codes, and storing the differences in a storage unit. 4. A key code sequence of a database before update is recorded together with data indicating a storage time, and for each key code of the database after update, data indicating a time when a record corresponding to the key code is updated is stored. Provided, when comparing the key code string before the update for each database, and the key code string after the update, also compare the update time point and the storage time point corresponding to each key code,
3. The database comparison method according to claim 2, wherein the difference is stored in a storage unit. 5. Before and after updating each database,
5. The method according to claim 1, wherein, when comparing each key code, the difference is classified into three types, that is, added, deleted, and changed, and stored in the storage unit. Database comparison method. 6. There are three or more databases having the same key code sequence, and the difference stored in each storage unit is different from the storage unit storing the difference between before and after update compared for each database. Are compared for each key code, and the content of each mismatch is output.
A database comparison method according to claim 5. 7. A key code corresponding to a record updated in a database, data indicating a type of the update,
When a transaction file including transaction data having the data indicating the time point of this update is provided, and the difference between each key code before and after each database is compared for each key code is stored in the storage unit, Stored together with the data indicating the time point of the comparison, and if the time points stored in the respective storage units are different for the inconsistency content comparing the differences stored in the respective storage units, the transaction file 7. The method according to claim 1, wherein transaction data indicating update data of a portion corresponding to the difference is extracted, and the contents of the mismatch are corrected by comparing the extracted transaction data with the transaction data. Database comparison method.