JP2000122903A - Method for processing information and computer system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method for processing structured information which is to be stored in the data base of a computer system. SOLUTION: In the method, grammar 14 describing the structure of information is decided and a data base schemer 10 is derived from the grammar 14. A mapping rule is generated from the grammar 14 and structured information 16 is stored in a data base 12 in accordance with the schemer and the mapping rule. The method can be used for transferring data to the data base 12 and reading data from the data base 12.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates generally to a method for processing information, and more particularly, to a method for processing structured information to be stored in a database and a method for transferring such information to a database. About the method.

[0002]

BACKGROUND OF THE INVENTION Very often, a given amount of information originating from party A must be read and processed by party B. Such information can exist in a huge variety of formats and can include numbers, words, sentences, and various variations of free text, tables, and the like. In modern times, such information is generated in large quantities and needs to be quickly and reliably processed and understood by the recipient. In addition, such information is often supplied to a database on the data transfer receiving side. A person receiving such information from a number of different sites and storing such information in a large database system must first read the information from the database, and then store the "package" Or, more generally, a large amount of information must be analyzed. The person can then understand the information. Without such a step of analyzing the information, the stored information would contain data,
There is no real value other than being remembered in the carrier. Such an information package is known as BLOBS (= Binary Large Object).
Such a BLOBS must be analyzed and, therefore, if its structure is not determined to be known,
No one can read it and understand the information contained in BLOBS.

A problem arises when it is necessary to read the contents of many BLOBS and evaluate them in the same way as was done for the contents of the database. Such evaluations include queries that selectively access a given content of a database, the result of which is a detailed list of queried information that is stored by individual criteria. When storing multiple BLOBS in a database,
With prior art techniques, a separate parsing process must be performed for each BLOBS, and it is not possible to immediately direct queries to multiple BLOBS without pre-parsing it. Thus, any assessment of a large amount of stored information can be a lot of work and time consuming, but the information is stored in an electronically readable form.

In view of the above, it should be apparent that a need exists for a method for processing large amounts of structured information that should be stored in a database of a computer system more comfortably and more quickly.

[0005]

SUMMARY OF THE INVENTION It is, therefore, one object of the present invention to provide an improved method for processing structured information to be stored in a computer system database.

It is another object of the present invention to provide an improved method for transferring information from an external site into a database.

It is still another object of the present invention to provide a computer system in which a database management system configured to execute a computer program for realizing the processing method according to the present invention is installed.

[0008]

The main idea to achieve the above object is to directly derive database schema information from a given grammar that characterizes the structure of the file contents to be transferred. Creating a database schema directly from the grammar. The schema information is derived during parsing with the help of grammar. The mapping rules indicate how to map content that adheres to a given grammar, and are derived at the same time as the schema information is derived.

[0009]

BRIEF DESCRIPTION OF THE DRAWINGS FIG.
With particular reference to FIG. 1, a given amount of structured information 100 will be described as being subject to the processing method of the present invention. The steps to be described for processing said quantity of information are part of the method, advantageously partly performed on the sending computer system and partly performed on the receiving computer system Is done. These computer systems include programs and tools that enable the above steps to be performed.

The information 100 is electronic (computer readable)
Included in the file.

The grammar is determined according to the amount of information 100, using, for example, a naming convention such as a given file extension or by side information (step 110).

A database schema corresponding to the grammar (here for a relational database) is derived from this grammar as shown in step 120.

Next, in an additional step 130, a mapping rule is generated which determines how to map the structured content of the information described by the grammar to a plurality of tables comprising a database schema.

Finally, at step 140, the database can be filled with information corresponding to the database schema and pre-established grammar rules.

As a result, in the case of this "grammar-based mapping", the information is stored in a structured format in a table of a relational database system. An advantage of the above method according to the present invention is that the database user can query the contents of the database and create a detailed query that brings up all the desired information in a sorted format, Tables are also easy to understand because they are generally semantic unities. Thus, parsing the information need not be part of the read access to the database, as in the prior art techniques.

Referring now to FIG. 2, a first simple embodiment of the processing method describes a so-called “simple grammar-based mapping”.

