JPH1097417A - Program assembling device and storage medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To improve a quality of a program development and to prevent the development from being overlapped. SOLUTION: This device is equipped with a skeleton data base 54 which stores a standard model program and a data restriction/component data base 52 generated on the basis of data items handled in operation and restrictions regarding the data items. A program assembling means 78 incorporates components taken out of the data restriction/component data base 52 according to the data items, an input/output classification, and data characteristics specified by a screen layout generating means 72 at custom points of the input/output process of the model program selected out of the skeleton data base 54 to generate a program. The program is based upon the standard model program, so variance of the program is small and the quality is improved. Further, the components generated on the basis of the restrictions regarding the data items are managed by the data base, so overlapped development can be prevented.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a program assembling apparatus and a storage medium for assembling a program used in a computer or the like. More particularly, the present invention relates to a part program for executing restrictions on data items handled in a business, and a skeleton model. The present invention relates to a program assembling apparatus that assembles a program by incorporating the program into a program, and a storage medium that stores an assembling program that causes a computer to realize the assembling function of such a program.

[0002]

2. Description of the Related Art In a conventional program development work, especially in a program design and development work mainly based on an interactive entry, the business requirements of a user department are listened to, and each developer in the information processing department embodies a program function, and Has designed / manufactured the structural design and check / edit logic individually. More specifically, the program is produced through the following four steps (1) to (4).

[0003] (1) Requirement definition process Listen to the business requirements of the user department (business flow, input / output screen / form functions, main input / output items, screen images, etc.)
Identify the data items handled in the business and design the database.

(2) Design process Based on the business flow and the screen / form request function,
Design the program by defining the form layout / MMI (Man-Machine-Interface).

(3) Production process Based on the program design document created in the design process, check logic and edit processing logic for the program structure and data items to be handled are created.

(4) Test process The function of the built program logic is verified.
If there is a defect, return to the previous process and make a new one.

[0007] Generally, the above requirement definition / design process is referred to as an upstream process, and the fabrication / test process is referred to as a downstream process.

By the way, in most cases, data items handled in business such as sales and distribution are stored in a database in some form, and are queried on forms and screens. The success or failure of the system is determined by the degree of completion of the database, so database design in the upstream process has been regarded as important. In particular, in recent years, database design techniques centered on data analysis techniques focusing on the life cycle of handled data in business and the relationship with other data have been put to practical use.

A screen / form and a program function used in business are realized by combining the characteristics of these data items. Each developer has designed logic based on the relationship between these data items based on their experience and knowledge, and has built programs.

Further, in recent years, a CASE tool (a program production support tool for creating a unique logic based on a standard program structure) for the purpose of improving the efficiency of the program production work in the downstream process has been put into practical use. Productivity is being improved by standardizing the program structure.

Therefore, recently, the mainstream of the program development is a combination of the database design of the upstream process by the above-described database design method and the production of the program of the downstream process by the CASE tool.

[0012]

However, in the above-mentioned conventional program development work, even if data analysis or CA
Even with the practical use of SE tools, there is still a problem that the creation of unique logic largely depends on individual skills, and duplicate development and quality variations have not been eliminated.

As a cause of this problem, even if the characteristics of a data item and its relationship with other data items are identified by data analysis, each developer in charge of incorporating the data item into program logic is based on his / her experience and knowledge. The design / production is performed by interpreting the relationship between these data items. That is, at present, data analysis results are used only for database design, and are not used for design / production of program logic. The reasons for not being used are as follows.

The characteristics and relationships of the data items in the data analysis result are complicated (not orderly).

There are individual differences in how to interpret each data constraint (characteristics and relationships of data items).

As a result, there is also a problem that program functions are repeatedly developed for each system / subsystem developed, which leads to a problem of maintainability.

In view of the above facts, the present invention stores a program for realizing the functions of the program assembling apparatus by using a computer and a program assembling apparatus which eliminates personality in program development and is less likely to cause duplicate development and quality variation. It is intended to provide a storage medium.

[0018]

According to one aspect of the present invention, there is provided a program assembling apparatus for assembling a program including a data input or output process for a data item defined in a business. A first storage unit that stores an item and a component program that executes a restriction when data is input or output in the data item in association with each other; Second storage means for storing at least one template program in which a type of a component program to be mounted at the processing location is defined;
Specifying means for specifying a data item, and first extracting means for extracting, from the first storage means, a component program for executing a restriction when data is input or output with the data item specified by the specifying means A second extraction unit for extracting any one of the template programs from the second storage unit; and a part program extracted by the first extraction unit, and a model extracted by the second extraction unit. Program assembling means for incorporating the type of the part program of the program into a processing location where the type is defined.

According to the first aspect of the present invention, the specifying means specifies a data item defined in the business. For example, in the case of a business dealing with an order receipt, data items include a contractor, a user, a settlement condition, an order number, and the like. Next, the first extracting means:
The component program for executing the restriction when data is input or output in the data item specified by the specifying means is stored in the first part.
From the storage means. For example, if the data item is “user” in the work of receiving an order, there is a component program for checking whether or not the user is registered. The second extracting means extracts any one of the template programs from the second storage means. The model program has a processing part where the component program stored in the first storage means is to be mounted, and the type of the component program to be mounted at this processing part is defined. The template program is obtained by classifying the structure of the program into several patterns according to the characteristics of input and output, and standardizing each pattern.
Also, types defined at the processing location include types of input, output, and editing component programs, types used for one data item, and types for checking association between data items. And the program assembling means:
The extracted part program is incorporated into a processing location in the extracted model program where the type of the part program is defined. With this assembled program, input or output processing for a specified data item can be performed.

As described above, according to the present invention, a component program for executing a restriction when inputting / outputting data in a data item handled in a business is stored in advance, and only by designating a data item, a constraint related to this data item is stored. Is implemented in the base model program. As a result, the efficiency of the program production work is improved, and the quality of the produced program is improved with less variation. In addition, by reusing the component program stored in the first storage unit, it is possible to suppress redundant development.

According to a second aspect of the present invention, there is provided a program assembling apparatus for assembling a program including a data input or output process for a data item defined in a business, wherein the data item and data are input or output by the data item. A first storage unit that stores the constraints when the component programs are executed in accordance with the characteristics and input / output of the data in association with each other, and an unmounted processing location where the component programs are to be mounted, A second storage unit storing at least one template program in which a type of a component program to be implemented at the processing location is defined; a data item; characteristics of data input or output in the data item;
And a designating means for designating the input / output of data in the data item, and a component program for executing a restriction when data is input or output in the data item designated by the designating means, First extraction means for extracting from the first storage means according to the characteristics and input / output of the second, second extraction means for extracting any one template program from the second storage means, And a program assembling means for incorporating the part program extracted by the first extracting means into a processing location where the type of the part program of the template program extracted by the second extracting means is defined. And

