KR100666942B1 - Method for Handling XML Data Using Relational Database Management System - Google Patents

Abstract

An XML data management method using a relational DBMS according to an aspect of the present invention includes constructing a DOM object tree by DOM parsing an XML file, and registering object information selected from the DOM object tree in an RDBMS table; A DTD registration step of registering XML DTD information in a DTD table and generating a document table and a node table for storing XML data of the registered DTD; Parsing an XML file and storing the DOM object information in a document table and a node table; And an XML file generation step of generating an XML file using the DOM object information stored in the DBMS.

Description

How to manage XML data using relational DVMS {Method for Handling XML Data Using Relational Database Management System}             

BRIEF DESCRIPTION OF THE DRAWINGS Fig. 1 is a diagram showing an XML file table in a case where a file is stored through a method of storing the entire XML file in a CLOB form of an RDBMS table.

FIG. 2 is a diagram illustrating an XML node table when a tag to be used as a search key in XML data is defined as a column of a table. FIG.

3 is a diagram illustrating an XML data RDBMS table mapping algorithm according to the present invention.

4 is a diagram showing the configuration of an XML library using the XML data RDBMS table mapping algorithm according to the present invention;

5 illustrates a DOM object tree resulting from DOM parsing of an XML file.

6 is a diagram illustrating a DB table decomposition process using a DTD of XML.

7 is a diagram showing a relationship diagram for each element according to the present invention.

8 illustrates one preferred embodiment of a DOM object tree in accordance with the present invention.

9 illustrates a preferred embodiment of a DTD table in accordance with the present invention.

10 illustrates a preferred embodiment of a node table in accordance with the present invention.

11 illustrates one preferred embodiment of data distribution using table partitioning in accordance with the present invention.

* Description of the symbols for the main parts of the drawings *

101: XML file name 102: registration time (regi_date)

103: XML file 410: setDTD

420: importXML 430: exportXML

440: XML Data Retrieval 500: RDBMS Tables

710: DTD table 720: document table

730: node table

The present invention relates to a method for managing XML data using an RDBMS, and more particularly, to XML data using a relational DBMS for managing object-oriented XML data using an RDBMS that manages a database based on a table type. It is about a management method.

Early computers simply stored and read data using the file system provided by the operating system. To manage or access such data more efficiently, application programmers had to develop the necessary applications on the file system. At that time, every time a user's needs changed, the application had to be changed or even redeveloped, and its functionality was extremely limited for many users at the same time.

In the early 1960s, for the first time, the term "database" was defined and soon defined as the concept of "a collection of operational data that is integrated and stored for shared application systems in an organization." Introduced Database Management System (DBMS), a system for managing databases. Since then, DBMSs such as IMS and Total, which are based on hierarchical data models and network data models, have been developed to show excellent performance in hierarchical business areas such as sales network information and department organization information. However, these DBMSs had one decisive disadvantage: changes to the database had a significant impact on the performance of the application because the applications were developed to connect the data to pointers and make the best use of those pointers. Moreover, maintaining such a database was not difficult at all.

A relational data model that could solve these problems was introduced in the early 1970s by E.F. Proposed by Codd. The relational data model conceptually proposes three representative relational algebraic operations: project, restrict, and join. The relational database built on these operations is an optimization problem, data storage structure, which is characteristic of the applications that were disadvantages of previous data models. We were able to solve the exposure problem, and the code writing code to follow the pointer manually. As a result, the database design remains independent of the application, enabling the development of multiple applications for that database.

The basic building block of a relational database is a two-dimensional table (or relation). A table consists of a set of data rows (tuples), each of which in turn consists of several data elements (called attributes). At this time, each attribute is fixed to have a basic data type such as STRING, NUMBER, DATE, and so on.

RDBMS products include U.C. Through Berkeley's Ingres, many systems such as Oracle, Informix, Sybase, and DB2 have been developed and widely used today.

Since the 1980s, relational databases have undergone a number of technological advancements that have revolutionized the DBMS field, and have shown excellent performance and superior stability in managing large amounts of data with basic types such as letters and numbers. To date, most companies' primary data consists of basic types of data such as numbers, dates, and short strings.