In simple grammar-based mapping, the complete schema 10 of the database 12 is derived and generated from a grammar 14 describing the structured information file contents 16. The mapping rule 18 indicates a method of mapping the content that adheres to the grammar to the database described by the derived schema, and is also derived statically by the grammar.

The following grammar example is just one of many possible applications of this technique. This is, for example, a simple grammar for describing nestable record structures for special computer languages.

[0019]

[Table 1]

This illustrative grammar shows that a record starts with an optional name of its structure, and then the keyword "STRUC"
"T" followed by zero or more MEMBERs, ending with the keyword "END". MEMB
ER consists of IDENTIFIER followed by TYPE. Next, IDENTIFIER is a concatenation of one or more alphabetic characters, and TYPE is the keyword "STRIN".
G "or" INTEGER "or a nested record.

The following relational schema can be derived from this grammar.

[0022]

[Table 2]

The corresponding mapping rule would be as follows:

If the "RECORD" rule of this grammar is applied, a new row is inserted into the table RECORD_TABLE, generating a unique number identifying the record, and placing this number in the record_key field of that row. Next, the name of the record, if any, and the actual number of MEMBERs are entered in the columns record_name and numbe of that row.
Put in r_of_members. For all MEMBERs, field pa by record_key value of this record
Update the corresponding row by updating rent_recore_key. ENDIF

If the MEMBER rule of this grammar is applied, insert a new row in the table MEMBER_TABLE, generate a unique number in this table and put it in the member_key field of that row. "IDENT
Put the value of "IFIER" in the member_name of that row. If this member is of type "STRING", simple_t
Put 0 in the ype field and NULL in the complex_type field. If the type is "INTEGER", enter 1 in the simple_type field and enter complex_type
Put NULL in the field. Next, if the type is a record structure, the re
Put the cord_key value in the complex_type field and use simple_t
Put NULL in the ype field. ENDIF

The following example demonstrates the above mapping. The following describes personal data, the structure of which adheres to a given grammar.

[0027]

[Table 3]

For a mapping rule according to the above, the result of the grammar-based mapping would be:

[0029]

[Table 4]

Thus, when filling a database with information of a plurality of different quantities or packages having a structure that can be generalized and described by the grammar 14 according to the above, first the same plurality of Bs, which would correspond to the prior art,
A comfortable read or query from a database containing a complete up-to-date query can be performed without having to analyze the LOB.

FIG. 3 shows a second embodiment of the processing method of the present invention.
In this embodiment, a so-called “compound grammar-based mapping” is described.

In a compound grammar-based mapping, the schema 10 is not always completely derived by the grammar 14, but if a given rule of the grammar applies to the content, the grammar and the so-called meta-context 20
Derived by both. The schema 10 can be derived, in part, from the grammar, and can both perform schema extension and map information to a database during parsing.

In order to explain this in more detail, in the above-mentioned "record", it is desirable to generate its own table for each record depending on the context and register each generated table in the registration table. Would. This context would reflect, for example, the needs of a given user or application.

The table to be created can be known only at the time of analysis. In this example, only one table is statically derived from the following grammar. RECORD_REGISTRY_TABL
E includes all records where the table exists. Table "RECORD_REGISTRY_TABLE" has column "record_
table_name ", which is the primary key for this table.

Thus, this rule creates schema extension information, eg, additional database tables, or creates additional rows or fields in already created tables, as compared to “simple grammar-based mapping”. And other rules.

In this example, a set of rules is as follows.

When the "RECORD" rule of this grammar is applied, a new table is created in the schema. The name of the table is indicated by the name of the parsed record. The columns of that table are (membe as varchar
r_name, simple_type as integer, varchar
complex_type). member_name is a primary key. Record name (IDENTIFIER value) to REC
Put in ORD_REGISTRY_TABLE table. If no record name is given, create a unique one. ENDIF When the MEMBER rule of this grammar is applied, a new row is inserted into the table corresponding to the record to which this member belongs. Set the value of IDENTIFIER to member_n of the row
Put in ame. If the type of this member is "STRING", put 0 in the simple_type field, and
Put NULL in the ype field. If the type is "INTEG
If "ER", enter 1 in the simple_type field and NULL in the complex_type field. Next, if the type is a record structure, change the record name to co
Put in mplex_type field and put NULL in simple_type field. ENDIF