According to the second aspect of the present invention, the specifying means specifies the data item defined in the business, the characteristics of the data input or output in this data item, and the input / output of data in this data item. Note that the data characteristics refer to data formats such as data types (alphabetic, numeric, and kana), the number of digits, and values. Next, the first extracting means:
A component program for executing a restriction when data is input or output in the data item specified by the specifying means is extracted from the first storage means according to the characteristics of the specified data and the input / output. The second extracting means extracts any one of the template programs from the second storage means. Then, the program assembling unit incorporates the extracted part program into a processing location in the extracted model program where the type of the part program is defined. With this assembled program, data input or output processing can be performed on the specified data item with the specified data characteristics for each specified input / output.

As described above, according to the present invention, a component program for executing a restriction when data is input / output in a data item handled in a business is stored in advance, and a data item, input / output, and
By simply designating the data characteristics, the component program that executes the restrictions related to the data item, input / output, and data characteristics is incorporated into the base model program. As a result, the efficiency of the program production work is improved, and the quality of the produced program is improved with less variation. In addition, by reusing the component program stored in the first storage unit, it is possible to suppress redundant development.

According to a third aspect of the present invention, there is provided the first or second aspect.
The invention further comprises: component selection means for selecting a component program extracted by the first extraction means, wherein the program assembling means converts the component program selected by the component selection means into the second program. The type of the part program of the template program extracted by the extracting means is incorporated in a defined processing location.

According to the third aspect of the present invention, the part selecting means selects the part program extracted by the first extracting means. Here, as a component selection method, for example, there is a method of displaying an outline of each extracted component program and selecting a component specified by an operator. Next, the program assembling unit incorporates the component program selected by the component selecting unit into a processing location where the type of the component program is defined in the template program extracted by the second extracting unit. As described above, according to the present invention, the extracted part program can be selected, so that the program production operation can be performed more efficiently.

The program assembling apparatus described above can also be realized by executing an assembling program for realizing the functions of the apparatus by a computer. By storing such an assembling program in a computer-readable storage medium as in the following aspects of the present invention, the versatility of the present invention can be greatly expanded.

According to a fourth aspect of the present invention, there is provided the first aspect, wherein a data item defined in the business and a component program for executing a restriction when data is input or output in the data item are stored in association with each other. A second area storing at least one template program which has a data area and a processing location where the component program to be mounted is not mounted, and in which the type of the component program to be mounted at the processing location is defined; A data area, and a computer-readable storage medium storing an assembling program for assembling the program based on the information of the assembling program, wherein the assembling program has a designation function for designating a data item, Extract a part program from the first data area to execute a restriction when data is input or output with a specified data item A second extraction function for extracting any one of the template programs from the second data area; and a part program extracted by the first extraction function for the second extraction. The program is a program for realizing, by a computer, an assembling function to be incorporated into a processing location where the type of the part program of the template program extracted by the function is defined.

According to a fifth aspect of the present invention, a data item defined in a business and a component program for executing a restriction when data is input or output in the data item are stored in association with each other. One data area and at least one template program which has an unmounted processing location where the component program is to be mounted and in which the type of the component program to be mounted at the processing location is defined. A computer-readable storage medium storing an assembling program for assembling a program based on information in a second data area, wherein the assembling program includes a data item, data input or output in the data item. Function for designating the characteristics of data and the input / output of data in the data item, and the data item designated by the designating function A first extraction function for extracting a component program for executing a restriction when data is input or output from the first data area in accordance with a specified characteristic of data and input / output; A second extraction function for extracting any one of the template programs from the data area, and a part program extracted by the first extraction function, the part program of the template program extracted by the second extraction function. The program is characterized in that it is a program for realizing, by a computer, an assembling function to be incorporated in a processing location where the type is defined.

Further, according to a sixth aspect of the present invention, the assembly program stored in the storage medium of the fourth or fifth aspect has a component selection function for selecting a component program extracted by the first extraction function. Wherein the assembling function incorporates the component program selected by the component selecting function into a processing location where the type of the component program of the template program extracted by the second extracting function is defined. It is a feature.

Here, in the inventions of claims 4 to 6, the first and second data areas are provided as data stored in the storage medium of the present invention. Directly access the storage medium, or transfer a part of the data read from the storage medium to the RAM.
Or the like may be temporarily stored. in this case,
This is suitable, for example, when the capacity of the hard disk is insufficient. Further, the first and second data areas may not be stored in the storage medium of the present invention, and may be provided as data previously stored in another storage unit. In addition,
The different storage means here includes a storage device such as a hard disk built in or external to the computer, in addition to another storage medium (portable) different from the storage medium of the present invention.

Further, the first and second data areas are initially provided as data stored in the storage medium of the present invention, and when executing the assembling program, these data areas are stored in another storage means. It can also be installed in an executable format. Including such a case, as in the invention of claim 7, claims 4 to 6
In the invention according to any one of the first to third aspects, it is preferable to further store a generation program for generating the first and second data areas in another storage means.

By executing the generating program according to the seventh aspect, for example, the first and second data areas stored in the storage medium of the present invention (compression format may be used).
Is generated in a separate storage means under a predetermined directory structure (in the case of a compressed format, it is converted into an executable format). Then, when the assembly program is executed, the computer accesses the first and second data areas stored in the separate storage means based on the first and second extraction functions. When the other storage means is a medium which can be accessed at a higher speed than the storage medium of the present invention, the assembling speed when executing the assembling program of the present invention can be improved.

It should be noted that the assembly program stored in the storage medium of the present invention may also be generated in another storage means by this generation program. Further, the first and second data areas stored in a storage medium different from the storage medium of the present invention may be generated in the separate storage means.

[0034]

Embodiments of the present invention will be described below in detail with reference to the drawings. (First Embodiment) FIG. 1 shows the configuration of a program assembling apparatus according to a first embodiment of the present invention. The program assembling apparatus is configured using a so-called personal computer.

As shown in FIG. 1, the program assembling apparatus according to the present embodiment has a microprocessor 10 for controlling and managing the entire apparatus based on a predetermined program, and a RAM 12 for temporarily storing various data. And a ROM 14 of a nonvolatile memory in which the predetermined program of the microprocessor 10 is stored, each of which is connected to a system bus 16 for transmitting control commands and data.
The programs stored in the ROM 14 include various support tools for assembling programs, which will be described later, and a compiler for converting a source program into an executable format.