However, with the advent of the Internet, the world is changing rapidly and the need for more complex data analysis is increasing. In addition, end users are demanding multimedia data support such as images, audio, and video. For this reason, problems with relational databases began to emerge.

It is difficult to represent complex objects in SQL, and it is difficult to represent complex objects using tables. In SQL, data relationships are represented by values. It is also difficult to find related objects. Another problem is that application development and maintenance are difficult due to the impedance mismatch problem.

As a way to solve these problems, I began to study the application of object-oriented technology, which had been in the spotlight since the mid-1980s, to the database. In the 1990s, object-oriented technology has become one of the most important concepts in the software industry, and it is natural to adopt object-oriented technology in the database field.

While relational databases perform exceptionally well for efficiently storing, managing, and retrieving large amounts of primitive types of data, the object-oriented model on which the object-oriented programming language (OOPL) is based provides a very good model of the real world, The advantage is that data can be represented and manipulated efficiently.

But because relational and object-oriented models are fundamentally different, integrating them is not so simple. Relational databases are based on two-dimensional tables, and the relationships between data are represented by comparing the values stored in each table. You can actually use those relationships by joining the tables using the SQL language. In contrast, the object model is based on the tight integration of code and data, flexible data types, hierarchical relationships between data types, and object references.

It is very difficult to represent this basic structure in two-dimensional tables in relational database systems, and there are many problems to be solved, including implementing an interface between the two systems to handle data manipulation and retrieval accurately. Eventually, this semantic mismatch between OOPL and relational databases led to the emergence of an object-oriented database system that directly provided an object-oriented model rather than through a relational database.

An object-oriented DBMS (OODBMS) is based on an object whose structure combines data and related code. The definition of an object is contained in a class, and each object is created as an instance of the class. Based on this object-oriented model, OODBMSs basically provide object features such as encapsulation, inheritance, polymorphism, object identifiers, and references between objects.

In OODBMS, many of the considerations necessary to maintain the correct relationship are removed. Starting with G-Base in 1987, various products such as GemStone, Orion, O2, ObjectStore, Versant and Objectivity have been researched and developed.

On the other hand, the XML (eXtensible Markup Language) proposed by the World Wide Web Consortium (W3C) in 1996 has recently been adopted as a new standard for information exchange on the Internet, and its field of use has rapidly increased. Because the information contained in XML is self-describing, it is characteristic of non-normal data and also has an object-oriented nature. Due to this characteristic of XML data, there are many restrictions in managing XML data based on RDBMS table.

Conventionally, there are two ways to manage XML data using RDBMS.

The first is to store the entire XML file in the form of CLOB (Character Large Object) of the RDBMS table. CLOB is a data type provided by the RDBMS for storing large data in the form of documents. The following shows the RDBMS table schema.

create table xml_file_tbl (

xml_file_name VARCHAR2 (100) NOT NULL,

regi_date DATE,

xml_file CLOB

);

FIG. 1 shows an XML file table in a case where a file is stored through a method of storing the entire XML file in the form of a CLOB of an RDBMS table.

A file named sample1.XML is stored in XML_file_name 101 of the XML file table of FIG. 1, and it can be seen that the registration time (regi_date) 102 is '12 am on August 31, 2004 '. Importantly, the XML file 103 is stored in its own CLOB column of the table.

The second way to manage XML data using RDBMS is to define a tag to be used as a search key in XML data as a column of a table, and to store the value when storing the XML file.

This second method is identical to the first method in that the entire XML file is stored in the form of a CLOB in the RDBMS table, but the difference is that specific tag and value information in the XML document is mapped and stored in a column of the table. Have In the first method, it is impossible to retrieve specific data of XML by simply storing the entire XML file in a CLOB. The second method uses a method of pre-determining and storing specific information to compensate for this problem.

The table schema below shows an example of defining the name attribute of the 'father' tag and the name attribute of the 'son' tag as the search key of the table, using the same example as in the first method.

/ * Oracle Table Schema * /

