JP5412995B2 - Database control apparatus, database control method, and database control program in program model checking - Google Patents

Description

  The present invention relates to a backtrack technique used when controlling a database (hereinafter referred to as DB) used in an execution environment in program model checking.

  When performing a program model check, there is data recorded in the DB as one of the elements constituting each state in the program path of the check target program. In the program model check, the state of the DB data does not change when only searching or referencing the DB record, but the state of the DB changes when creating, updating, or deleting. In the example shown in A of FIG. 10, the DB data is inserted (Insert) in the path from state A to state B, and the deletion (Delete) is performed in the path from state B to state C. Next, in order to execute a path from state B to state D in the program model check, an execution environment including DB data is returned from state C to state B, and then the path to state D is executed. Backtracking is required when returning the execution environment from state C to state B. That is, backtracking is performed for all elements constituting each state in the program path, but it is also necessary to perform it for DB data.

There are two methods for realizing the backtracking of DB data: a method using a DB stub and a method of rewriting contents by connecting to an actual DB.
When a DB stub is used, a DB data file is prepared in advance and a DB data image in each state phase is held. At the time of backtracking, it is held as an internal variable of the stub program, and the state is restored by utilizing a mechanism for returning the internal variable of the program of the program model checking tool. For this purpose, it is necessary to prepare a stub that imitates the behavior of a DBMS (Data Base Management System), but there is a problem that much work time is required to create a stub having a DBMS function. In addition, since a stub created for each DBMS used for each program model checking target system changes, there is also a problem that the system target must be changed to use the stub. Furthermore, since there are different parts for each DBMS (for example, different data types, different grammars for each DBMS), if one stub mechanism is created, it cannot be used in other systems.

Therefore, a proposal has been made to rewrite the contents of a DB by connecting to an actual DB without using a DB stub.
For example, another read-only point-in-time database called a database snapshot is prepared, and only the modification of the original database is copied to the storage, and the point-in-time view is retained. A technique is known in which when a user error occurs and data restoration is required, the latest snapshot is restored by copying the latest snapshot. However, when backtracking is performed on a DB, the number of snapshots that must be managed is not limited to the most recent one, but backtracking must be performed for each state by going back to the root of the state tree. Therefore, the number of snapshots can be very large depending on the program.

  Therefore, the following techniques have been proposed. For example, a method for restoring DB data using an SQL (Structured Query Language) log is known. However, it is not possible to easily solve what kind of SQL statement should be issued in order to return to a DB in a specific state as in the program model check.

Special Table 2007-524173 JP 2006-244394 A JP 2004-348701 A Japanese Unexamined Patent Publication No. 7-160563 JP 2000-10836 A

  A database control apparatus, a database control method, and a database control which are made in view of the above circumstances and perform efficient backtracking to restore a DB data used in an execution environment in a program model check to a state where it is desired to be restored The purpose is to provide a program.

  A database control apparatus that controls a database used in an execution environment when a program model checking apparatus, which is one aspect, performs a program model checking, includes a recording unit and a backtrack management unit.

  When the recording unit receives a state change notification having a node ID, which is an identification number for identifying the state after the change of the database, from the program model checking device, the recording unit associates with the node ID and moves to the state after the change. Record path information indicating the transition path and log information that is a code for controlling the database output from the program model checking device during the transition from the state before the change to the state after the change in the state tree management table To do.

  When receiving a backtrack start notification having a restoration destination node ID that is an identification number indicating a return destination state from the program model checking device, the backtrack management unit associates the state tree management with the restoration destination node ID. Based on the path information and log information recorded in the table, a backtrack code for returning the database to the state indicated by the restoration destination node ID is generated.

  Efficient backtracking can be performed to return the DB data used in the execution environment to a state in which it is desired to be restored in the program model check.

It is a block diagram which shows the structure of the apparatus of the system which performs a program model check. It is a block diagram which shows the structure of a program model inspection apparatus. A is a figure which shows the SQL sentence issued from the program model checker. B is a diagram showing a code that associates an SQL sentence with a node. It is a figure which shows the example of the state of a database. It is a flowchart which shows the exchange of a program model test | inspection. It is a flowchart which shows the exchange of a program model test | inspection. It is a flowchart which shows operation | movement of DB data management part. A to E are diagrams showing state tree management tables. It is a flowchart which shows operation | movement of a backtrack management part. It is a figure which shows the structure in a case where a present Example is implement | achieved as a computer program. AC is a figure which shows the example of the state of a database.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
The present embodiment shows an efficient method for returning DB data to a state to be restored when backtracking occurs after creation, update, deletion, etc. for the DB record.