The program assembling apparatus includes a hard disk drive 22 that reads and writes data using a magnetic disk or the like as a storage medium, and a floppy disk drive (F) that reads and writes data using a floppy disk as a storage medium.
DD) 26, and a display 30 for displaying kana-kanji converted character data and images, each of which is a hard disk control unit 20, an FDD control unit 24, a display control unit including a so-called VRAM and a kanji ROM. It is connected to the system bus 16 via.
Note that a so-called magneto-optical disk device or the like may be used as the hard disk device 22.

The hard disk control unit 20, FDD
A DMA controller 18 connected to the system bus 16 is also connected to the control unit 24 and the display control unit 28. The DMA controller 18 directly accesses the memory without passing through the microprocessor 10 to perform high-speed data transfer. It is possible.

The program assembling apparatus further includes a keyboard 34 as input means using keys, a mouse 38 as a pointing device, and a printer 42 for printing and outputting image and character data. , A mouse control unit 36 and a printer control unit 40.

Further, the program assembling apparatus includes a modem 46 for converting an analog signal of the connected analog telephone line into a digital signal. The modem 46 is connected to the system bus 16 via the input / output interface control unit 44. ing. That is, the program assembling apparatus can perform data communication with another terminal or a host computer via an analog telephone line. When connecting to a digital line such as a so-called ISDN, the modem 46 becomes unnecessary.

The hard disk drive 22 described above
Has a VTOC 50 as a file management area, and as data managed by the VTOC 50, a data constraint / parts database 52, a skeleton database 5
4, DB access component 56, process constraint component 58, general-purpose function component 60, MMI control component 62, and control component 6
4. The embedded program 65 is stored. In addition,
Details of each data will be described later.

Here, data constraint / parts database 5
A detailed description will be given of a method of classifying constraints and making components necessary for creating the component 2.

First, the "constraints" refer to the rules (business rules) in the business world, and the "constraints" are, as shown in FIG. It can be classified into constraints (process constraints) to be expressed depending on the processing process.

As a reason for extracting and analyzing the constraints, conventionally, in the system analysis design stage, various constraints have been described in a format such as a system specification, a code design, and an input / output check specification without being clearly classified. Was. Moreover, the constraints that can be extracted in the upstream process are limited to the main ones, and the constraints that cannot be completely extracted are first discovered in the program manufacturing process or the test stage, and are often added afterwards. For this reason, the constraint is expressed in a duplicated manner in a large number of program codes, which is one of the factors that reduce the maintenance efficiency of the program.

Therefore, in the present embodiment, the restriction is not buried in the form of the unique processing logic of the program, and is handled as a database (database restriction) as a common resource in the company. It is also possible to make constraints independent of the means of realizing the system (technical environment, operating environment, etc.) and define them independently of the technical board of system construction, in other words, as constraints that are only affected by business changes. it can.

Next, an outline of the meaning definition of the database constraint will be described below. The data constraint / parts database 52 describes all restrictions resulting in data items such as business, and in principle, provides one part routine for each constraint. This database constraint describes the rules defined when a logical database record is recorded on the database and within its own database record and between other related logical database records. (See FIG. 5).

(1) Single item constraint Each data item in the logical database has a unique constraint. There are the following three types of single item constraints.

(B) Domain attribute restrictions (types and values) of data that can be taken by the standard domain (domain)
Is a constraint for defining. For example, there is a YYYYMMDD format as a domain attribute constraint for the domain of “year / month / day”.

However, YYYY is the year (1900-2100 and other year ranges handled by the system) MM is the month (01 to December), DD
Is the day (01-31; taking into account leap years).

(B) Item standard attribute constraint This is a constraint for defining the data type (type, length, value) that a data item can take. It is assumed that the item standard attribute constraint always satisfies the domain attribute constraint. For example, as the data item attribute constraint of the data item “order No.”, there is an 8-digit alphanumeric character or the like that is entered one by one in the following circles.

Format 1: ○ ○ ○ ○ ○ ○ A-J Numeric space, etc. (c) Item standard output attribute constraint This is a constraint for specifying the attribute (format) when displaying data items. For example, as the data item output attribute constraint of the data item “contract unit”, there is the following three-character Japanese.

K->"KG",L->"pound", F
->"Book" (2) Entity constraint A constraint that exists between a data item in an entity (logical database) and another data item. Note that constraints existing between data items include, for example, “value of one data item to be updated”, “value of another data item in the logical record to be updated”, and “update of a certain data item to be updated”. This means that at least one of the "previous value" and the "value of the data item in another logical record" has a specific relationship with each other.

The entity constraints include the following (a) to (
B) There are three types. (A) DB existence constraint This is a constraint for specifying that the data exists as a value of a database key item such as a master. For example, as the DB existence constraint of the data item "contractor" of the order file,
There are the following.

* The contractor has already been registered as the contractor of the related file. (B) Identifier constraint (uniqueness constraint) This is a constraint for stipulating whether or not the value of the key item is allowed to be duplicated.

For example, there are the following identifier restrictions for the order file. * Key item “Order No.” must be unique. (C) Required item restriction in entity This is a restriction for specifying data items necessary to exist as a logical database record. For example, there is the following as a mandatory item constraint in the entity of the order file.

* The transaction form, product name, and product attribute are required data as the order record. (D) Restrictions on required items by subtype This is a restriction for specifying the data items required to exist as a logical database record of a certain subtype.

The entity is derived from the user view (analytic judgment by the user) at the time of analysis.
The entity itself is a subtype of something and a supertype of something.

For example, the following are required items for each subtype of "in-house trading subtype" in the order file.

* In the "in-house trading subtype" record,
Transaction type, product name, product attributes, product type, contractor, settlement conditions,
And the data of the buyer type are required.

(E) Restrictions on required items for each substructure Depending on the database record, some states (substructures) may occur between the occurrence of the record and its disappearance.
Is a constraint for defining data items necessary to exist as a logical database record in each of these states.

For example, the following items are required as subfield-based mandatory item restrictions in the “unordered” state of the order file “in-house trading subtype” record.

* The “in-house trade subtype” record in the “unordered” state includes:-transaction type, product name, product attribute, product type,
Data on contractors, settlement conditions, and buyer types are required.

(F) Updatable item constraint by subtype (updatable item check component by subtype) This is a constraint for defining a data item that can be updated as a logical record of a certain subtype and a data item that cannot be updated. . For example, “Consignment processing subtype” in the order file
There are the following updatable item constraints for each subtype.

* The “consignment processing subtype” record can change the data of the contractor, the production place, the contract delivery date, the contract quantity, the use, the department in charge of the issuing department, and the shipping destination. , Product type, contract unit, and settlement unit data cannot be changed.

(G) Updatable item constraint by substructure (updatable item check component by substructure) This is a constraint for defining a data item that can be updated as a logical record in a certain state and a data item that cannot be updated. For example, there is the following as a substructure-updatable item restriction in the “already shipped” state of the order file “in-house trade subtype” record.