create table xml_file_tbl (

xml_file_name VARCHAR2 (100) NOT NULL,

regi_date DATE,

xml_file CLOB

);

/ * Oracle Table Schema * /

create table xml_node_tbl (

xml_file_name VARCHAR2 (100) NOT NULL,

father_name VARCHAR2 (100) NOT NULL,

son_name VARCHAR2 (100) NOT NULL,

regi_date DATE

);

Here, the XML file table (xml_file_tbl) is a table for storing XML file information, and the XML node table (xml_node_tbl) is a table for parsing an XML file and storing values of specific tags (father tag and sun tag). The XML file table and the XML node table have a one-to-n relationship.

FIG. 2 shows an XML node table when a tag to be used as a search key in XML data is defined as a column of a table.

FIG. 2 is for explaining the second method, and assumes a case of storing an XML file table named sample.XML as in the case of FIG. 1 and XML by parsing a value of a specific tag (father, sun) It is stored in the corresponding column of the node table, and the XML file is stored in the CLOB column of the XML file table. In this case, the form of the XML file table is the same as in FIG. 1, and the form of the XML node table is shown in FIG.

In the first method of managing XML data using the RDBMS described above, since the XML file itself is stored in the CLOB column of the table as it is, the information on a specific tag of the XML data cannot be retrieved from the RDBMS. In the case of the method, it is possible to search for a predefined tag by parsing the value of a specific tag and storing it as a search key.However, like the first method, it is impossible to retrieve information about an arbitrary tag that is not predefined. do.

Recent RDBMSs (eg, Oracle, Informix, etc.) also apply object-oriented concepts to provide XML data processing, but this requires the purchase of the latest RDBMS. However, upgrading DBMS that is already in operation is expensive and is not preferred in terms of data management safety. Therefore, there is a need for a method to effectively manage XML data using the existing DBMS.

In order to solve the above problems, by using DOM parsing and decomposition of DTD-based DB tables, the relational DBMS that can process the XML data of the object tendency by using a general RDBMS rather than an XML-only DBMS Its purpose is to provide an XML data management method using.

An XML data management method using a relational DBMS according to an aspect of the present invention comprises the steps of constructing a DOM object tree by parsing an XML file with a Document Object Model (DOM), selecting an object from the DOM object tree; Registering the selected DOM object information in an RDBMS table, and storing the DOM object in a DB table.

The object selecting step may include selecting each DOM object information in order of 'left to right' and 'top to down' in order.

The storing of the DOM object in the DB table may include storing the DOM object of the XML data in different DB tables classified by Document Type Definitions (DTDs).

The DB table includes at least one of a DTD table for storing DTD information, a document table for storing XML file information, and a node table for storing XML DOM object information, wherein one DTD table is connected to at least one document table. One document table may be connected to at least one node table.

The node table may be distributed by table partitioning that logically or physically divides data of the table.

According to another aspect of the present invention, there is provided a method of managing XML data using a relational DBMS, including: parsing an XML file to construct a DOM object tree, and registering object information selected from the DOM object tree in an RDBMS table; A DTD registration step of registering XML DTD information in a DTD table and generating a document table and a node table for storing XML data of the registered DTD; Parsing an XML file and storing the DOM object information in a document table and a node table; And an XML file generation step of generating an XML file using the DOM object information stored in the DBMS.

The method may further include retrieving desired XML data from the RDBMS table using an SQL query.

Hereinafter, a preferred embodiment according to the present invention will be described in detail with reference to the drawings.

3 illustrates an XML data RDBMS table mapping algorithm according to the present invention.

According to the present invention, unlike the prior art of storing the XML file itself in a table, DOM object information obtained by parsing an XML file in a Document Object Model (DOM) is stored in an RDBMS table.

The XML data RDBMS table mapping algorithm according to the present invention is largely divided into an XML file DOM parsing step S310, selecting an object from a DOM tree in step S320, and registering DOM object information in an RDBMS in step S330. can see. Detailed description of each step will be described with reference to FIGS. 5 to 7.