(Constitution)
FIG. 1 is a diagram showing a configuration of a system that performs program model checking, including a database control device 2 that executes backtracking that returns DB data used in an execution environment in program model checking to an arbitrary state. This system for performing program model checking includes a program model checking device 1 and a database control device 2.

  For example, as shown in FIG. 2, the program model checking apparatus 1 includes a driver 21 that is a model checking environment for the inspection target program 22, a DBMS 11 (database management system) that is actually used when the inspection target program 22 is executed. I have. The program model checking apparatus 1 records the state at that time whenever a branch condition in the program (creation, update, deletion, etc. with respect to a DB record in addition to a change in data held by the check target program 22) appears. Note that the program model checking apparatus 1 may also include a DB stub, a network stub, etc. (not shown).

  The driver 21 inputs input data 23 imitating a user operation to the inspection target program 22 instead of a client (for example, a verification performer). Then, the program model checking device 1 continuously calls the program to be checked 22 with various variations, and checks whether the functional specifications stored in the property 24 are satisfied.

As described above, the program model checking apparatus 1 performs a comprehensive check on the DBMS 11 and the DB stub 23 that exchange data with the check target program 22.
The database control device 2 includes a DB data management unit 3, a code storage unit 5 (DB driver addition module 4), and the like.

  The DB driver addition module 4 includes a code storage unit 5 and stores a code (for example, an SQL statement) issued from a DB driver (for example, JDBC (Java Data Base Connectivity)) included in the normal DB database in the log file 6. (A in FIG. 3). Although SQL is used in this example, the language is not limited to SQL as long as it is a language for operating a relational database. Since the DBMS 11 used by the inspection target program 22 has a function of storing log files, in that case, the function may be used instead of the code storage unit 5.

  The state tree management unit 7 manages information equivalent to the state tree of the program model checking device 1 in order to grasp the path for returning to each state. Further, the state tree management unit 7 receives from the program model checking apparatus 1 a state change notification having a branch of the program path and a node ID (identification number) indicating a new state of the program. Then, the node ID corresponding to the new state is associated with the path between the previous state and the new state and recorded in a state tree management table described later.

  When the log file management unit 8 receives the state change notification from the program model checking device 1, the log file management unit 8 reads the SQL log file 6 and acquires and manages the SQL statement issued between the state transitions whenever the path state changes. The log file management unit 8 reads the log file 6, extracts a code (for example, an SQL statement) from the last issued status change notification to receiving the current status change notification, and associates it with the node ID (B in FIG. 3). For example, in the case of a path transitioning from state 1 to state 2 shown in FIG. 4, all SQL statements issued during the period from state 1 to state 2 are recorded in association with the node ID corresponding to state 2. If the path is a transition from state 2 to state 3, all the SQL statements issued during the period from state 2 to state 3 are recorded in association with the node ID corresponding to state 3. The numbers assigned to the respective states in FIG. 4 are associated with the order in which the program model checking apparatus 1 performs the program model checking.

When the backtrack management unit 9 receives the notification of executing the backtrack from the program model checking device 1, the backtrack management unit 9 creates a DB control code (for example, an SQL statement) for returning the DBMS 11 to the initial state and setting it to a target state ( Details will be described later).
The DB control code issuing unit 10 issues the DB control code created by the backtrack management unit 9 to the DBMS 11.

(Description of operation)
FIG. 5 is a flowchart for explaining the operations of the program model checking apparatus 1, the DB data management unit 3, the code storage unit 5, the inspection target program 22, and the DBMS 11.

  In step S <b> 1, the DB data management unit 3 transmits an inspection start notification having a code for setting the DB to an initial state to the DBMS 11. For example, an SQL statement for initializing the DB is output via the DB driver addition module 4.

In step S2, the DBMS 11 receives a code for setting the initial state. In step S3, the DBMS 11 initializes the DB.
In step S4, the program model checking apparatus 1 starts program model checking.