* "In-house trading subtype" records in the "already shipped" state include:-Contract delivery date, contract quantity, settlement unit price, issue date, contract remarks, contract optional, contract change reason, use data can be changed. .

Data of transaction form, product name, product genus, product type, contract unit, settlement unit, settlement condition cannot be changed.

(H) Substructure item transition update constraint This constraint defines another state in which a logical record can transition from one state. For example, there are the following sub-structure item transition constraints for the status “contract progress status” item of the order file.

* Order file status "Contract progress"
The following can be considered:-Anything other than "shipped" cannot be "contract completed".

[0096] "Contract completed" can not do anything. (I) Intra-entity / inter-entity item relation restrictions These are restrictions for specifying the relation between the data items of the logical database record. For example, in the order file, "Issue date", "Operation date", "Contract delivery date"
There are the following items related to the intra-entity / inter-entity item relations.

IF “Contract delivery date” = (with day input) THEN “Contract delivery date” ≦ “Same day of next month” ELSE “Contract delivery date (year / month)” ≦ “Next month” ENDIF If there is, the contract delivery date is limited to the same day of the following month, and if no date is entered, the contract delivery date is limited to the next month.
That is.

(3) Derivation processing restriction This describes a derivation processing rule for a data item that is recognized as data that can be logically derived, regardless of whether it is implemented on a physical database. For example, there are the following as the derived processing constraints on the “discontinued quantity” of the shipping file.

* “Discontinued quantity” = “contracted quantity” −
"Total shipment quantity" In other words, when the act of terminating the shipment is performed, a value obtained by subtracting the total shipment quantity from the contract quantity is derived as the discontinuation quantity.

However, data items whose tallying unit dynamically changes, such as tallying items of data, are not considered as derived processing constraints. These are described as process constraints in business analysis or system design, or as unique functions of individual businesses.

(4) Security Constraint This describes security rules for each data item in the logical database.

It should be noted that a confidentiality constraint should be originally set on the data itself. However, such a confidentiality constraint is indirectly applied to a system function by narrowing a data access route for each user (for example, by restricting a menu). In many cases, data is confidentially protected.

The constraints defined as described above are pre-developed as components (program modules) on the premise of reuse, and are used as data constraint components as data constraint / component databases according to the business function requirements of each application program. 52. It should be noted that, in principle, one component is used for each constraint, but the following points are taken into account when converting the constraints into components.

(B) Use as few items as possible for the interface of the parts (reduce the number of subroutine arguments). (B) The data amount handled by the parts is made as small as possible and delivered in data item units.

(C) The information inside the component is hidden and made self-contained. Here, FIG. 6 shows a characteristic classification of components manufactured based on the restrictions shown in FIG. As shown in FIG.
Parts are classified as follows (a) to (f).

(A) Database restriction component Database restriction component is made into a component for each mounting unit.
Note that the relationship with the database constraint is indicated by the * part on the right.

(B) DB access component Only the database access processing part required by the business program is made into a component. The corresponding constraint is:
There are a DB existence constraint and an identifier (uniqueness) constraint.

As described above, by absorbing the actual access operation to the physical database by the component, the program can be developed by using the logical access independent of the DBMS (database management system).

(C) Process-constrained component A process-constrained component other than the database constraint is made into a component.

(D) General-purpose function part This is a part for general-purpose data processing and editing without depending on specific data items such as addition and subtraction of dates.

(E) MMI (Man-Machine Interface) Control Parts These are parts that share data operations related to input / output items other than database items on screens and forms.

(F) Control parts These are parts that control common processing depending on the technical environment in online and batch programs. In many cases, the processing component is incorporated into a model (skeleton) described later, and examples include an error message text conversion display processing component and a cursor initial setting processing component.

Next, the data constraint / parts database 52
Will be described with reference to the flowchart of FIG.

As shown in FIG. 8, first, data items to be handled in a business are identified by business analysis (step 150).
The attribute / digit / value, meaning, etc., of each data item are defined (step 152).

Next, each data item is defined as a logical file of a database / transaction record of the data constraint / parts database 52 (step 15).
4). This makes it possible to search the database for data items that have been converted into logical files.

Next, the constraints of each data item, the related rules in the record, and the essential constraints are identified by data analysis (step 156). At this time, it is important to properly characterize various constraints (classification criteria) and extract and define constraints as much as possible.

The data constraint identified in step 156 is registered as a logical file in the data constraint / parts database 52 in association with the data item of the corresponding logical file (step 158). In the registered data constraint file, constraint rules for data constraints defined in the data analysis in step 156, data items using the data constraints, and the like are described. The data item described here indicates an association between the data item and the data constraint. That is, when a certain data item is specified, the data constraint (constraint ID) related to the data item must be known.

A unique constraint ID is assigned to each data constraint so that the data constraint can be identified from other data constraints by the constraint ID. In other words, data constraints are centrally managed using this constraint ID. This constraint ID can be represented by a file address or the like of the data constraint.

Next, a data component is produced based on the data constraint, and registered in the constraint data / component database 52 in association with the data constraint (step 160). It should be noted that the data component is manufactured on the principle of one constraint and one component. This data component is a source program (subroutine) describing processing logic for executing the corresponding data constraint, and includes interface parameters (input parameters required for executing the processing logic and output parameters output after the processing; Argument). In the source program, the component specifications of the data component (component overview)
Is described.

A unique component ID is assigned to each data component so that the data component can be identified from other data components by the component ID. That is, data components are centrally managed using this component ID. This component ID can be represented by a file address or the like of the data component. In addition, the relationship between the data constraint and the data component is shown in a data constraint file or a management area as a relation table between the constraint ID and the component ID. That is, when a certain data constraint (constraint ID) is designated, a data component (component ID) related to the data constraint must be known.

FIG. 3 shows the relationship between data items, data constraints, and data components in the database 52 created by the above procedure.

As shown in FIG. 3, a data item defined as a logical file is associated with a data constraint in a database or a transaction record.
The data constraint is associated with the data component. Further, a built-in program incorporating the data component is associated with the data component via a component ID. Since the files are associated with each other and stored in a database as described above, when the data constraint is changed, it is possible to immediately identify the data component, the embedded program, and the related data item to which the data constraint is applied. There are advantages.

Next, the configuration of the skeleton database 54 is shown in FIG. As shown in FIG. 4, the skeleton database 54 includes a plurality of template programs 1 and 2 having a standard program control structure (skeleton).
3,. . . . . , N, and a header area for management, in which data such as an outline of each model program is described, is provided in the head area of these model programs. The control structure of programs developed in business systems etc. can be classified into several patterns according to the characteristics of input and output, but these patterns are standardized and pre-registered as "models". It is.