Here, DOM is a programmatic interface connecting HTML (HyperText Markup Language) and XML documents. It defines how to open any XML document and process XML data. Using the DOM, developers can create XML documents, navigate XML document structures, and add / modify / delete their elements. The main purpose of the DOM is to provide a standard programming interface for use in a wide variety of environments and applications.

The W3C DOM is designed to be developed in any programming language. The information contained within an XML document is self descriptive. That is, the XML document contains not only data but also information about the data in the form of a tag. Therefore, it is difficult to extract tag information or data from an XML document in text form. To reduce the effort of parsing text documents, XML data is processed using an XML parser. An XML document uses a parser to convert an XML document in text form into a tree-based hierarchical structure.

Since the elements of an XML document are formed in a hierarchical structure, the document can be represented as a tree containing all the information. Sub-elements appear as sub-nodes of their parent, and attributes are also recognized as sub-nodes of the element in which they are defined. In the process, the parser creates a tree of nodes representing the elements of the document.

The parsing model includes a tree-based DOM and an event-based simple API for XML (SAX), which facilitates access to the structure and information of XML and allows its manipulation. It provides a standard interface for representing XML documents in the form of hierarchical nodes.

4 illustrates an XML library configuration using the XML data RDBMS table mapping algorithm according to the present invention.

FIG. 4 shows that an XML library can be constructed based on the XML data RDBMS table mapping algorithm shown in FIG. 3. The XML library provides three main functions, and the operator can use the XML library to store XML data in an RDBMS (importXML) or to export XML file information from the RDBMS (exportXML). The operator can also retrieve 440 the desired XML data using an SQL query from the RDBMS table.

The three main functions of the XML library are DTD registration (setDTD) 410, XML file import (importXML) 420, and XML file export (exportXML) 440.

The DTD registration function 410 registers the XML DTD information in the DTD table, and generates a document table and a node table for storing XML data of the registered DTD.

Here, the DTD is a specification that accompanies the document to distinguish paragraphs of the document, to identify the title of the subject, and to identify markups that indicate how each should be handled. Sending the DTD together will allow the document to be processed anywhere that has a DTD reader (or SGML compiler) that can be displayed or printed as originally intended. This means that one standard SGML compiler can serve many different kinds of documents with different markup code and related semantics. The compiler consults the DTD and displays or prints the document as appropriate.

The XML file storage 420 function is to DOM parse an XML file to store DOM object information in the document table and node table. The XML file generation 430 function plays a role in generating an XML file using DOM object information stored in a DBMS.

In the above, the present invention has been described with reference to FIGS. 3 and 4, and specific details of the present invention will be described below with reference to FIGS. 5 to 7.

5 illustrates a DOM object tree resulting from DOM parsing of an XML file.

When you parse the XML file, you can see that the DOM object tree is constructed as shown in FIG. The DOM object tree generated by DOM parsing is entered by mapping each DOM object information to the RDBMS table 500 in the order of 'left to right' and 'top to down' in order. .

6 illustrates a DB table decomposition process using a DTD of XML.

As shown in FIG. 6, DTD decomposition performs a role of physically separating one node table and dividing it into XML data for each node.

Document Type Definition (DTD) defines a format of XML data, which means that XML data using the same DTD is defined in the same format. "Dtd", which is the front part of 'dtd_ # xml data' of FIG. 6, is a part indicating the format of data. Each of the node tables (dtd_1 xml data, dtd_2 xml data, ..., dtd_n xml data) divided in FIG. 6 have the same format since they are partitioned using one DTD.

DOM object information of the RDBMS table mapping algorithm of the XML data as described in FIG. 3 RDBMS registration, rather than storing the DOM object of the XML data in one DB table, stored in another DB table classified by DTD. The new DTD dynamically creates a new DB table through the DTD registration process each time.

The benefits of dividing and storing DB tables by DTD are that XML data can be distributed to different DB tables, data can be distributed, and search time can be shortened. DB tables by DTD can be classified to improve management efficiency. to be.

7 shows an entity relationship diagram according to the present invention.

Referring to FIG. 7, it can be seen that one DTD table 710 is connected to the plurality of document tables 720, and one document table 720 is again connected to the plurality of node tables 730.