The following example is analyzed.

[0039]

[Table 5]

This schema has a table "PersonData"
And can be extended by "SubRecord1".
In other words, no record name is shown for nested records, so the name "SubRecord
1 "will be created.

[0041]

[Table 6]

After analysis, the table will contain the following data:

[0043]

[Table 7]

As described in the first embodiment, comfortable reading or querying from the database can be performed without analyzing the BLOB in advance.

Referring now to FIGS. 4 and 5, there is shown an example relating to the application of the processing method according to the invention, in which direct read / query access to the database 12 can be performed without prior analysis of the information.

The receiving party B (right side of FIG. 5) is to receive a plurality of information packages of the same type, ie, information packages having a common general structure, from various parties, one of which. One (party A) is shown on the left side of FIG.

B can be a hospital database that receives a given amount of patient data from physician A's clinic computer. It is expected that the same type of data, ie, the information package, will be transferred for each of the patients in A.

Party A designs or uses (400) one or a set of so-called DTDs (Document Type Declarations) containing the grammatical rules that characterize the content of the information to be transferred.

Next, at step 410, one of the DTD files 30 is sent to B. This can be in any electronic form or in the form of a document sent as a letter from A to B.

Next, in step 420, B receives the DTD file 30, and generates the database schema 10 according to the information contained in the DTD file.

As shown at the top of FIG. 5, A sends the DTD file to B in step 410 of FIG. As can be seen from the database symbol 12, the database
Schema 10 is derived from the DTD file contents and is dynamically generated upon receipt of the DTD file as indicated by the four “dummy” points in database 12. Once the database schema 10 is complete and the computer system on which the database 12 resides is ready to receive data, data transfer can begin.

In the next line of FIG. 5, the information package is sent from A to B. This information is split into four tables representing the recipient B's illustrative database schema. Thus, all information is stored at its exact location in the database. This sending process is repeated a given number of times, and the amount of information stored in B's database is growing. Third party C is also shown to send the same type of information to B's database.

As shown in the lower right part of FIG.
The entire stored information can be accessed by an up-to-date query that selects the desired table contents from the database. BLOBS analysis is not required as in the state of the art.

Returning to FIG. 4, in step 430, A
Sends a given amount of information (files, multiple information packages such as emails) depending on the grammar rules and database schema set up in B's computer system. This is shown as the second "row" in FIG.