The template program is as shown in FIG.
A pre-processing section for performing pre-processing, a main processing section for performing main processing, a determination section for continuing main processing until a predetermined condition is satisfied, a post-processing section for performing post-processing after completion of the main processing, (Example of the structure of the template program 1).

The main processing section of the template program 1 includes, for example, a custom point 1 for addressing a program to call out and execute a data part, a control processing for controlling after execution of the data part, and a custom point 1 And a custom point 2 for addressing a program that calls and executes a data component other than that specified by.

The program addressed by the custom point 1 is composed of one or a plurality of process blocks. For example, the process block 1 includes a component pre-call procedure logic and a component call CALL (call a described data component). The logic is configured in the order of the component call result determination logic.

The type of the component to be coded is defined at the processing location specified by each custom point, and the component defined by this type is mounted as described later.

The above model program is described in detail in FIG.
It can be configured as in Example 1 (order modification program). As shown in FIG. 11, the program includes a screen output system processing routine for executing a series of processes for outputting a screen, a screen input system processing routine for executing a process when data is input to the display screen. Consists of
These processing routines consist of unmounted processing points where components are to be coded (processes covered by solid rectangles), which processing points are specified by custom points, and the type of the component to be coded. Is defined.

The screen output system processing routine is described as “Order f (f
Is a file; read below), ". . . . . . ,
It consists of a process specified by a custom point of “start order input screen”, and displays the contents of the read order f as an order input screen. The order f reading process is executed by an order f reading component for reading the order f.

The screen input system processing routine includes custom coding of “external format database area special editing”,
“Single item & mandatory item constraint check”,. . . . . , A custom point process such as “start order confirmation screen display”, displays a screen for inputting the characteristics of the data items, checks the characteristics of the data items input on the screen, and if there is no error, the next Display the order confirmation screen.

The "single item & mandatory item constraint check" is a process of searching the data constraint / parts database 52 for the characteristics of the data items of the single item and the required items input on the screen and determining whether the condition of the characteristic of the data item is satisfied. Is defined as a routine for checking whether As the data component candidates to be coded at the custom point of “single item & mandatory item constraint check”, as shown in the figure, “user item standard check component”, “settlement condition item standard check component”,. . . . , “External-> internal format database area conversion”. Note that these components are associated with “constrained error processing components” that display an error when there is an error in the characteristics of the data item input on the screen as a result of the inspection.

The "item association inspection" is defined as a routine for inspecting the association between data items (parts). Among the component candidates coded in the “item-related inspection”, there is a user presence check component that checks whether or not a user who is to receive an order is registered. In addition, a relation destination f reading component for reading the relation destination f of the user is coded in the user existence check part.

Further, the component candidates coded in the “item-related inspection” include a “user & settlement-condition-item-related check component” for checking the order-receiving user and the settlement condition of the user. By activating the part, the settlement condition of the designated order receiving user is immediately found.

Further, a part candidate coded in the “item relation inspection” includes an “order received f subtype update item check part” for checking which subtype of the order received f is updated. By starting this part, the update subtype of the designated order receiving user f is immediately identified. In addition,
A constraint error processing component is associated with the received order f subtype update item check component, and this constraint error processing component performs error processing for subtype update input.

FIG. 2 is a functional block diagram of a program assembling apparatus having the above-described configuration.

As shown in FIG. 2, the program assembling apparatus according to the present embodiment includes a template program selecting means 70 for selecting a template program stored in the skeleton database 54. The model program selection means 70 is a model program selection screen 71 showing a summary list of each model program on the display 30.
Is displayed, and the user moves the cursor using the mouse 38 or the like, and selects the template program at the location clicked. The selected template program is read from the skeleton database 54 and temporarily stored in the RAM 12.

Further, the program assembling apparatus uses a screen layout creating means 7 for creating a layout of an input / output screen.
2 is provided. This screen layout creation means 72
Data item specification means 72a for specifying data items
And input / output identifying means 72b for distinguishing between input and output of a specified data item, and data characteristic input means 72c for inputting data characteristics of the specified data item.

The data item designation means 72a is an input means for the operator to input or select data items from the screen layout editing screen 73. The input / output identifying unit 72b is an input unit for inputting, from the screen layout editing screen 73, the input and output of the data item specified by the data item specifying unit 72a. Whether the data of the data item is input data or output data is identified by whether or not each item is clicked with the mouse 38. Then, for each data item displayed on the screen layout editing screen 73, the data characteristic input means 72c is used to input the characteristics of the data item (such as the data type, value, and number of digits that the data item can take). Input means. In addition, the operator
A screen layout can be created in accordance with the data items, inputs, and data characteristics specified using the screen layout editing screen 73.

Further, the program assembling device displays input item / part selection means 7 for displaying and selecting data components related to the designated data item by input item and output item.
4 and an output item part selecting means 76. In addition,
The input item refers to a data item input by the operator, and the output item refers to a data item to be output.

The input item component selection means 74 searches the data constraint / component database 52 to read out data component candidates related to the input item, and displays the component specifications of the data component candidates on the input item component selection screen 75. The user moves the cursor with the mouse 38 and selects a data component candidate at the location clicked as the data component of the input item.

The output item parts selection means 76 searches the data constraint / parts database 52 to read out data part candidates related to the output items, and displays the part specifications of the data part candidates on the output item parts selection screen 77. Then, the user moves the cursor with the mouse 38 and selects the data component candidate at the location clicked as the data component of the output item. These selected data components are temporarily stored in the RAM 12.

Further, the program assembling apparatus incorporates the data component selected by the input item component selection unit 74 and the data component selected by the output item component selection unit 76 into the template program selected by the template program selection unit 70, and executes the source program. Is automatically provided. Then, the program assembling means 7
8 displays the source program that has been assembled on the program editing editor 79. The user can use the program editing editor 79 to check the source program, change the order of the data components, and delete and modify the data components.

Further, the program assembling apparatus includes an execution program editing means 80 for converting the assembled and edited source program into an executable program, and a program execution means 82 for executing the execution program. The execution program editing means 80 compiles the assembled and edited source program, and executes the component execution module library 83 and the execution program library 84
From the above, other necessary execution form data components and subroutines are searched, and an execution program is created by linking them. The component execution module library 83 converts each component of the data constraint / component database 52 into an execution module and registers it as a library.

The progress of compilation and linking (error display, etc.) is displayed on the program execution editor 82.
Further, when the user clicks on the display position of the execution program in the program execution editor 81, the program execution means 82 executes the execution program.

The functional configuration of the program assembling apparatus described above can be realized by a program assembling support tool or the like (program assembling program) stored in the ROM 14.

Next, the flow of program production using the program assembling apparatus according to the present embodiment will be described with reference to the flowchart of FIG.