In step S5, the program model checking device 1 starts outputting the code to the code storage unit 5 and the DBMS 11 (see A in FIG. 3).
In step S6, the code storage unit 5 records the code in the log file 6. In step S7, the DBMS 11 receives the code.

In step S8, the log file management unit 8 starts reading the log file 6.
In step S9, the program model checking device 1 determines a change in the state of the DB. For example, the program model checking device 1 detects an insert, an update, a delete, etc., which become branch conditions described in an SQL statement.

In step S10, the program model checking apparatus 1 transmits to the DB data management unit 3 a state change notification to be described later with respect to the state change detected in step S9.
In step S11, the DB data management unit 3 receives a state change notification. The DB data management unit 3 detects that the state of the DB has changed based on the state change notification.

In step S <b> 12, the DB data management unit 3 reads a code from the code storage unit 5.
In step S13, the DB data management unit 3 associates the code acquired from the code storage unit 5 with the state (details will be described later).

In normal times, the processes shown in steps S4 to S13 are repeatedly executed, and when backtracking is performed, the process proceeds to step S15.
In step S14, it is determined whether or not the program model checking apparatus 1 performs backtracking. If backtracking is performed, the process proceeds to step S15. For example, the program model checking device 1 detects that the state does not change any more due to the existing function. Note that when executing backtracking, the program model checking apparatus 1 interrupts the program model checking. Then, when it is detected that the backtrack process is completed, the program model check is resumed. For example, switching synchronization between the program model checking device 1 and the database control device 2 is established by using JPF (Java Pathfinder) or the like.

In step S <b> 15, the program model checking device 1 transmits a backtrack start notification described later to the DB data management unit 3.
In step S16, the DB data management unit 3 receives a backtrack start notification.

In step S17, the DB data management unit 3 executes backtrack processing (details will be described later).
In step S <b> 18, the DB data management unit 3 transmits a code for initializing the DB of the DBMS 11 to the DBMS 11 via the DB driver addition module 4.

In step S19, the DBMS 11 receives a code for setting the initial state, and in step S20, the DBMS 11 sets the DB to the initial state.
In step S21, a code generated based on information (restoration destination node ID) for rolling back the DBMS 11 indicated in the backtrack start notification by the DB data management unit 3 is sent to the DBMS 11 via the DB driver addition module 4. Send.

  In step S22, the DBMS 11 receives a code for rolling back the DB, and in step S23, the DBMS 11 outputs an instruction to roll back to the state designated for the DB.

  In step S24, when the process of step S22 is completed, the DB data management unit 3 transmits a state restoration end notification to the program model checking apparatus 1. The state restoration end notification is a notification for causing the program model checking apparatus 1 to resume program model checking and switching the operation from the database control apparatus 2 to the program model checking apparatus 1.

(Description of operation of DB data management unit)
Assuming a program state having the state tree shown in FIG. 4, the operation of the DB data management unit 3 will be described using the flowchart shown in FIG. In this example, an SQL statement is used as a code.

  In step S31, the DB data management unit 3 issues an SQL statement to the program model checking apparatus 1 in order to set the DB of the DBMS 11 to an initial state (state 1 in FIG. 4). For example, “delete * from TB1” and “delete * from TB5” shown in A of FIG. 7 are issued. The SQL statement to be in the initial state is recorded in advance in the state tree management table by the user (verification performer). “TB1” and “TB5” are tables received by the DBMS 11.

  Note that the state tree management tables shown in A to E of FIG. 7 have cells that record “node ID”, “path”, and “SQL”, and the state notified from the program model checking apparatus 1 to “node ID”. The identification number indicating is recorded. In “path”, contents (path information) associated with the “node ID” and indicating the state of the branch point and the transition state are recorded. For example, if it is a branch from state 2 to state 3, it is recorded as “2 → 3”. In “SQL”, an SQL statement that is associated with the “node ID” and issued until a branch (state transition) is detected is recorded.

  In step S <b> 32, the DB data management unit 3 receives an inspection start notification (also notified at the time of resumption) from the program model inspection device 1 via the DB driver addition module 4. The inspection start notification is information issued when the program model inspection apparatus 1 starts or restarts inspection (see A in FIG. 6).