In the next step 440, B's computer system receives the amount of information and
Database table 3 according to schema 10
2 automatically stored. As can be seen from the loop shown in FIG. 4, the sending process of A can be repeated as often as necessary. Alternatively, the other party C (another doctor's clinic) can send an additional amount of the same type of information shown in the third row of FIG. Next, since the latter information is structured in the same way as the information of A, it is stored in the same manner.

As a result, the receiving side database 12
Are correctly structured and filled with the information stored in the corresponding database table 32. Thus, individual queries can be set up immediately and comfortably by B's staff over the entire volume of information package transferred, without the need for any BLOB analysis when reading data from the database. Thus, the amount of time required to read and understand data from the database is minimized.

Steps 120 and 130 of FIG. 1 will now be described in more detail, with particular reference to the so-called context-free grammar which forms the main application part of the method of the invention. The structure of the file contents, or more generally, the structure of the information package or quantity in the terms of the present application, is often described by a context-free grammar. In this case, the non-terminals of the grammar are mapped to tables in a relational database system. This is a natural mapping, since non-terminals are typically used to describe a semantic entity group syntactically. Next, such an entity
Groups can be mapped to tables.

Without loss of universality, the rules of a context-free grammar are assumed to be of the form

[1] ls ==> rs1 rs2 ... rsN or [2] ls ==> rs1 rs2 ... rsN or [3] ls ==> (rs) + or [4] ls ==> (rs) *

Ls represents “left side”, and rs represents “right side”. ls always represents a non-terminal, and rs represents any of a terminal, an empty-terminal, and a non-terminal.

[1] is referred to as a structure connection, and means that the left side is formed by connection of one or more terminals or non-terminals on the right side.

[2] is referred to as structure selection and means that the left side is correctly composed of one terminal or non-terminal on the right side.

[3] is called one repetition of the structure, and means that the left side is constituted by one or more repetitions of rs.

[4] is called zero repetition of the structure and means that the left side is constituted by zero or more repetitions of rs.

Each context-free grammar can be described by a finite set of rules, each of which adheres to one of the above four patterns. Further, without loss of universality, it can be assumed that each non-terminal appears exactly once on the left side of the rule. Regular expressions are a special subclass of context-free grammar, and can therefore be described by a set of rules that adhere to these patterns. In practice, non-terminals are divided into token classes and real non-terminals. The former is recognized by the lexical analyzer, and the latter is recognized by the parser. In the above example, these groups are quoted for the terminal, such as 'name', 'A', '0', ':', and <STRING>, <IDE
<> For token class such as NTIFIER>, <NUMBER>, ADDRESS, EMPLOYER
It is distinguished by an uppercase word without a prefix or suffix for non-terminals, such as _NUMBER.

"Real non-terminal" is called a non-terminal.

The "simple grammar-based mapping" of such a rule would be as follows:

A table is created for each non-terminal. Further, a primary key is automatically created for each table. This is just a number that clearly identifies the line. This key is automatically incremented for each new row inserted into the table.

For each rule that matches pattern [1],
A column representing the foreign key of each non-terminal on the right of the rule is added to the table corresponding to the non-terminal on the left of the rule. A varchar column is added for each token class on the right side of the rule. If the rule matches during parsing, the foreign key is placed in the appropriate column for each non-terminal to the right of the rule, and the specific value is placed in the appropriate column for each token class.

For example, the grammar rules are as follows.

[0071]

[Table 8]

As a result, the following schema extension is performed.

[0073]

[Table 9]

The character string "Name: John Miller No: 00000"
7 "," Name: Liz Parker No: 000011 "," Name: Cind
After parsing "y Smith No: 000003", the following items will be generated.

[0075]

[Table 10]

Note that the value of column "name" of table EMPLOEEEE refers to a row of table NAME.

For each rule that matches pattern [2],
A column representing the foreign key of each non-terminal on the right of the rule is added to the table corresponding to the non-terminal on the left of the rule. For each token class, a varchar column is generated, and if there is a terminal on the right, a varchar named "terminal_value"
A type column is generated. If the rule matches a non-terminal during parsing, the foreign key is placed in the appropriate column for the matching non-terminal on the right of the rule, and all other columns are set to NULL. If the rule matches the token class, its specific value is placed in the appropriate column, and all other columns are set to NULL. If a terminal matches on the right side, the value of that terminal is placed in the "terminal" column and all other columns are set to NULL.

For another illustrative potential file content, the grammar rules are as follows:

[0079]

[Table 11]

As a result, the following schema extension is performed.

[0081]

[Table 12]

Character strings "A: Dog", "P: Oak", "P: Ald
The following items will be generated when analyzing "er" and "A: Squirrel".

[0083]

[Table 13]

Another example is provided for a thorough understanding. In this example, customers can be identified by name or customer number. Order can be placed on a table, chair, or S
It can be another one corresponding to the any_other_subject column of the UBJECT table. The grammar rules are as follows.

[0085]

[Table 14]

As a result, the following schema extension is performed.

[0087]

[Table 15]

The character string "Order from: John Miller Subjec"
t is: Table '', `` Order from: 000918 Subject is: Wa
ter '', `` Order from: Liz Parker Subject is: Ca
r "," Order from: Cindy Smith Subject is: Chair "
The following items will be generated when analyzing.

[0089]

[Table 16]

For each rule that matches pattern [3] and has a non-terminal on the right, a column for primary key purposes is added to the table corresponding to the non-terminal on the left of the rule. Also, a column for counting purposes is added to this table and functions as a part of the primary key. For the right non-terminal, a foreign key column is added to the table. If the rule matches during parsing, a row containing the item's sequence number and foreign key is created and inserted into the table for each instantiation on the right.

For example, the grammar rules are as follows.

[0092]

[Table 17]

As a result, the following schema extension is performed.

[0094]

[Table 18]

The string "John Miller Liz Parker Cindy S"
The following items will be generated when analyzing "mith" and "Elvis Presley Sandra Brown".

[0096]

[Table 19]

For each rule that matches pattern [3] and has a token class on the right, a column for primary key purposes is added to the table corresponding to the non-terminal on the left of the rule. A column for counting purposes is also added to this table, which also functions as a part of the primary key. For the token class on the right, a varchar column is added to the table. If the rule was applied during parsing, for each instantiation on the right, a row containing the item's sequence number and specific token class value is created and inserted into the table.

For example, the grammar rules are as follows.

[0099]

[Table 20]

As a result, the following schema extension is performed.

[0101]

[Table 21]

The strings "John Liz Cindy" and "Elvis
The following items will be generated when analyzing "Sandra".

[0103]

[Table 22]

For each rule that matches pattern [3] and has a terminal on the right, a column for primary key purposes is added to the table corresponding to the non-terminal on the left of the rule. A column for counting purposes is also added to this table. If the rule is applied during parsing, a row containing the number of occurrences of the terminal is created and inserted into the table.

For example, the grammar rules are as follows.

[0106]

[Table 23]

As a result, the following schema extension is performed.

[0108]

[Table 24]

Character strings "000000000000", "00"
The following items are generated when “0” and “000000” are analyzed.

[0110]

[Table 25]

For each rule that matches pattern [4], the same rule as in case of [3] is applied.

The processing and forwarding method according to the invention is advantageously implemented in XML (Extensible Markup Language, Extens
ible Markup Language) documents. This is because each XML document optionally references a document type declaration file (DTD). As is known in the art, DTD describes the structure of an XML file using primarily regular expressions, among other constructs.
The following sample DTD demonstrates that a DTD created in XML can be applied to the processing and forwarding method according to the present invention. This DTD contains the structure of the list of employees.

[0113]

[Table 26]

An XML document that adheres to the above DTD may be as follows.

[0115]

[Table 27]

This XML document describes a list of employees including their names and mutual relationships. It must be emphasized that the structure of this XML document is indicated by the DTD and that the DTD describes this structure like a grammar by regular expressions.

The DTD rules must be interpreted as follows.

[0118]

[Table 28]

According to this rule, the list of employees includes one or more employees, and such a list has the tag <list_
of_employees> and </ list_of_employees>.

[0120]

[Table 29]

These rules indicate that one employee must include one name, may include multiple e-mail addresses, and may optionally have a designated link. I have. In addition, employees must have unique IDs. Employee items in the content file must be tagged with <employee> and </ employee>.

[0122]

[Table 30]

These rules indicate that the name is composed of a surname and a baptismal name, and that it is composed of an arbitrary character string.
Name entries in the content file must be tagged with <name> and </ name>. Last names and baptisms must also be tagged with <family>, </ family>, and <given>, </ given>.

[0124]

[Table 31]

This rule indicates that an electronic mail is composed of an arbitrary character string. Email item is <email>
And </ email>.

[0126]

[Table 32]

These rules indicate that one link has two optional attributes, one referring to the manager and the other referring to the list of subordinates.

Each <! ELEMENT ...> item is called an element type. In the above example, list_of_employees, employee, emai
It shows seven element types, l, name, family, given, and link.

A document element adheres to the structure of a given element type,
It can have attributes (also defined in the DTD). These attributes are described by <! ATTLIST ...> items.

Here, it can be seen that the method of the present invention can be applied to a relational database by describing element mappings that adhere to element type definitions.

One of the simple embodiments of this mapping technique
One would create a table for each element type in a database schema, exactly the same way as in context-free grammar.

Accordingly, the following table can be generated.

[0133]

[Table 33]

The columns in the above table correspond to the definition of the element type itself and its attributes. In this example, exactly the same rules are used as in the context-free grammar, so we get the following table definition:

[0135]

[Table 34]

In the foregoing specification, the invention has been described with reference to specific illustrative embodiments. It will be apparent, however, that various modifications and changes may be made without departing from the broader spirit and scope of the invention as set forth in the appended claims. Accordingly, the specification and accompanying drawings are to be regarded in an illustrative, rather than a restrictive, sense.

The processing method according to the present invention is also applicable to an object-oriented database for storing structured information.

In summary, the following items are disclosed regarding the configuration of the present invention.

(1) A method for processing structured information (100) to be stored in a database of a computer system, comprising the steps of: (110) determining a grammar describing the structure of the information; A method comprising: deriving a database schema (120); generating mapping rules from the grammar (130); and storing structured information in the database according to the schema and mapping rules (140). (2) The method according to the above (1), characterized by mapping a grammar non-terminal to the table (32) of the relational database (12). (3) The method according to (2), wherein the structured information (100) is described using a context-free grammar. (4) The structured information (100) is described using a context-free grammar, and a document description file 30 reflecting the structured content of the plurality of information packages (100) is generated. (3) characterized in that the database schema (12) is derived.
The method described in. (5) The method according to (4), wherein the structured information (100) is described using XML. (6) The method according to the above (5), wherein a grammar non-terminal is mapped to a structural element of the object-oriented database system. (7) A method of transferring a certain amount of information from an external site into a database, wherein the amount of information is a plurality of at least similarly structured information packages that can be generalized by a common general information structure. (100), wherein the method characterizes the general structure of the information package (100) to be transferred.
D) once, and a document description file (3)
Generating a database schema (10) once in the receiving database (10) in response to 0);
A method comprising: sending the plurality of information packages (100) to a receiving database (12); and writing information to a database (12) corresponding to a schema (10). (8) At least one database management configured to execute a computer program for implementing the method described in (1) to (6) or to support the execution of the method described in (7). Computer system on which the system was installed. (9) An electronic data carrier for storing data usable for installing a computer program for implementing the method according to (1) or for supporting the execution of the method according to (7).