As shown in FIG. 7, first, the external specification (outline) of the production program is determined (step 200). At this stage, the functional outline of the program is determined.

Next, a model of the entry program (model program) suitable for the external specification of the program determined in step 200 is selected (step 202).
This selection is performed using the template program selection means 70 described above. In the following description, a case where the control structure of the selected template program corresponds to the control structure of three programs PG1, PG2 (corresponding to the program in FIG. 11) and PG3 in FIG. 9 will be described as an example. FIG.
Screens G1, G2, G3 indicate input / output screens of the programs PG1, PG2, PG3 whose screen layout is designed, respectively.

Next, the layout of the input / output screen of each program is created using the screen layout creating means 72 (step 204). In creating the layout of the input / output screen, data items are specified and input on the screen, and input items and output items are identified for each data item. In the example of the G2 screen in FIG. 9, black squares are input items (user, settlement condition, order No, charge of the issuance department section), and white squares are output items (order No., transaction, contractor).

Further, in the input / output screen layout creation processing of step 204, the characteristics (type,
Values, definitions, etc.). For example, in the example of G2 in FIG. 9, the data item of "user" designates alphabets and numbers, the number of digits of a user number, and the like.

Next, for the input item identified in step 204, data component candidates are displayed and a data component is selected (step 206). In the display of this data part, as shown in FIG. 10, a corresponding data restriction is searched from the data restriction / parts database 52 based on the name of the data item (input item), and a part candidate list associated with the restriction is displayed. I do.

For example, for the “user” input item on the screen G2, the data item definition is determined using the data item name = “user” as a key.

The data component is searched from the data constraint / component database 52 in the following flow based on the data constraint related to the determined data item definition.

Data item-> User item standard constraint-> User item standard check component (user)-> User DB existence constraint-> User DB existence check component-> User & settlement condition item related constraint-> User & settlement condition item Related Check Parts The operator selects a data part to be used in the production program from the displayed list of data parts, and clicks with the mouse 38 or the like. The selected data component is distinguished from other data components as indicated by the portion enclosed by the rectangle in FIG.

Similarly, for the output item identified in step 204, data component candidates are displayed and a data component is selected (step 208). In the display of this data component, a corresponding data constraint is searched from the data constraint / component database 52 based on the name of the data item (output item), and a component candidate list corresponding to the characteristic of the constraint is displayed. For example, a part that specifies the number of digits, type, and the like of the data of the output item is also included. Then, a data component to be used in the production program is selected from the displayed list of data components, and clicked with the mouse 38 or the like.

In step 208, step 20
It is checked whether the data characteristic specified in 4 is valid as the data item. If valid, a component to be executed with the specified data characteristic as a constraint is displayed. If not, an error message is displayed. Is done.

Next, the data parts of the input items and the output items selected in steps 206 and 208 are incorporated into the corresponding points of the custom points where the data parts in the template program selected in step 202 are defined. Automatically generates a source program (step 210).

For example, in the case of the data component related to the user input item of FIG. 10, it is incorporated in each custom point of PG2 shown in FIG. 11 as follows. That is, "single item & required item constraint check block" in FIG.
"User item standard check component" and "User presence check component" and "User & settlement condition item related check component" are incorporated in "Item related inspection block" (FIG. 11).
Parts shown with diagonal lines).

Further, components for inputting / outputting data with designated data characteristics for each designated input / output are incorporated in the processing portion for actually inputting / outputting data.

The program in which the data components are incorporated in this way is stored in the embedded program area 65 of the hard disk 22. At this time, the program is registered in association with the incorporated data component via the component ID.

Next, the program assembled in step 210 is edited as required (step 21).
2). In this editing work, the operator checks the assembled source program with an editor, changes or deletes the check order as necessary, and incorporates a group of components for automatic setting into the program.

Then, the edited program is tested (step 214). In this test, the edited source program is converted to an executable program by the compiler,
Register the definition such as the screen definition and start the execution program.

As a result of the test, if the program does not satisfy the desired condition (No at Step 216),
Returning to step 212, the program is edited again, and if the program satisfies the desired condition (step 216, affirmative determination), the program production ends.

When the order modification program (PG1, PG2, PG3) produced as described above is started,
As shown in FIG. 9, first, an order list screen of a screen G1 is displayed. In the screen G1, a transaction, a contractor, and a selection column input check item (mk) are displayed for each order number. Here, when any one of the check items of the selection column input check of the order number is clicked with the mouse 38, the PG2 is activated. However, if the user corresponding to the selected order number has not been registered, an error is displayed.

Order No. selected when PG2 is activated
Is read, and an order-indicated correction input screen G2 including data items of order number, transaction, contractor, user, settlement condition, order number, issue section charge, and error is edited and output. Then, the operator inputs data into the input items (black squares) of the edited and output data items. For example, user, settlement condition, order No. And the like, and press the ENTER key of the keyboard 34. When the key is pressed, it is checked whether or not the data input to the input item is appropriate. If there is an error, an error is displayed. In the case of an error display, the operator corrects the input data of the input item until the error display disappears.

If there is no error, PG3 is started and the order indication confirmation screen G3 for data item confirmation is edited and output. The operator checks the order confirmation screen G3, and if there is no error, presses the ENTER key of the keyboard 34, and if there is an error, corrects it again. When the ENTER key is pressed, PG1 is activated again, an order memo list is displayed, and the same processing is repeated for the next selected order number. According to the above-described program assembling apparatus according to the present embodiment in which the order indication correction of the order is executed in this manner, the program is semi-automatically produced in an interactive manner with the user. Not only can the work be performed efficiently, but also because the structure of the produced program is reduced because the model program is based, the quality is improved. Further, in the data constraint / parts database, the use state of parts is managed, so that maintainability is improved.

Furthermore, the constraints are made independent of the means for realizing the system (technical environment, operating environment, etc.), and defined independently of the technical base of the system construction, in other words, the constraints are influenced only by business changes. By doing so, it becomes easy to replace parts and rearrange parts in response to constraint changes due to business changes, and the quality, productivity, and maintainability of programs in program development are significantly improved.

Further, data constraint / parts database 5
2 can be accessed from another terminal device via a communication line to share a database, and reuse of data components can be suppressed to suppress duplicate production. In addition,
The data constraint / parts database 52 may be created as a database of a host computer accessible from a program assembling apparatus having a communication unit.