The DTD table (dtd_tbl) 710 is a table that stores DTD information and may be represented by an Oracle table schema of the following form.

/ * Oracle Table Schema * /

create table dtd_tbl (

dtd_id NUMBER (5) NOT NULL, // DTD distinguished ID

dtd_name VARCHAR2 (100) NOT NULL, // DTD file name

dtd_root VARCHAR2 (100) NOT NULL, // root tag name of document

version VARCHAR2 (100) NOT NULL, // document version

encoding VARCHAR2 (100) NOT NULL, // document encoding name

doctbl_name VARCHAR2 (100) NOT NULL, // doc_tbl name mapped to dtd

nodetbl_name VARCHAR2 (100) NOT NULL, // node_tbl name mapped to dtd

regi_date DATE, // document registration date

dtd CLOB // document DTD information

);

The document table (doc _ # _ tbl) 720 is a table for storing XML file information. # Is a serial number, and is a number automatically assigned each time a DTD is registered. That is, the document table 720 is determined by doc_1_tbl, doc_2_tbl, ..., and can be represented by a schema of the following form.

/ * Oracle Table Schema * /

create table doc _ # _ tbl (

doc_id NUMBER (5) NOT NULL, // XML document ID

dtd_id NUMBER (5) NOT NULL, // DTD distinguished ID (parent ID)

doc_name VARCHAR2 (100) NOT NULL, // name of the XML file (document)

regi_date DATE // date of registration

);

The node table (node _ # _ tbl) 730 is a table for storing XML DOM object information. # Also represents a serial number and takes a value automatically assigned each time a DTD is registered. Therefore, the node table 730 takes the form of node_1_tbl, node_2_tbl, ..., and has the following schema.

/ * Oracle Table Schema * /

create table node _ # _ tbl (

doc_id NUMBER (5) NOT NULL, // XML document ID (parent ID)

node_id NUMBER (5) NOT NULL, // DOM Object ID

pnode_id NUMBER (5) NOT NULL, // parent node ID on DOM Tree

node_type NUMBER (2) NOT NULL, // DOM Definition Object Type ID

node_name VARCHAR2 (100) NULL, // DOM Object Name

node_value VARCHAR2 (100) NULL, // DOM Object Value

node_ord NUMBER (2) NULL // Same sibling order of DOM Objects

);

As mentioned above, the configuration and operation of the present invention have been described in general and in detail. Hereinafter, preferred embodiments of the present invention will be described.

8 illustrates a preferred embodiment of a DOM object tree in accordance with the present invention.

FIG. 8 illustrates the shape of the DOM object tree according to the present invention instead of the prior art by using the sample.xml file used in FIG. 1 as an embodiment. As can be seen in Figure 8, each object is connected to each other.

9 illustrates a preferred embodiment of a DTD table according to the present invention.

9 shows a result of storing DTD information in a DTD table. It is assumed here that a DTD of sample.xml is first registered and generated as doc_1_tbl and node_1_tbl. The result stored in doc_1_tbl is shown in Table 1 below.

doc_id dtd_id doc_name regi_date One One sample.xml 2004-08-31 12:00:00

10 illustrates one preferred embodiment of a node table in accordance with the present invention.

FIG. 10 illustrates a result of storing object information of the DOM tree in node_1_tbl, and may arbitrarily search for an arbitrary XML tag and value desired by a user from a node table storing object information of the DOM tree.

An example of retrieving some data will be given based on the node table of FIG. For example, if you search for the name of 'father',

"select node_value from node_tbl where node_name = 'name; and pnode_id = (select node_id from node_tbl where node_name =' father ')

You can use a search expression like this:

Also, to search for 'father age' of 'son1', you can use the following search.

"select node_value from node_1_tbl where node_name =" age "AND node_id = (select pnode_id from node_1_tb1 where node_name = 'name' AND node_value = 'son1')"

11 illustrates a preferred embodiment of data distribution using table partitioning according to the present invention.