[Brief description of the drawings]

FIG. 1 is a schematic flowchart of a processing method of the present invention.

FIG. 2 is a comprehensive schematic diagram showing a basic mode of the first embodiment of the processing method of the present invention.

FIG. 3 is a comprehensive schematic diagram showing a basic mode of a second embodiment of the processing method of the present invention.

FIG. 4 is a schematic block diagram of a method for transferring information according to the present invention.

FIG. 5 is a comprehensive schematic diagram illustrating information transfer according to the method of the present invention.

[Explanation of symbols]

Reference Signs List 10 schema 12 database (db) 14 grammar 16 file contents 18 mapping rule 20 metacontext 30 DTD file 32 db table 100 information package 110 determining grammar 120 deriving db schema from grammar 130 generating mapping rules from grammar 140 schema and Store information in database according to mapping rules 400 Prototype information 410 Analyze information 420 Generate DTD 430 Send DTD to B 440 Receive DTD and generate db schema 450 Send multiple information packages 460 Send information receive

Claims (9)

[Claims] A method for processing structured information (100) to be stored in a database of a computer system, the method comprising: determining a grammar describing the structure of the information (11).
0), deriving a database schema from the grammar (120), and generating mapping rules from the grammar (13)
0) and storing (140) structured information in the database according to the schema and the mapping rules. 2. The method according to claim 1, characterized in that grammar non-terminals are mapped to tables (32) of the relational database (12). 3. Structured information (10) using a context-free grammar.
Method according to claim 2, characterized by the step of describing 0). 4. Structured information (10) using a context-free grammar.
0), generating a document description file 30 reflecting the structured contents of the plurality of information packages (100), and deriving the database schema (12) from the document description file (30). The method of claim 3. 5. Method according to claim 4, characterized in that the structured information (100) is described using XML. 6. The method according to claim 5, characterized in that grammar non-terminals are mapped to structural elements of the object-oriented database system. 7. A method for transferring a quantity of information from an external site into a database, said quantity of information being at least a plurality of at least similarly structured generalizable by a common general information structure. An information package (100), said method comprising: once generating a document description file (30) (DTD) characterizing the general structure of the information package (100) to be transferred; Generating a database schema (10) once in a receiving database (10) in response to: sending the plurality of information packages (100) to a receiving database (12); Writing information to a corresponding database (12). 8. At least one database management system configured to execute a computer program for realizing the method according to claim 1 or to support the execution of the method according to claim 7. Computer system on which is installed. 9. An electronic data carrier storing data usable for installing a computer program for implementing the method according to claim 1 or for supporting the execution of the method according to claim 7.