In step S <b> 33, the code storage unit 5 records the SQL statement issued from the DBMS 11 in the log file 6. FIG. 3A shows an example of an SQL sentence issued from the DBMS 11.
In step S34 (state tree management process), the state tree management unit 7 receives a state change notification from the program model checking apparatus 1 via the DB driver addition module 4. The state change notification is notified when there is a state change in the path of the program under inspection, and has a state change code indicating that this notification is a notification indicating a state change and a node ID indicating a new state. (See B in FIG. 6). For example, if the transition is from state 1 to state 2 (branch point) in FIG. 4, “2” is notified as the node ID indicating state 2.
The program model checking device 1 stores the state at that time whenever a branch condition in the program appears.

  In step S35 (log file management process), the log file management unit 8 records a status change mark in the SQL statement. FIG. 3B shows an example of an SQL sentence issued from the DBMS 11. In the example of FIG. 3B, [initial state] and [node ID 2] to [node ID 6] are described as marks. In this example, the comment symbols “/ *” and “* /” are used to treat the mark as a comment sentence.

  In step S36 (state tree management process), the state tree management unit 7 additionally records a “node ID” indicating a new state in the state tree management table. For example, if the transition is from state 1 in FIG. 4 to state 2 (branch point), “2” is added to “node ID” in the state tree management table as shown in FIG. 7B. Then, “1 → 2” indicating that the state 2 which is a program branch point is detected from “1” (state 1) of “node ID” is recorded in “path”. In addition, the SQL statements issued from the state 1 to the state 2 recorded by the log file management unit 8 are sequentially recorded in “SQL”.

  Similarly, the transition from state 2 to state 3 and from state 3 to state 4 is processed in the same manner as steps S33 to S36. As a result, the state tree management tables shown in FIGS. 7B and 7C are generated.

Backtrack processing is performed in steps S37 to S39, S41 (backtrack management processing), and step S40 (DB control code issuance processing).
In step S37, the backtrack management unit 9 receives a backtrack start notification from the program model checking device 1. When the backtrack start notification is received, the process proceeds to step S38, and when not received, the process proceeds to step S33. The backtrack start notification has a code indicating the start of backtracking and a restoration destination node ID which is an identification number indicating the status of the restoration destination. For example, when the program advances to state 4 in FIG. 4, the backtrack management unit 9 receives from the program model checking apparatus 1 a backtrack start notification that returns to the latest program branch state 3.

In step S38, the backtrack management unit 9 acquires a restoration destination node ID.
In step S39, the backtrack management unit 9 retrieves the node ID indicated by the restoration destination node ID from the state tree management table, and obtains the path and the SQL sentence from the initial state to the state indicated by the restoration destination node ID. Extract all. Then, the extracted SQL sentence is rearranged in the reverse order of the path to generate an SQL sentence (DB control code) and transmits it to the DB control code issuing unit 10.

In step S40 (DB control code issuance process), the DB control code issuing unit 10 issues the SQL statements generated in step S39 to the DBMS 11 in order.
In step S41, the backtrack management unit 9 transmits a state restoration end notification to the program model checking apparatus 1.

  In the case of FIG. 4, when the program proceeds to the state 4, the DB data backtrack unit 2 executes the program model checking apparatus 1 from the state 3 indicated by “3” of the “node ID”. The SQL statement issued in step 1 is recorded in the state tree management table.

  When the program advances to state 5, a notification is received from program model checking apparatus 1 so as to return to the latest program branch state 2. Therefore, the process proceeds to backtrack processing for returning to state 2.

Next, the DB control code issuing unit 10 issues an SQL statement and returns the DBMS 11 to the state 2.
Next, the program model checking apparatus 1 is executed from the state 2 in FIG. 4, and the SQL statement issued between the state 2 and the state 6 is recorded in “SQL” of the state tree management table.

  Note that the code (SQL sentence) is output from the program model checking apparatus 1 only when the inspection target program 22 of the program model checking apparatus 1 is operated, so that the program does not operate during backtracking. Therefore, the code (SQL sentence etc.) from the inspection target program 22 is ignored. Therefore, the operation at the time of backtracking is not recorded in the log file 6.