In the present invention, by applying the concept of monthly table partitioning to the node table in which DOM object information is stored, data is distributed to improve search performance. Table partitioning is a function provided by the DBMS that partitions table data using partitions that are logically or physically separated.

The table partitioning method of FIG. 11 is distinguished from the table decomposition described in FIG. 6. If the table decomposition of FIG. 6 is physical, the monthly partitioning method used in FIG. 10 divides the node table according to logical division. Will be called.

According to the method of FIG. 11, the schema of the node table to which the monthly partition is applied may be represented as follows.

/ * Oracle Table Schema * /

create table node _ # _ tbl (

doc_id NUMBER (5) NOT NULL, // XML document ID (parent ID)

node_id NUMBER (5) NOT NULL, // DOM Object ID

pnode_id NUMBER (5) NOT NULL, // parent node ID on DOM Tree

node_type NUMBER (2) NOT NULL, // DOM Definition Object Type ID

node_name VARCHAR2 (100) NULL, // DOM Object Name

node_value VARCHAR2 (100) NULL, // DOM Object Value

node_ord NUMBER (2) NULL, // Same sibling order of DOM Object

month NUMBER (2) NOT NULL // table partition key

) partition by range (month)

(

  partition XML_01 values less than (2)

, partition XML_02 values less than (3)

, partition XML_03 values less than (4)

, partition XML_04 values less than (5)

, partition XML_05 values less than (6)

, partition XML_06 values less than (7)

, partition XML_07 values less than (8)

, partition XML_08 values less than (9)

, partition XML_09 values less than (10)

, partition XML_10 values less than (11)

, partition XML_11 values less than (12)

, partition XML_12 values less than (13)

);

The present invention, by flexibly managing the XML data using the existing RDBMS to increase the utilization of the existing operating RDBMS, problems such as the possibility of duplication of operation and data management due to the use of both the DBDB and the RDBMS dedicated XML DBMS Can be eliminated to facilitate the integration of XML data with non-XML data.

Claims (9)

In the method for managing XML (eXtensible Markup Language) data using a relational DBMS (RDBMS), Parsing an XML file from a Document Object Model (DOM) to construct a DOM object tree; Selecting an object from the DOM object tree; And Registering the selected DOM object information in an RDBMS table, and storing the DOM object in a DB table. The method of claim 1, The object selection step, A method of managing XML data using a relational DBMS, in which each DOM object information is selected in an order of 'left to right' or 'top to down'. The method of claim 1, Storing the DOM object in a DB table, A method of managing XML data using a relational DBMS, characterized by storing DOM objects of XML data in different DB tables classified by document type definitions (DTDs). The method of claim 3, wherein The DB table, At least one of a DTD table for storing DTD information, a document table for storing XML file information, and a node table for storing XML DOM object information. A method for managing XML data using a relational DBMS, wherein one DTD table is connected to at least one document table, and one document table is connected to at least one node table. The method of claim 4, wherein The node table is, A method of managing XML data using a relational DBMS, characterized in that the data can be distributed by table partitioning that logically or physically separates the data of the table. In the method for managing XML (eXtensible Markup Language) data using a relational DBMS (RDBMS), Parsing an XML file to construct a DOM object tree and registering object information selected from the DOM object tree in an RDBMS table; A DTD registration step of registering XML DTD information in a DTD table and generating a document table and a node table for storing XML data of the registered DTD;  Parsing an XML file and storing the DOM object information in a document table and a node table; And  An XML data management method using a relational DBMS including an XML file generation step of generating an XML file using DOM object information stored in a DBMS. The method of claim 6,  XML data management method using a relational DBMS further comprising the step of retrieving the desired XML data using an SQL query from the RDBMS table. The method of claim 6, The RDBMS table registration step, A method of managing XML data using a relational DBMS, characterized by storing DOM objects of XML data in different DB tables classified by document type definitions (DTDs). The method of claim 8, The DB table, At least one of a DTD table for storing DTD information, a document table for storing XML file information, and a node table for storing XML DOM object information. A method for managing XML data using a relational DBMS, wherein one DTD table is connected to at least one document table, and one document table is connected to at least one node table.

Images