In addition, the required realization functions are often excessive or insufficient due to the fragmentary knowledge / preconceptions of the user, and often include potential inconsistencies (bugs). By showing the screen and the operation method to the user at an early stage, the possibility that the latent request can be found is increased. Then, if a group of parts relating to data items used in the business is prepared in advance and a prototype (model) of the program structure is prepared, the program assembling apparatus according to the present embodiment is used to interact with the use department. A method for developing a system can be realized. In addition, inquiry-related programs and the like can be designed / produced by the department in use. (Second Embodiment) In the first embodiment, a program assembling apparatus is realized by software pre-installed in a ROM such as a personal computer or a workstation. However, the program assembling apparatus is implemented in a tangible storage medium such as a floppy disk or a CD-ROM. It is also possible to use software distributed via the stored one. This will be described below as a second embodiment.

FIG. 16 shows the configuration of a personal computer 11 according to the second embodiment and the contents stored in a CD-ROM storing software for causing the computer to function as a program assembling apparatus. I have. Note that the same components as those of the first embodiment are denoted by the same reference numerals, and detailed description is omitted.

As shown in FIG. 16, the personal computer 11 is provided with a CD-ROM drive 21 capable of reading data stored on a CD-ROM as a storage medium. A system bus 1 is provided via a CD-ROM control unit 19 for controlling an interface between the drive and the microprocessor 10.
6 is connected.

The CD-ROM control unit 19 includes:
DMA controller 18 connected to system bus 16
Are connected, and the DMA controller 18 directly accesses the RAM 12 without passing through the microprocessor 10 to enable high-speed data transfer.

As shown, the CD-ROM 23 according to the present embodiment to be inserted into the CD-ROM drive 21 includes the program assembling support tool according to the first embodiment in the personal computer 11. In addition to the assembling program 51 for realizing the same program assembling function, the same data constraint / component database 52, skeleton database 54, DB access component 56, process constraint component 58, and general-purpose function component 6 as in the first embodiment are used.
0, an MMI control component 62, and a control component 64 (hereinafter referred to as “assembly data group”). Further, the CD-ROM 23 stores a utility 67 for executing various functions such as a function for installing the assembly program 51 and the like in the personal computer 11, a help function, and a function for compiling the assembled source program. ing. The assembly program and the data group for assembly stored in the CD-ROM 23 can be stored in a compressed format.

By inserting the CD-ROM 23 into the CD-ROM drive 21 and activating the installation program, the assembling program 51 and the assembling data group stored in the CD-ROM 23 are transferred to the hard disk 2.
2 can be installed. If the assembling program and the assembling data group are compressed, they are decompressed and generated in an executable format under a predetermined directory structure.

The assembly program 51 includes the template program selection means 70, screen layout creation means 72, input item parts selection means 74, output item parts selection means 76, program assembly means 78, and execution program editing means shown in FIG. Each function of 80 and the program execution means 82 is configured as a program for being realized by the personal computer 11.

Therefore, when the installed assembling program is executed, a program can be semi-automatically produced in an interactive manner with the user by a procedure similar to the procedure shown in the flowchart of FIG. The produced program is stored in the hard disk 22.

As a result, the same effects as those of the first embodiment can be obtained, and all computers having an operating system and a hardware environment capable of executing the assembling program are realized as a program assembling apparatus. And the versatility of the present invention can be greatly expanded.

In the example shown in FIG. 16, one CD-RO
Although the assembling program 51 and the assembling data group are stored in M23, the assembling program 51 and the assembling data group may be stored in different CD-ROMs and provided.

The data group for assembly installed on the hard disk 22 is transferred to the personal computer 11.
By the operation described above, the user himself can also upgrade the version. Further, when the assembling program 51 and the assembling data group are provided on separate CD-ROMs as described above, the newly provided CD-ROM is used.
It is also possible to upgrade each version individually.

Further, the assembly program can be executed by directly accessing the CD-ROM without installing the assembly program 51 and the assembly data group in the personal computer 11. in this case,
The assembly program may be executed by temporarily reading a part of the data read from the CD-ROM into the RAM 12. In addition, only one of the assembly program and the assembly data group or only some of the data and some of the subroutines are installed.
23 may be read.

The above is one example of the program assembling apparatus according to each embodiment of the present invention, but the present invention is not limited to the above example. For example, it goes without saying that components having restrictions other than those described above can be incorporated into a template program.

Also, the program assembling apparatus according to the present embodiment is realized by a personal computer, a workstation, or the like, and software pre-installed therein or software stored in a tangible storage medium.
It may be realized using software (procedure) distributed via transmission means such as a wired or wireless commercial network. Further, it can be configured as a dedicated device.

Furthermore, in the second embodiment, a CD-ROM is used as an example of a storage medium, but the present invention is not limited to this, and any computer-readable storage medium may be selected. Can be. Such storage media include, for example, floppy disks, magneto-optical disks,
There are a magnetic tape, a DVD-ROM, a DVD-RAM, and the like.

[0157]

EXAMPLE The program assembling apparatus described in the above embodiment was operated under the following environment and verified.

In the data constraint / parts database, “D
ATAMANAGER "(MSP) was used.

In the program assembling apparatus, the template program selecting means 70, the screen layout creating means 72, the execution program editing means 80, and the program executing means 82 of FIG.
N "(ACA).

"TELON" is, as shown in FIG.
It has a unique custom point, and the incorporation of parts into each custom point uses the transport function provided by "TELON".

In the program assembling apparatus, the input item check specification selecting means 74, the output item editing specification selecting means 76, and the program assembling means 78 in FIG. 2 were operated by developing a “TELON / repository cooperation tool” in-house.

The verification model of the present embodiment was developed based on “development of order modification program”.

FIGS. 13, 14 and 15 show examples of source programs assembled by activating the program assembling apparatus in this embodiment. 13 to 15 show the source program code divided and displayed for each 1/3 portion.

The following results were obtained as verification results. (1) It has been confirmed that the program information of the verification model can be sufficiently managed by the structure of the data constraint / parts database.

(2) The form of incorporation into the template source program has been determined. Specifically, the position of the custom point and the like have been determined. In addition, the system for semi-automatically incorporating database-constrained parts could be arranged.

[0166]

As described above, according to the first aspect of the present invention, a component program for executing a restriction when inputting / outputting data in a data item handled in a business is stored in advance,
A part program that executes constraints related to this data item simply by specifying the data item is incorporated into the corresponding processing part of the template program, so the structure of the created program has less variation and the quality is improved. In addition, by reusing the component program, it is possible to prevent duplicate development.

According to the second aspect of the present invention, a component program for executing a restriction when inputting / outputting data in a data item handled in a business is stored in advance, and data items, input / output, and data characteristics are stored. The part program that executes the constraints related to this data item, input / output, and data characteristics just by specifying it is incorporated into the template program, so the structure of the manufactured program is less scattered and the quality is improved. In addition, by reusing the component program, it is possible to prevent duplicate development.

According to the third aspect of the present invention, the extracted part program can be selected, so that in addition to the above-described effects, an effect that the program production work can be performed more efficiently can be obtained.