(Description of operation of the backtrack management unit: backtrack management processing)
FIG. 8 is a flowchart showing the operation of the backtrack management unit 9.

  In step S51, the process waits until the backtrack management unit 9 receives a backtrack start notification from the program model checking apparatus 1. For example, in the case of returning from the state 4 shown in FIG. 4 to the state 3, the state tree management table shows “path” corresponding to “1” to “4” of “node ID” as shown in C of FIG. "SQL" is generated and recorded.

  In step S <b> 52, the backtrack management unit 9 receives a backtrack start notification from the program model checking device 1. For example, as shown in FIG. 8A, the backtrack start notification includes a code indicating the start of backtracking (“start code”) and a recovery destination node ID (an identification number indicating the status of the recovery destination). If the program model check returns to the state 3 shown in FIG. 4, “3” is transmitted from the program model checking apparatus 1 as the restoration destination node ID, and the backtrack management unit 9 performs the state 3 based on the restoration destination node ID. Recognize backtracking to

  In step S53, the backtrack management unit 9 searches the state tree management table for the “node ID” corresponding to the restoration destination node ID. For example, if the restoration destination node ID is “3”, the row having the “node ID” of “3” is searched from the state tree management table of FIG. Then, “3” as a search result is recorded in the recording unit (B in FIG. 8).

In steps S54 to S56, the backtrack management unit 9 extracts a path from the “node ID” indicating the initial state to the state corresponding to the restoration destination node.
In step S54, the backtrack management unit 9 extracts the “path” associated with the “node ID” corresponding to the restoration destination node. Further, the “path” corresponding to the “node ID” detected in step S56 is extracted.

  In step S55, the backtrack management unit 9 determines whether the initial state is indicated in the previous node ID (previous state) in the extracted “path”. If the initial state is indicated, the process proceeds to step S57. If the initial state is not indicated, the process proceeds to step S56. For example, in the case of FIG. 7, since “1” of “node ID” indicates the initial state which is state 1 of FIG. 4, when “1 → 2” recorded in “path” is detected. Control goes to step S57.

  In step S56, the backtrack management unit 9 extracts the “node ID” corresponding to the node ID before the recorded “path” from the state tree management table.

The case of backtracking from state 4 to state 3 in FIG. 4 will be described.
In step S54, as shown in C of FIG. 8, “2 → 3” that is “path” associated with “3” of “node ID” is extracted. Each “path” associated with each “node ID” is indicated as “A → B”, B indicates a “node ID” associated with the same record, and A is indicated by “B”. The node ID before reaching the “node ID” is shown.

For example, since the node ID before “2 → 3” is “2” in step S55, the previous state is not the initial state, and the process proceeds to step 56 (step S5: first time).
In step 56, the previous node ID “2” is extracted from the path “2 → 3” of the node ID (first time) shown in C of FIG. 8 recorded in step S55 (E in FIG. 8).

In step S54, as shown in C of FIG. 8, “1 → 2” that is “path” associated with “2” of “node ID” is extracted.
Next, in step S55, since the node ID before “1 → 2” is “1”, it is determined as the initial state, and the process proceeds to step 57 (step S55: second time of D in FIG. 8).