According to the fourth to seventh aspects of the present invention, in addition to the effects of the first to third aspects,
All computers having an operating system and a hardware environment capable of executing the stored assembling program can be realized as the program assembling apparatus of the present invention, and the versatility of the present invention can be greatly expanded. The effect is obtained.

[Brief description of the drawings]

FIG. 1 is a diagram showing a configuration of a program assembling apparatus according to a first embodiment of the present invention.

FIG. 2 is a functional block diagram of the program assembling apparatus according to the first embodiment.

FIG. 3 is a diagram illustrating a schematic configuration of a data constraint / parts database of the program assembling apparatus according to the first embodiment;

FIG. 4 is a diagram showing a schematic configuration of a skeleton database and a schematic configuration of a template program of the program assembling apparatus according to the first embodiment.

FIG. 5 is a diagram illustrating a method of classifying restrictions in the program assembling apparatus according to the first embodiment.

FIG. 6 is a diagram showing a method of classifying parts of the program assembling apparatus according to the first embodiment.

FIG. 7 is a flowchart illustrating a procedure for producing a program using the program assembling apparatus according to the first embodiment;

FIG. 8 is a flowchart illustrating a procedure for creating a data constraint / parts database of the program assembling apparatus according to the first embodiment;

FIG. 9 is a diagram showing an input / output screen and a program configuration when an order modification program is produced using the program assembling apparatus according to the first embodiment.

FIG. 10 is a diagram showing the relationship among data items, order files, data constraints, and component modules when an order modification program is produced using the program assembling apparatus according to the first embodiment.

FIG. 11 is a diagram showing a detailed configuration of an order modification program manufactured by the program assembling apparatus according to the first embodiment.

FIG. 12 is a diagram showing an online program structure of “TELON” for realizing an assembling function of the program assembling apparatus according to the first embodiment and custom points.

FIG. 13 is a diagram showing a code result of a source program assembled using the program assembling apparatus according to the first embodiment.

FIG. 14 is a diagram showing a code result of a source program assembled using the program assembling apparatus according to the first embodiment.

FIG. 15 is a diagram showing a code result of a source program assembled using the program assembling apparatus according to the first embodiment.

FIG. 16 is a block diagram showing the configuration of a personal computer according to a second embodiment of the present invention and the storage contents of a CD-ROM storing software and data for causing the computer to realize a function as a program assembling apparatus; FIG.

[Explanation of symbols]

23 CD-ROM 51 Assembly program 52 Data restriction / parts database (first storage means) 54 Skeleton database (second storage means) 70 Model program selection means (second extraction means) 72 Screen layout creation means 72a Data items Designation means (designation means) 72b Input / output identification means (designation means) 72c Data characteristic input means (designation means) 74 Input item parts selection means (first extraction means, parts selection means) 76 Output item parts selection means (first Extraction means, part selection means) 78 Program assembling means (program assembling means)

Claims (7)

[Claims] 1. A program assembling apparatus for assembling a program including a data input or output process for a data item defined in a business, comprising: a data item; and a constraint when data is input or output in the data item. A first storage unit that stores the component programs in association with the component programs that execute the component programs, and has an unmounted processing location in which the component programs are to be mounted, and the type of the component program to be mounted in the processing locations is A second storage unit that stores at least one defined template program; a designation unit that designates a data item; and a constraint when data is input or output with the data item designated by the designation unit. A first extraction unit for extracting a part program to be executed from the first storage unit; and one of the templates from the second storage unit. A second extraction means for extracting a program, and a processing location in which the type of the component program of the template program extracted by the second extraction means is defined by the component program extracted by the first extraction means. And a program assembling means to be incorporated into the program. 2. A program assembling apparatus for assembling a program including a data input or output process for a data item defined in a business, comprising: a data item; and restrictions when data is input or output in the data item. Storage means in which a component program to be executed according to the characteristics of the data and input / output is stored in association with each other, and a processing location where the component program is not to be mounted, and A second storage unit storing at least one template program in which a type of a component program to be mounted at a location is defined; a data item; characteristics of data input or output in the data item; and the data item Means for designating the input / output of data at the time of inputting and outputting data in the data item designated by the designating means. A first extraction unit for extracting a part program for executing the approximation from the first storage unit in accordance with the characteristics and input / output of designated data; and any one of the template programs from the second storage unit And a part program extracted by the first extracting means in a processing location where the type of the part program of the template program extracted by the second extracting means is defined. A program assembling apparatus, comprising: a program assembling means to be incorporated. 3. A component selecting means for selecting a component program extracted by the first extracting means, wherein the program assembling means converts the component program selected by the component selecting means into the second program. 3. The program assembling apparatus according to claim 1, wherein the model of the part program of the template program extracted by the extracting means is incorporated in a defined processing location. 4. A first data area in which a data item defined in a business and a component program for executing a restriction when data is input or output in the data item are stored in association with each other, A second data area that has at least one template program that has an unmounted processing location where the component program is to be mounted and that defines the type of the component program to be mounted at the processing location; A computer-readable storage medium storing an assembling program for assembling a program based on the information of the assembling program, wherein the assembling program includes: a designation function for designating a data item; and a data item designated by the designation function. Extracting, from the first data area, a component program for executing a restriction when data is input or output by the first extraction Function, a second extraction function of extracting any one of the template programs from the second data area, and a component program extracted by the first extraction function are extracted by the second extraction function. A storage medium, which is a program for realizing, by a computer, an assembling function to be incorporated in a processing location where the type of the part program of the template program is defined. 5. A first data area in which a data item defined in a business and a component program for executing a restriction when data is input or output in the data item are stored in association with each other, A second data area that has at least one template program that has an unmounted processing location where the component program is to be mounted and that defines the type of the component program to be mounted at the processing location; A computer-readable storage medium storing an assembling program for assembling a program based on the information of the data item, wherein the assembling program includes a data item, characteristics of data input or output in the data item, and the data item Function for specifying the input / output of data at the time, and data input or output with the data item specified by the function The part program for executing a constraint as it is, according to different characteristics of the specified data and input and output,
A first extraction function for extracting from the first data area, a second extraction function for extracting any one of the template programs from the second data area, and a component extracted by the first extraction function A storage medium, which is a program for realizing, by a computer, an assembling function of incorporating a program into a processing location where the type of the part program of the template program extracted by the second extracting function is defined. 6. The assembly program further comprises: a component selection function for selecting a component program extracted by the first extraction function, wherein the assembly function is a component program selected by the component selection function. 6. The storage medium according to claim 4, wherein said function is a function of incorporating the component program into a processing location defined by a type of said part program of said template program extracted by said second extraction function. 7. The storage medium according to claim 4, further comprising a generation program for generating said first and second data areas in another storage means.
Storage medium for terms.