As described above, the backtrack management unit 9 extracts the path (state 1 → state 2 → state 3) from the “node ID” indicating the initial state to the state corresponding to the restoration destination node.
In step S57, the backtrack management unit 9 extracts the SQL sentence in “SQL” corresponding to the “node ID” associated with the recorded “path” from the state tree management table. For example, as shown in F of FIG. 8, an SQL sentence corresponding to “3” of “node ID”, an SQL sentence corresponding to “2” of “node ID”, and “1” of “node ID” (initial state) Are extracted from the state tree management table.

  In step S58, the backtrack management unit 9 rearranges the SQL statements extracted in step S59 in the reverse order of the paths, and transmits them to the DB control code issuing unit 10 in that order. For example, as shown in FIG. 8G, an SQL sentence corresponding to “1” (initial state) of “node ID”, an SQL sentence corresponding to “2” of “node ID”, and “3” of “node ID” ] Are rearranged and transmitted to the DB control code issuing unit 10.

  The DB control code issuing unit 10 issues the received SQL statements to the DBMS 11 of the program model checking device 1 in order. Then, the program model checking device 1 restores the DB state based on the SQL sentence.

  In step S59, the backtrack management unit 9 notifies the DBMS 11 that all the SQL statements for making the state indicated by the restoration destination node ID have been restored (status restoration completion notification).

  By performing backtrack processing as described above, memory consumption can be reduced by performing efficient backtracking to return the data of the DBMS 11 used in the execution environment in the program model check to the restored state. In addition, a log that reaches each state can be managed as a state tree structure, and a path to return to the log can be dynamically created.

  In addition, even when program model checking is executed using an actual DB, each state of DB data as in the past is left in a snapshot and managed by linking with the state of the program model checking path Do not need.

  Also. Conventionally, even if there is no DB data in the program model check, a huge memory and CPU performance is required. In addition, if memory consumption due to snapshots is added, the execution of program model checking itself is greatly affected. In addition, a copy database and storage are required separately. In addition, since the timing of taking a snapshot is managed at the timing of data change and is different from the unit managed by the program model check, a mechanism for linking and managing both is required. Conventionally, state tree information dynamically created in the program model checking device is managed, and when returning to a state belonging to a completely different subtree as shown in FIG. Identify and seek the path to that state.

  However, in this example, in order to return from the state S to the state I as shown in FIG. 10B, it is necessary not only to go back to the state but also to identify the subtree to which the state I belongs and calculate the path to that state. Disappears. In addition, no additional storage is required to store data snapshots. In addition, memory consumption can be reduced.

  Conventionally, it is assumed that the state returns to a state represented by a one-dimensional time sequence as shown in FIG. 10C, and a state where a plurality of time sequences exist like a state tree of program model checking. It is not a way to manage. Therefore, in order to manage the state tree information in which there are a plurality of time sequences that are dynamically created within the program model checking tool, DB state management linked to the dynamically created program model checking state tree must be performed. It needs to be done efficiently. However, if it does not have a data structure that can record all of the multiple paths through which node the target state passes from the root, it can efficiently log backtrack to any state. It is difficult to create from. Also, if the tree structure is ignored and management is performed, if the number of states is extremely large, such as hundreds to thousands, as in program model checking, memory consumption increases and the path to which the target state is to be traced Since it is searched whether it can be searched, the load of CPU becomes large.

  On the other hand, in this example, the path to the backtrack start point is managed as a state tree, so that the node search and the calculation of the path to that point are accelerated, and the load on the CPU can be reduced.

Further, since the code (SQL sentence or the like) issued by the program model checking apparatus 1 is used, it is not necessary to change the program model checking apparatus for each DBMS 11.
In the present embodiment, an example in which the program model checking device and the database control device are separate devices is shown, but the present invention can be configured as a single device having the functions of both devices. .

(Configuration when this embodiment is realized as a computer program)
FIG. 9 is a diagram illustrating an example of a hardware configuration of a computer that can implement the apparatus according to the embodiment of the present invention.

  The computer hardware 90 includes a CPU 91, a recording unit 92 (ROM, RAM, hard disk drive, etc.), a recording medium reader 93, an input / output interface 94 (input / output I / F), a communication interface 95 (communication I / F), and the like. It has. Further, each of the components is connected by a bus 96.

  The CPU 91 executes the above-described state tree management process, log file management process, backtrack management process, and DB restoration notification issuance process (the processes shown in FIGS. 5, 6, and 8) stored in the recording unit 92.

The recording unit 92 records programs and data executed by the CPU 91. It is also used as a work area.
The recording medium reading device 93 controls reading / writing of data with respect to the recording medium 93 a according to the control of the CPU 91. And the data written by control of the recording medium 93a and the recording medium reader 93 are memorize | stored, or the data memorize | stored in the recording medium 93a are read. The detachable recording medium 93a includes a magnetic recording device, an optical disk, a magneto-optical recording medium, a semiconductor memory, and the like as a computer-readable recording medium. The magnetic recording device includes a hard disk device (HDD). Examples of the optical disc include a DVD (Digital Versatile Disc), a DVD-RAM (Random Access Memory), a CD-ROM (Compact Disc Read Only Memory), and a CD-R (Recordable) / RW (ReWritable). Magneto-optical recording media include MO (Magneto-Optical disk).

  An input / output device 94 a (mouse, keyboard, display, etc.) is connected to the input / output interface 94, receives information input by the user, and transmits it to the CPU 91 via the bus 96. In addition, operation information and the like are displayed on the screen of the display according to a command from the CPU 91.

  The communication interface 95 is an interface for LAN connection, Internet connection, or wireless connection with another computer as necessary. It is also connected to other devices and controls data input / output from external devices.

  By using one or more computers having such a hardware configuration, the various processing functions described above (the processing described in the embodiments (such as flowcharts)) are realized. In that case, a program describing the processing contents of the functions that the system should have is provided. By executing the program on a computer, the above processing functions are realized on the computer. The program describing the processing contents can be recorded in a computer-readable recording medium 93a.

  When distributing the program, for example, a portable recording medium such as a DVD or a CD-ROM in which the program is recorded is sold. It is also possible to store the program in a storage device of a server computer and transfer the program from the server computer to another computer via a network.

The computer that executes the program stores, for example, the program recorded on the portable recording medium or the program transferred from the server computer in its own storage device. Then, the computer reads the program from its own storage device and executes processing according to the program. The computer can also read the program directly from the portable recording medium and execute processing according to the program. Further, each time the program is transferred from the server computer, the computer can sequentially execute processing according to the received program.
The present invention is not limited to the above-described embodiment, and various improvements and modifications can be made without departing from the gist of the present invention.

Regarding the embodiment including the above-described examples, the following additional notes are further disclosed.
(Appendix 1)
A database control device that controls a database used in an execution environment when the program model checking device performs program model checking,
When a state change notification having a node ID that is an identification number for identifying the state after the change of the database is received from the program model checking device, a transition path to the state after the change is associated with the node ID. A recording unit for recording in the state tree management table log information that is a code for controlling the database output from the program model checking device during the transition from the state before the change to the state after the change ,
The path recorded in the state tree management table in association with the restoration destination node ID when the backtrack start notification having the restoration destination node ID that is an identification number indicating the return destination state is received from the program model checking device A backtrack management unit that generates a backtracking code for returning the database to the state indicated by the restoration destination node ID based on the information and the log information;
A database control apparatus comprising:
(Appendix 2)
The backtrack management unit
A plurality of log information corresponding to a plurality of path information indicating transition paths from the initial state to the state corresponding to the restoration destination node ID is acquired from the state tree management table, and the log information is arranged and backtracked. 2. The database control device according to appendix 1, wherein the code is generated.
(Appendix 3)
When a state change notification having a node ID that is an identification number for identifying the state after the change of the database is received from the program model checking means for performing the program model check, the state is associated with the node ID and changed to the state after the change. Record the path information indicating the transition path and log information, which is a code for controlling the database output from the program model checking means during the transition from the state before the change to the state after the change, in the state tree management table. Recording means;
When a backtrack start notification having a restoration destination node ID, which is an identification number indicating a return destination state, is received from the program model checking means, it is recorded in the state tree management table in association with the restoration destination node ID. Backtrack management means for generating backtracking code for returning the database to the state indicated by the restoration destination node ID based on path information and log information;
A computer comprising:
(Appendix 4)
A database control method for a database used in an execution environment when a program model checking device performs a program model checking,
When a state change notification having a node ID that is an identification number for identifying the state after the change of the database is received from the program model checking device, a transition path to the state after the change is associated with the node ID. And log information that is a code for controlling the database output from the program model checking device during the transition from the state before the change to the state after the change to the state tree management table,
The path recorded in the state tree management table in association with the restoration destination node ID when the backtrack start notification having the restoration destination node ID that is an identification number indicating the return destination state is received from the program model checking device Based on the information and log information, a backtracking code for returning the database to the state indicated by the restoration destination node ID is generated.
A database control method in program model checking characterized by the above.
(Appendix 5)
On the computer,
When a state change notification having a node ID that is an identification number for identifying the state after the change of the database is received from the program model checking device, the transition path to the state after the change is shown in association with the node ID Processing for recording path information and log information that is a code for controlling the database output from the program model checking device during the transition from the state before the change to the state after the change in the state tree management table;
The path recorded in the state tree management table in association with the restoration destination node ID when the backtrack start notification having the restoration destination node ID that is an identification number indicating the return destination state is received from the program model checking device Backtrack management processing for generating a backtracking code for returning the database to the state indicated by the restoration destination node ID based on the information and log information;
A database control program in program model checking characterized by causing
(Appendix 6)
A plurality of log information corresponding to a plurality of path information indicating transition paths from the initial state to the state corresponding to the restoration destination node ID is acquired from the state tree management table, and the log information is arranged and backtracked. The database control method in the program model check according to appendix 4, characterized by generating a code for use.
(Appendix 7)
On the computer,
A plurality of log information corresponding to a plurality of path information indicating transition paths from the initial state to the state corresponding to the restoration destination node ID is acquired from the state tree management table, and the log information is arranged and backtracked. A database control program in program model checking characterized by generating a code for use.

DESCRIPTION OF SYMBOLS 1 Program model inspection apparatus 2 Database control apparatus 3 DB data management part 4 Module 5 Code storage part 6 Log file 7 State tree management part 8 Log file management part 9 Backtrack management part 10 DB control code issuing part 21 Driver 22 Program 23 Input Data 24 Property 31 Driver 90 Hardware 92 Recording unit 93 Recording medium reader 93a Recording medium 94 Input / output interface 94a Input / output device 95 Communication interface 96 Bus

Claims (5)

A database control device that controls a database used in an execution environment when the program model checking device performs program model checking,
When a state change notification having a node ID that is an identification number for identifying the state after the change of the database is received from the program model checking device,
Path information indicating a transition path to the state after the change, and log information that is a code for controlling the database output from the program model checking device during the transition from the state before the change to the state after the change. A recording unit for recording in the state tree management table;
The path recorded in the state tree management table in association with the restoration destination node ID when the backtrack start notification having the restoration destination node ID that is an identification number indicating the return destination state is received from the program model checking device Based on the information and log information, a plurality of log information corresponding to a plurality of path information indicating a transition path from the initial state to a state corresponding to the restoration destination node ID is acquired from the state tree management table, A backtrack management unit that generates a backtracking code for arranging the log information in the reverse order of recording and returning the database to the state indicated by the restoration destination node ID;
A database control apparatus comprising: The backtrack management unit
A plurality of log information corresponding to a plurality of path information indicating transition paths from the initial state to the state corresponding to the restoration destination node ID is acquired from the state tree management table, and the log information is arranged and backtracked. The database control device according to claim 1, wherein the database code is generated. When a state change notification having a node ID that is an identification number for identifying the state after the change of the database is received from the program model checking means for performing the program model check, the state is associated with the node ID and changed to the state after the change. Record the path information indicating the transition path and log information, which is a code for controlling the database output from the program model checking means during the transition from the state before the change to the state after the change, in the state tree management table. Recording means;
When a backtrack start notification having a restoration destination node ID, which is an identification number indicating a return destination state, is received from the program model checking means, it is recorded in the state tree management table in association with the restoration destination node ID. Backtrack management means for generating backtracking code for returning the database to the state indicated by the restoration destination node ID based on path information and log information;
A computer comprising: A database control method for a database used in an execution environment when a program model checking device performs a program model checking,
When a state change notification having a node ID that is an identification number for identifying the state after the change of the database is received from the program model checking device,
Path information indicating a transition path to the state after the change, and log information that is a code for controlling the database output from the program model checking device during the transition from the state before the change to the state after the change. Record in the state tree management table,
The path recorded in the state tree management table in association with the restoration destination node ID when the backtrack start notification having the restoration destination node ID that is an identification number indicating the return destination state is received from the program model checking device Based on the information and log information, a plurality of log information corresponding to a plurality of path information indicating a transition path from the initial state to a state corresponding to the restoration destination node ID is acquired from the state tree management table, Arranging the log information in reverse order of recording and generating a backtracking code for returning the database to the state indicated by the restoration destination node ID;
A database control method in program model checking characterized by the above. On the computer,
When a state change notification having a node ID that is an identification number for identifying the state after the change of the database is received from the program model checking device, the transition path to the state after the change is shown in association with the node ID Processing for recording path information and log information that is a code for controlling the database output from the program model checking device during the transition from the state before the change to the state after the change in the state tree management table;
The path recorded in the state tree management table in association with the restoration destination node ID when the backtrack start notification having the restoration destination node ID that is an identification number indicating the return destination state is received from the program model checking device Based on the information and log information, a plurality of log information corresponding to a plurality of path information indicating a transition path from the initial state to a state corresponding to the restoration destination node ID is acquired from the state tree management table, Backtrack management processing for generating a backtrack code for arranging the log information in the reverse order of recording and returning the database to the state indicated by the restoration destination node ID;
A database control program in program model checking characterized by causing

Images