US9600597B2 - Processing structured documents stored in a database - Google Patents
Processing structured documents stored in a database Download PDFInfo
- Publication number
- US9600597B2 US9600597B2 US13/239,695 US201113239695A US9600597B2 US 9600597 B2 US9600597 B2 US 9600597B2 US 201113239695 A US201113239695 A US 201113239695A US 9600597 B2 US9600597 B2 US 9600597B2
- Authority
- US
- United States
- Prior art keywords
- string
- database
- identifier
- strings
- status
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Expired - Fee Related, expires
Links
Images
Classifications
-
- G06F17/30917—
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/80—Information retrieval; Database structures therefor; File system structures therefor of semi-structured data, e.g. markup language structured data such as SGML, XML or HTML
- G06F16/84—Mapping; Conversion
- G06F16/86—Mapping to a database
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99931—Database or file accessing
- Y10S707/99932—Access augmentation or optimizing
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99931—Database or file accessing
- Y10S707/99939—Privileged access
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S707/00—Data processing: database and file management or data structures
- Y10S707/99941—Database schema or data structure
- Y10S707/99942—Manipulating data structure, e.g. compression, compaction, compilation
Definitions
- the present invention relates generally to computer implemented database systems and, more particularly, to an improved method and system for processing structured documents stored in a database system.
- Structured documents are documents which have nested structures.
- Documents written in Extensible Markup Language (XML) are structured documents.
- XML is quickly becoming the standard format for delivering information over the Internet because it allows the user to design a customized markup language for many classes of structured documents.
- a business can easily model complex structures such as purchase orders in XML format and send them for further processing to its business partners.
- XML supports user-defined tags for better description of nested document structures and associated semantics, and encourages the separation of document content from browser presentation.
- DBMSes database management systems
- DASD direct access storage devices
- Some DBMSes known as relational databases, store and query the documents utilizing relational techniques
- other DBMSes known as native databases, store the documents in their native formats.
- XML X-ray coding
- element and attribute names that are relevant to and descriptive of the particular class of document. While this provides the user with great flexibility, it also presents problems for database processing. Evaluating strings corresponding to element names is costly because the strings are of varying length and the database processor, at a minimum, must perform length checks. Such length checks add costs during runtime and also complicate program coding. In addition, processing variable length strings complicates memory management in the database. Moreover, in order to store XML documents in their native format in a database, the element and attribute names, along with other strings, must be stored on disk. For large documents, the amount of disk space required to store a collection of such documents can be quite large and expensive.
- a typical compression method involves replacing certain strings with numbers and storing mapping information in a file specific or document specific table.
- the mapping table is stored in front of the file or document. While this method reduces the size of the document, it also presents several disadvantages in the storage and processing of such documents.
- a method, computer readable medium, and system for processing a structured document are disclosed.
- the method, computer readable medium, and system provide for identifying a plurality of strings processed by the database, assigning an identifier to each of the plurality of strings, storing each of the plurality of strings and its assigned identifier in a table in the database, wherein at least one of the plurality of strings is not derived from one or more structured documents stored in the database and at least another of the plurality of strings is derived from the one or more structured documents stored in the database, and utilizing the table during document processing.
- a global association table is provided to store strings and their respective identifiers.
- the strings correspond to element names, attribute names, and namespaces in one embodiment. Because a global association table is utilized, an identifier for a particular string can be used in place of the string throughout the database. By replacing strings with their respective identifiers, document processing and storage are significantly improved.
- FIG. 1 is a block diagram of an exemplary computer environment for use with the present invention.
- FIG. 2A is a flowchart illustrating a method for processing a structured document stored in a database according to the embodiment of the present invention.
- FIG. 2B is an association table according to an embodiment of the present invention.
- FIG. 3 is a flowchart illustrating a method for utilizing the association table during document storage according to an embodiment of the present invention.
- FIG. 4 is a flowchart illustrating a method for utilizing the association table during query processing according to an embodiment of the present invention.
- FIG. 5 is a flowchart illustrating how the cache is utilized when a request for a string identifier is processed according to the embodiment of the present invention.
- the present invention relates generally to computer implemented database systems and, more particularly, to an improved method and system for processing structured documents stored in their native format in a database.
- the following description is presented to enable one of ordinary skill in the art to make and use the invention and is provided in the context of a patent application and its requirements.
- Various modifications to the embodiment and the generic principles and features described herein will be readily apparent to those skilled in the art.
- the following discussion is presented in the context of a DB2® database environment available from IBM® Corporation. It should be understood that the present invention is not limited to DB2® and may be implemented with other database management systems.
- the present invention is to be accorded the widest scope consistent with the principles and features described herein.
- an identifier is assigned to each of a plurality of strings that is processed by the database, and the string and its assigned identifier are stored in a global database table.
- the global database table comprises strings used throughout the database, it is not limited to a single file or document.
- the table is associated with the database, and not with a particular file or document in the database.
- strings associated with element names, attribute names and namespaces, and their respective identifiers are stored in the table.
- FIG. 1 is an exemplary computer environment for use with the present invention.
- a typical distributed computer system 100 utilizes a network 103 to connect client computers 102 executing client applications to a server computer 104 executing software and other computer programs, and to connect the server computer 104 to data stores 106 .
- These systems are coupled to one another by various networks, including LANs, WANs, and the Internet.
- Each client computer 102 and the server computer 104 additionally comprise an operating system and one or more computer programs (not shown).
- the server computer 104 uses a data store interface (not shown) for connecting to the data stores 106 .
- the data store interface may be connected to a database management system (DBMS) 105 , which supports access to the data stores 106 .
- DBMS 105 can be a relational database management system (RDBMS) capable of storing structured documents in their native formats, such as the DB2® system developed by IBM® Corporation, or it also can be a native XML database system.
- RDBMS relational database management system
- the interface and DBMS 105 may be located at the server computer 104 or may be located on one or more separate machines.
- the data stores 106 may be geographically distributed.
- the DBMS 105 and the instructions derived therefrom are all comprised of instructions which, when read and executed by the server computer 104 cause the server computer 104 to perform the steps necessary to implement and/or use the present invention.
- the exemplary environment illustrated in FIG. 1 is not intended to limit the present invention, and alternative environments may be used without departing from the scope of the present invention.
- a single server computer system 104 is illustrated, it is well understood that multiple processing systems, known as nodes, could be linked to the network 103 in a Massively Parallel Processing (MPP) environment.
- MPP Massively Parallel Processing
- FIG. 2A is a flowchart illustrating a method for processing a structured document stored in a database according to the embodiment of the present invention.
- step 202 a plurality of strings processed by the DBMS 105 are identified. An identifier is then assigned to each of the plurality of strings in step 204 .
- step 206 the strings and their respective identifiers are stored in a table, and in step 208 , the DBMS 105 utilizes the table to replace the plurality of strings with their assigned identifiers. Thereafter, the identifiers, as opposed to the strings, are used during document processing.
- an association table 200 is provided.
- the association table is stored on-disk in the database 106 a in the embodiment.
- the association table 200 may be stored in a catalog node in order to avoid adding a new single point of failure.
- the association table 200 is a database-global table, i.e., the entire database system shares the association table 200 , and is a dictionary that maps strings to identifiers, hereinafter referred to as StringIDs.
- the strings include all element names, attribute names, namespace Uniform Resource Identifiers (URIs), and namespace prefixes found in documents stored in the database.
- FIG. 2B Shown in FIG. 2B is an exemplary association table 200 according to an embodiment of the present invention, where the table 200 is a conventional relational, e.g., SQL, table.
- the table 200 comprises a string column ( 202 ) and a StringID column ( 204 ).
- the string column ( 202 ) contains the strings corresponding to, for example, elements (e.g., 202 a and 202 b ), attributes (e.g., 202 c ), and namespaces (not shown).
- the StringID column ( 204 ) contains the StringIDs ( 204 a - 204 e ) associated with the strings ( 202 a - 202 e ).
- each StringID is a fixed size integer representing a variable length string.
- the StringID is used in place of the string throughout the database.
- the DBMS 105 stores a StringID of an element's name and a StringID of the element's namespace instead of the corresponding variable length strings.
- variable length strings in the query are converted to their respective StringIDs and therefore, the StringIDs in the query, and not the variable length strings, are compiled and executed.
- the StringIDs instead of the strings are utilized for storage and internal processing of the database.
- the StringID is generally smaller than its corresponding string, storing the StringID requires less storage space than storing the string. Thus, the StringID is used to compress the document and less disk space is required to store documents. Also, any other related database components, e.g., indices or a path table, require less storage space.
- the association table is global, a separate mapping table is not required to be stored with each document and the StringIDs can be utilized for homogeneous processing.
- the StringIDs are of a fixed size (e.g., four bytes) and consistent throughout the database, internal processing is simplified and performance improved. For instance, because StringIDs are fixed sized integers, comparing them, as opposed to variable length strings, is more efficient and less complicated.
- the association table 200 also includes strings found in sources other than stored documents.
- a query can introduce new element and attribute names based on a new document created from the result of the query.
- Such elements and attributes are referred to as “constructed” elements and attributes to distinguish them from those found in documents stored in the database.
- the strings associated with constructed elements (e.g., 202 d and 202 e ) and attribute names are stored in the association table 200 and assigned a StringID (e.g., 204 d and 204 e ). By doing so, the strings in the query can also be converted to StringIDs, which ensures homogeneous processing throughout the database.
- the association table 200 further comprises a status column ( 206 ) that indicates whether a string is “temporary” or “permanent.”
- Strings derived from documents stored in the database e.g., 202 a , 202 b , and 202 c ) are assigned “permanent” or “P” status because such strings are repeatedly used in document processing.
- Strings derived from sources other than documents stored in the database e.g., 202 d and 202 c ), for instance, from a query, are assigned “temporary” or “T” status because they are generally utilized once, e.g., during compile and execution of the query.
- a database administrator can utilize the DBMS 105 to automatically manage the size and content of the association table 200 by periodically checking the status column 206 of each string ( 202 a - 202 e ) and deleting those strings whose status is temporary ( 206 d , 206 e ).
- FIG. 3 is a flowchart illustrating a method for utilizing the association table 200 during document storage according to an embodiment of the present invention.
- the DBMS 105 includes a StringID generator 300 , which is utilized by processing mechanisms in the DBMS 105 , e.g., a storage mechanism 110 and a compiler 120 , to request and procure StringIDs ( 204 a - 204 e ) for strings ( 202 a - 202 e ).
- the process begins at step 302 when the storage mechanism 110 receives and parses a structured document that is to be stored in the database 106 a .
- the storage mechanism 110 stores the structured document as a plurality of nodes that form a node tree. Note that the nodes forming the node tree are not related to the nodes in an MPP environment. Each node in the tree includes its name, its namespace and its path. In order to minimize the size of the node, the strings associated with the name and namespace are converted to their respective StringIDs.
- the storage mechanism 110 considers a first string (e.g., 202 a ) in the document and in step 306 , requests a StringID for the string from the StringID generator 300 .
- the StringID generator 300 performs a lookup on the association table 200 for the string. If the string is found in the association table 200 (step 310 ), the StringID generator 300 then determines whether the string's status is temporary (in step 311 ) by checking the status column 206 . If the string's status is not temporary, i.e., its status is permanent, then the StringID generator 300 returns the StringID (e.g., 204 a ) corresponding to the string to the storage mechanism 110 in step 316 . If the string's status is temporary, the StringID generator 300 changes the status to permanent in step 313 and returns the StringID in step 316 . The StringID generator 300 changes the string's status from temporary to permanent because the string is derived from a document that is, or will be, stored in the database.
- the StringID generator 300 determines whether the string's status is temporary (in step 311 ) by checking the status column 206 . If the string's status is not temporary, i.e., its status is permanent, then the
- the StringID generator 300 creates a new StringID for the string and marks the new string's status as permanent in step 312 .
- the new string, its StringID and its status is inserted into and stored in the association table 200 .
- the StringID generator 300 returns the new StringID to the storage mechanism 110 in step 316 .
- the storage mechanism 110 replaces the string (e.g., 202 a ) with its StringID (e.g., 204 a ) in step 318 , and considers a next string (e.g., 202 b ) in the document via step 320 .
- Steps 306 through 320 are repeated until the storage mechanism 110 has replaced all of the strings with their respective StringIDs.
- the storage mechanism 110 then proceeds with its normal processing steps to store the document in its native format in the database.
- FIG. 4 is a flowchart illustrating a method for utilizing the association table 200 during query processing according to an embodiment of the present invention.
- the process begins in step 402 when a query is received by the compiler 120 .
- the query comprises a request to access at least one node in a document in a collection of documents.
- the query comprises a path to the requested node.
- the path is a “road map” to the node and comprises the names of the nodes in the node tree that lead to the requested node.
- the compiler 120 converts the query from a collection of strings to a collection of StringIDs.
- step 404 the compiler 120 considers a first string.
- the compiler 120 requests a StringID for the string from the StringID generator 300 in step 406 .
- step 408 the StringID generator 300 performs a lookup on the association table 200 for the string. If the string is found in the association table 200 (step 410 ), the StringID generator 300 returns the StringID corresponding to the string to the compiler 120 in step 416 . If the string is not found in the association table 200 (step 310 ), the string is a constructed string. As such, the StringID generator 300 creates a new StringID for the constructed string and marks the constructed string's status as temporary in step 412 . In step 414 , the constructed string, its StringID, and its status are inserted into and stored in the association table 200 . Next, the StringID generator 300 returns the new StringID to the compiler 120 in step 416 .
- the compiler 120 replaces the string with its StringID in step 418 , and considers a next string in the document via step 420 . Steps 406 through 420 are repeated until the compiler 120 has replaced all of the strings in the query with their respective StringIDs. The compiler 120 then proceeds with its normal processing steps, such as optimizing the query, and generating an executable plan to access the data in the documents.
- a cache 130 ( FIG. 1 ) is provided in the server 104 to store portions of the association table 200 so that access to the association table 200 is minimized.
- FIG. 5 is a flowchart illustrating how the cache 130 is utilized when a request for a StringID is processed according to an embodiment of the present invention.
- the StringID generator 300 receives a request from a requesting mechanism for a StringID and checks the cache 130 for the string in step 504 . If the string is located in the cache 130 (step 506 ), the StringID generator 300 determines whether the string's status is temporary in step 507 . If the string's status is not temporary, i.e., the string status is permanent, the corresponding StringID is returned from the cache 130 to the requesting mechanism in step 512 .
- the StringID generator 300 determines whether the requesting mechanism is the storage mechanism 110 (step 509 ). If the storage mechanism 110 is not the requesting mechanism, then the StringID from the cache 130 is returned to the requesting mechanism in step 512 . Otherwise, i.e., the storage mechanism 110 is the requesting mechanism, the string's status is changed to permanent in the cache 130 (step 510 ). In order to preserve coherency between the cache 130 and the association table 300 , the StringID generator 300 then locates the string in the association table 200 and changes the string's status to permanent in step 511 . Thereafter, the StringID from the cache 130 is returned to the storage mechanism in step 512 .
- the StringID generator 300 performs a lookup on the association table 300 in step 508 .
- the StringID generator 300 processes the request as before described in steps 310 through 314 in FIG. 3 , or as described in steps 410 through 414 in FIG. 4 .
- the StringID generator 300 returns the StringID to the requesting mechanism in step 512 .
- the StringID generator 300 also stores the string, its StringID, and the status in the cache 130 .
- the cache 130 can store strings that are particularly relevant to the server 104 .
- a database administrator can stock the cache 130 with default entries from the association table 200 , or with entries from a copy of the cache 130 that was created previously. Accordingly, the cache 130 is “primed” when the DBMS 105 is initiated.
- access to the association table 200 is minimized. By minimizing such access, the conversion from strings to StringIDs is faster and less costly.
- a global association table 200 is provided to store strings and their respective StringIDs.
- the strings correspond to element names, attribute names, and namespaces found in documents stored in the database. Because a global association table 200 is utilized, a StringID for a particular string can be used in place of the string throughout the database. By replacing strings with their respective StringIDs, document processing and storage are significantly improved.
Landscapes
- Engineering & Computer Science (AREA)
- Databases & Information Systems (AREA)
- Theoretical Computer Science (AREA)
- Data Mining & Analysis (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
A method, computer readable medium, and system for processing a structured document are disclosed. The method, computer readable medium, and system include identifying a plurality of strings processed by a database, assigning an identifier to each of the plurality of strings, storing each of the plurality of strings and its assigned identifier in a table in the database, and utilizing the table during document processing.
Description
This application is a continuation of U.S. patent application Ser. No. 12/398,716, filed Mar. 5, 2009, status allowed, which is a continuation of U.S. Pat. No. 7,512,608, filed Sep. 11, 2006, which is a continuation of U.S. Pat. No. 7,171,430, filed Aug. 28, 2003, all of which are hereby incorporated by reference in their entirety for all purposes as if fully set forth herein.
The present invention relates generally to computer implemented database systems and, more particularly, to an improved method and system for processing structured documents stored in a database system.
Structured documents are documents which have nested structures. Documents written in Extensible Markup Language (XML) are structured documents. XML is quickly becoming the standard format for delivering information over the Internet because it allows the user to design a customized markup language for many classes of structured documents. For example, a business can easily model complex structures such as purchase orders in XML format and send them for further processing to its business partners. XML supports user-defined tags for better description of nested document structures and associated semantics, and encourages the separation of document content from browser presentation.
As more and more businesses present and exchange data in XML documents, database management systems (DBMSes) have been developed to store, query and retrieve these documents which are typically stored on direct access storage devices (DASD), such as magnetic or optical disk drives for semi-permanent storage. Some DBMSes, known as relational databases, store and query the documents utilizing relational techniques, while other DBMSes, known as native databases, store the documents in their native formats.
As stated above, one attractive feature of XML is that it allows the user to design a customized markup language for many classes of structured documents. The user can select element and attribute names that are relevant to and descriptive of the particular class of document. While this provides the user with great flexibility, it also presents problems for database processing. Evaluating strings corresponding to element names is costly because the strings are of varying length and the database processor, at a minimum, must perform length checks. Such length checks add costs during runtime and also complicate program coding. In addition, processing variable length strings complicates memory management in the database. Moreover, in order to store XML documents in their native format in a database, the element and attribute names, along with other strings, must be stored on disk. For large documents, the amount of disk space required to store a collection of such documents can be quite large and expensive.
To alleviate the storage problem, it is common to compress a document in order to reduce the amount of storage space required to store it. A typical compression method involves replacing certain strings with numbers and storing mapping information in a file specific or document specific table. The mapping table is stored in front of the file or document. While this method reduces the size of the document, it also presents several disadvantages in the storage and processing of such documents. First, storing the mapping information in each file/document requires additional disk space for each file/document. Second, because each compressed file/document is associated with its own mapping table, the numbers associated with the strings in one compressed file/document do not correspond to the same strings in a different compressed file/document. Accordingly, because the numbers are not consistent throughout the database, the numbers cannot be used for purposes beyond document compression. Instead, the compressed documents must be decompressed before they can be processed. Once the document is decompressed, i.e., the numbers are replaced with the associated strings, the query processor is still required to evaluate strings.
Accordingly, a need exists for an improved method and system for processing structured documents stored in a database. The method and system should reduce the size of a structured document for storage, while supporting homogeneous document processing. The present invention addresses such a need.
A method, computer readable medium, and system for processing a structured document are disclosed. The method, computer readable medium, and system provide for identifying a plurality of strings processed by the database, assigning an identifier to each of the plurality of strings, storing each of the plurality of strings and its assigned identifier in a table in the database, wherein at least one of the plurality of strings is not derived from one or more structured documents stored in the database and at least another of the plurality of strings is derived from the one or more structured documents stored in the database, and utilizing the table during document processing.
According to an embodiment, a global association table is provided to store strings and their respective identifiers. The strings correspond to element names, attribute names, and namespaces in one embodiment. Because a global association table is utilized, an identifier for a particular string can be used in place of the string throughout the database. By replacing strings with their respective identifiers, document processing and storage are significantly improved.
The present invention relates generally to computer implemented database systems and, more particularly, to an improved method and system for processing structured documents stored in their native format in a database. The following description is presented to enable one of ordinary skill in the art to make and use the invention and is provided in the context of a patent application and its requirements. Various modifications to the embodiment and the generic principles and features described herein will be readily apparent to those skilled in the art. For example, the following discussion is presented in the context of a DB2® database environment available from IBM® Corporation. It should be understood that the present invention is not limited to DB2® and may be implemented with other database management systems. Thus, the present invention is to be accorded the widest scope consistent with the principles and features described herein.
According to an embodiment of the present invention, an identifier is assigned to each of a plurality of strings that is processed by the database, and the string and its assigned identifier are stored in a global database table. Because the global database table comprises strings used throughout the database, it is not limited to a single file or document. Thus, the table is associated with the database, and not with a particular file or document in the database. In one embodiment, strings associated with element names, attribute names and namespaces, and their respective identifiers are stored in the table.
To describe further the present invention, please refer to FIG. 1 , which is an exemplary computer environment for use with the present invention. In FIG. 1 , a typical distributed computer system 100 utilizes a network 103 to connect client computers 102 executing client applications to a server computer 104 executing software and other computer programs, and to connect the server computer 104 to data stores 106. These systems are coupled to one another by various networks, including LANs, WANs, and the Internet. Each client computer 102 and the server computer 104 additionally comprise an operating system and one or more computer programs (not shown).
The server computer 104 uses a data store interface (not shown) for connecting to the data stores 106. The data store interface may be connected to a database management system (DBMS) 105, which supports access to the data stores 106. The DBMS 105 can be a relational database management system (RDBMS) capable of storing structured documents in their native formats, such as the DB2® system developed by IBM® Corporation, or it also can be a native XML database system. The interface and DBMS 105 may be located at the server computer 104 or may be located on one or more separate machines. The data stores 106 may be geographically distributed.
The DBMS 105 and the instructions derived therefrom are all comprised of instructions which, when read and executed by the server computer 104 cause the server computer 104 to perform the steps necessary to implement and/or use the present invention. The exemplary environment illustrated in FIG. 1 is not intended to limit the present invention, and alternative environments may be used without departing from the scope of the present invention. For instance, while a single server computer system 104 is illustrated, it is well understood that multiple processing systems, known as nodes, could be linked to the network 103 in a Massively Parallel Processing (MPP) environment.
Referring again to FIG. 1 , an association table 200 is provided. The association table is stored on-disk in the database 106 a in the embodiment. In an MPP environment, the association table 200 may be stored in a catalog node in order to avoid adding a new single point of failure. The association table 200 is a database-global table, i.e., the entire database system shares the association table 200, and is a dictionary that maps strings to identifiers, hereinafter referred to as StringIDs. In an embodiment, the strings include all element names, attribute names, namespace Uniform Resource Identifiers (URIs), and namespace prefixes found in documents stored in the database. By replacing strings with their respective StringIDs, document processing and storage are significantly improved.
Shown in FIG. 2B is an exemplary association table 200 according to an embodiment of the present invention, where the table 200 is a conventional relational, e.g., SQL, table. As is shown, the table 200 comprises a string column (202) and a StringID column (204). The string column (202) contains the strings corresponding to, for example, elements (e.g., 202 a and 202 b), attributes (e.g., 202 c), and namespaces (not shown). The StringID column (204) contains the StringIDs (204 a-204 e) associated with the strings (202 a-202 e).
In one embodiment, each StringID is a fixed size integer representing a variable length string. The StringID is used in place of the string throughout the database. For example, during storage, the DBMS 105 stores a StringID of an element's name and a StringID of the element's namespace instead of the corresponding variable length strings. In another example, during query processing, variable length strings in the query are converted to their respective StringIDs and therefore, the StringIDs in the query, and not the variable length strings, are compiled and executed. In summary, the StringIDs instead of the strings are utilized for storage and internal processing of the database.
Several advantages flow from this utilization. First, because the StringID is generally smaller than its corresponding string, storing the StringID requires less storage space than storing the string. Thus, the StringID is used to compress the document and less disk space is required to store documents. Also, any other related database components, e.g., indices or a path table, require less storage space. Second, because the association table is global, a separate mapping table is not required to be stored with each document and the StringIDs can be utilized for homogeneous processing. Third, because the StringIDs are of a fixed size (e.g., four bytes) and consistent throughout the database, internal processing is simplified and performance improved. For instance, because StringIDs are fixed sized integers, comparing them, as opposed to variable length strings, is more efficient and less complicated.
As stated above, some of the strings in the association table 200 are those found in documents stored in the database. In an embodiment, the association table 200 also includes strings found in sources other than stored documents. For example, a query can introduce new element and attribute names based on a new document created from the result of the query. Such elements and attributes are referred to as “constructed” elements and attributes to distinguish them from those found in documents stored in the database. The strings associated with constructed elements (e.g., 202 d and 202 e) and attribute names are stored in the association table 200 and assigned a StringID (e.g., 204 d and 204 e). By doing so, the strings in the query can also be converted to StringIDs, which ensures homogeneous processing throughout the database.
According to the embodiment, the association table 200 further comprises a status column (206) that indicates whether a string is “temporary” or “permanent.” Strings derived from documents stored in the database (e.g., 202 a, 202 b, and 202 c) are assigned “permanent” or “P” status because such strings are repeatedly used in document processing. Strings derived from sources other than documents stored in the database (e.g., 202 d and 202 c), for instance, from a query, are assigned “temporary” or “T” status because they are generally utilized once, e.g., during compile and execution of the query. Thus, a database administrator can utilize the DBMS 105 to automatically manage the size and content of the association table 200 by periodically checking the status column 206 of each string (202 a-202 e) and deleting those strings whose status is temporary (206 d, 206 e).
To describe how the association table 200 is utilized in step 208 of FIG. 2A , please refer now to FIG. 1 , FIG. 2B and FIG. 3 . FIG. 3 is a flowchart illustrating a method for utilizing the association table 200 during document storage according to an embodiment of the present invention. As is shown in FIG. 1 , the DBMS 105 includes a StringID generator 300, which is utilized by processing mechanisms in the DBMS 105, e.g., a storage mechanism 110 and a compiler 120, to request and procure StringIDs (204 a-204 e) for strings (202 a-202 e).
The process begins at step 302 when the storage mechanism 110 receives and parses a structured document that is to be stored in the database 106 a. In one embodiment, the storage mechanism 110 stores the structured document as a plurality of nodes that form a node tree. Note that the nodes forming the node tree are not related to the nodes in an MPP environment. Each node in the tree includes its name, its namespace and its path. In order to minimize the size of the node, the strings associated with the name and namespace are converted to their respective StringIDs. Thus, in step 304, the storage mechanism 110 considers a first string (e.g., 202 a) in the document and in step 306, requests a StringID for the string from the StringID generator 300.
In step 308, the StringID generator 300 performs a lookup on the association table 200 for the string. If the string is found in the association table 200 (step 310), the StringID generator 300 then determines whether the string's status is temporary (in step 311) by checking the status column 206. If the string's status is not temporary, i.e., its status is permanent, then the StringID generator 300 returns the StringID (e.g., 204 a) corresponding to the string to the storage mechanism 110 in step 316. If the string's status is temporary, the StringID generator 300 changes the status to permanent in step 313 and returns the StringID in step 316. The StringID generator 300 changes the string's status from temporary to permanent because the string is derived from a document that is, or will be, stored in the database.
If the string is not found in the association table 200 (step 310), the StringID generator 300 creates a new StringID for the string and marks the new string's status as permanent in step 312. In step 314, the new string, its StringID and its status is inserted into and stored in the association table 200. Next, the StringID generator 300 returns the new StringID to the storage mechanism 110 in step 316.
Once the StringID is returned, the storage mechanism 110 replaces the string (e.g., 202 a) with its StringID (e.g., 204 a) in step 318, and considers a next string (e.g., 202 b) in the document via step 320. Steps 306 through 320 are repeated until the storage mechanism 110 has replaced all of the strings with their respective StringIDs. The storage mechanism 110 then proceeds with its normal processing steps to store the document in its native format in the database.
Another example of how the association table 200 is utilized in step 208 of FIG. 2A is described in FIG. 4 . FIG. 4 is a flowchart illustrating a method for utilizing the association table 200 during query processing according to an embodiment of the present invention. The process begins in step 402 when a query is received by the compiler 120. Typically, the query comprises a request to access at least one node in a document in a collection of documents. In an embodiment, the query comprises a path to the requested node. The path is a “road map” to the node and comprises the names of the nodes in the node tree that lead to the requested node. According to the embodiment, the compiler 120 converts the query from a collection of strings to a collection of StringIDs.
In step 404, the compiler 120 considers a first string. The compiler 120 then requests a StringID for the string from the StringID generator 300 in step 406. In step 408, the StringID generator 300 performs a lookup on the association table 200 for the string. If the string is found in the association table 200 (step 410), the StringID generator 300 returns the StringID corresponding to the string to the compiler 120 in step 416. If the string is not found in the association table 200 (step 310), the string is a constructed string. As such, the StringID generator 300 creates a new StringID for the constructed string and marks the constructed string's status as temporary in step 412. In step 414, the constructed string, its StringID, and its status are inserted into and stored in the association table 200. Next, the StringID generator 300 returns the new StringID to the compiler 120 in step 416.
Once the StringID is returned, the compiler 120 replaces the string with its StringID in step 418, and considers a next string in the document via step 420. Steps 406 through 420 are repeated until the compiler 120 has replaced all of the strings in the query with their respective StringIDs. The compiler 120 then proceeds with its normal processing steps, such as optimizing the query, and generating an executable plan to access the data in the documents.
In one embodiment, a cache 130 (FIG. 1 ) is provided in the server 104 to store portions of the association table 200 so that access to the association table 200 is minimized. FIG. 5 is a flowchart illustrating how the cache 130 is utilized when a request for a StringID is processed according to an embodiment of the present invention. In step 502, the StringID generator 300 receives a request from a requesting mechanism for a StringID and checks the cache 130 for the string in step 504. If the string is located in the cache 130 (step 506), the StringID generator 300 determines whether the string's status is temporary in step 507. If the string's status is not temporary, i.e., the string status is permanent, the corresponding StringID is returned from the cache 130 to the requesting mechanism in step 512.
If the string's status is temporary (step 507), the StringID generator 300 determines whether the requesting mechanism is the storage mechanism 110 (step 509). If the storage mechanism 110 is not the requesting mechanism, then the StringID from the cache 130 is returned to the requesting mechanism in step 512. Otherwise, i.e., the storage mechanism 110 is the requesting mechanism, the string's status is changed to permanent in the cache 130 (step 510). In order to preserve coherency between the cache 130 and the association table 300, the StringID generator 300 then locates the string in the association table 200 and changes the string's status to permanent in step 511. Thereafter, the StringID from the cache 130 is returned to the storage mechanism in step 512.
If the string is not in the cache 130 (step 506), the StringID generator 300 performs a lookup on the association table 300 in step 508. Here, the StringID generator 300 processes the request as before described in steps 310 through 314 in FIG. 3 , or as described in steps 410 through 414 in FIG. 4 . After the lookup, the StringID generator 300 returns the StringID to the requesting mechanism in step 512. In one embodiment, the StringID generator 300 also stores the string, its StringID, and the status in the cache 130.
In an embodiment, the cache 130 can store strings that are particularly relevant to the server 104. A database administrator can stock the cache 130 with default entries from the association table 200, or with entries from a copy of the cache 130 that was created previously. Accordingly, the cache 130 is “primed” when the DBMS 105 is initiated. By utilizing the cache 130 according to the embodiment described above, access to the association table 200 is minimized. By minimizing such access, the conversion from strings to StringIDs is faster and less costly.
An improved method and system for processing structured documents stored in a database is disclosed. According to an embodiment, a global association table 200 is provided to store strings and their respective StringIDs. In the embodiment, the strings correspond to element names, attribute names, and namespaces found in documents stored in the database. Because a global association table 200 is utilized, a StringID for a particular string can be used in place of the string throughout the database. By replacing strings with their respective StringIDs, document processing and storage are significantly improved.
Although the present invention has been described in accordance with the embodiments shown, one of ordinary skill in the art will readily recognize that there could be variations to the embodiments and those variations would be within the spirit and scope of the present invention. Accordingly, many modifications may be made by one of ordinary skill in the art without departing from the spirit and scope of the appended claims.
Claims (22)
1. A method for processing a structured document, the method comprising:
identifying a plurality of strings processed by a database;
assigning an identifier to each of the plurality of strings;
storing each of the plurality of strings and its assigned identifier in a table in the database, wherein at least one string of the plurality of strings in the table in the database is derived from a source other than the structured documents stored in the database, and wherein at least another string of the plurality of strings in the table in the database is derived from the one or more structured documents stored in the database; and
utilizing the table during document processing at least by:
receiving a request to store a structured document in the database, wherein the structured document comprises a plurality of element, attribute, and namespace strings;
transforming the structured document by replacing the plurality of element, attribute, and namespace strings with their respective identifiers at least by:
requesting an identifier for one of the plurality of element, attribute, and namespace strings in the structured document;
performing a lookup on the table for the one string;
returning the identifier assigned to the one string when the one string is located in the table; and
assigning a new identifier to the one string, storing the one string and the new identifier in the table, designating a status of the one string as permanent, and returning the new identifier when the one string is not located in the table; and
storing the transformed structured document in the database.
2. The method of claim 1 , further comprising:
designating a status for each of the plurality of strings, wherein the status is one of a temporary status or a permanent status;
storing the status in the table; and
providing a cache in the database for storing a portion of the table.
3. The method of claim 1 , wherein transforming the structured document further comprises:
checking a current status of the one string when it is located in the table; and
changing the status of the one string to permanent when the current status is temporary.
4. The method of claim 2 , wherein utilizing the table during document processing comprises:
receiving a query, wherein the query comprises a plurality of element, attribute, and namespace strings;
transforming the query by replacing the plurality of element, attribute, and namespace strings with their respective identifiers; and
processing the transformed query.
5. The method of claim 4 , wherein transforming the query comprises:
requesting an identifier for one of the plurality of element, attribute, and namespace strings in the query;
checking the cache for the one string;
returning an identifier assigned to the one string when the one string is located in the cache;
performing a lookup on the table for the one string when the one string is not located in the cache;
returning the identifier assigned to the one string when the one string is located in the table; and
assigning a new identifier to the one string, storing the one string and the new identifier in the table, designating a status of the one string as temporary, and returning the new identifier when the one string is not located in the table.
6. The method of claim 1 , wherein the identifier is a fixed-sized integer.
7. The method of claim 1 , wherein the at least one string is derived from a query to the database.
8. A non-transitory computer readable medium containing a computer program for processing a structured document stored thereon, the computer program comprising instructions for:
identifying a plurality of strings processed by a database;
assigning an identifier to each of the plurality of strings;
storing each of the plurality of strings and its assigned identifier in a table in the database, wherein at least one string of the plurality of strings in the table in the database is derived from a source other than the structured documents stored in the database, and wherein at least another string of the plurality of strings in the table in the database is derived from the one or more structured documents stored in the database; and
utilizing the table during document processing at least by:
receiving a request to store a structured document in the database, wherein the structured document comprises a plurality of element, attribute, and namespace strings;
transforming the structured document by replacing the plurality of element, attribute, and namespace strings with their respective identifiers at least by:
requesting an identifier for one of the plurality of element, attribute, and namespace strings in the structured document;
performing a lookup on the table for the one string;
returning the identifier assigned to the one string when the one string is located in the table; and
assigning a new identifier to the one string, storing the one string and the new identifier in the table, designating a status of the one string as permanent, and returning the new identifier when the one string is not located in the table; and
storing the transformed structured document in the database.
9. The computer readable medium of claim 8 , wherein the computer program further comprises instructions for:
designating a status for each of the plurality of strings, wherein the status is one of a temporary status or a permanent status;
storing the status in the table; and
providing a cache in the database for storing a portion of the table.
10. The computer readable medium of claim 8 , wherein transforming the structured document further comprises:
checking a current status of the one string when it is located in the table; and
changing the status of the one string to permanent when the current status is temporary.
11. The computer readable medium of claim 9 , wherein utilizing the table during document processing comprises:
receiving a query, wherein the query comprises a plurality of element, attribute, and namespace strings;
transforming the query by replacing the plurality of element, attribute, and namespace strings with their respective identifiers; and
processing the transformed query.
12. The computer readable medium of claim 11 , wherein transforming the query comprises:
requesting an identifier for one of the plurality of element, attribute, and namespace strings in the query;
checking the cache for the one string;
returning an identifier assigned to the one string when the one string is located in the cache;
performing a lookup on the table for the one string when the one string is not located in the cache;
returning the identifier assigned to the one string when the one string is located in the table; and
assigning a new identifier to the one string, storing the one string and the new identifier in the table, designating a status of the one string as temporary, and returning the new identifier when the one string is not located in the table.
13. The computer readable medium of claim 8 , wherein the identifier is a fixed-sized integer.
14. The computer readable medium of claim 8 , wherein the at least one string is derived from a query to the database.
15. A system for processing a structured document, the system comprising:
a string identifier generator operable to:
identify a plurality of strings processed by the database, and
assign an identifier to each of the plurality of strings;
a database in communication with the string identifier generator, the database including a table operable to store each of the plurality of strings and its assigned identifier, wherein at least one string of the plurality of strings in the table in the database is derived from a source other than the structured documents stored in the database, and wherein at least another string of the plurality of strings in the table in the database is derived from the one or more structured documents stored in the database; and
a cache in communication with the string identifier generator and the database, the cache being operable to store a portion of the table,
wherein the table and the cache are utilized during document processing at least by:
receiving a request to store a structured document in the database, wherein the structured document comprises a plurality of element, attribute, and namespace strings;
the transforming the structured document by replacing the plurality of element, attribute, and namespace strings with their respective identifiers at least by:
requesting an identifier for one of the plurality of element, attribute, and namespace strings in the structured document;
performing a lookup on the table for the one string;
returning the identifier assigned to the one string when the one string is located in the table; and
assigning a new identifier to the one string, storing the one string and the new identifier in the table, designating a status of the one string as permanent, and returning the new identifier when the one string is not located in the table; and
storing the transformed structured document in the database.
16. The system of claim 15 , wherein the string identifier generator is further operable to:
designate a status for each of the plurality of strings, wherein the status is one of a temporary status or a permanent status, and
store the status in the table.
17. The system of claim 16 , further comprising:
a storage mechanism in communication with the string identifier generator, the database, and the cache, the storage mechanism being operable to receive and store a structured document in the database.
18. The system of claim 15 , wherein the string identifier generator is further operable to:
check a current status of the string when it is located in the table and
change the status of the string to permanent when the current status is temporary.
19. The system of claim 16 , further comprising:
a compiler in communication with the string identifier generator, the database, and the cache, the compiler being operable to receive and process a query to the database.
20. The system of claim 19 , wherein the string identifier generator is further operable to:
receive a request for an identifier for a string from the compiler,
check the cache for the string,
return an identifier assigned to the string when the string is located in the cache,
perform a lookup on the table for the string when the string is not located in the cache,
return the identifier assigned to the string when the string is located in the table, and
assign a new identifier to the string, store the string and the new identifier in the table, designate a status of the string as temporary, and return the new identifier when the string is not located in the table.
21. The system of claim 15 , wherein the identifier is a fixed-sized integer.
22. The system of claim 15 , wherein the at least one string is derived from a query to the database.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US13/239,695 US9600597B2 (en) | 2003-08-28 | 2011-09-22 | Processing structured documents stored in a database |
Applications Claiming Priority (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US10/652,662 US7171430B2 (en) | 2003-08-28 | 2003-08-28 | Method and system for processing structured documents in a native database |
US11/530,839 US7512608B2 (en) | 2003-08-28 | 2006-09-11 | Method for processing structured documents stored in a database |
US12/398,716 US8037090B2 (en) | 2003-08-28 | 2009-03-05 | Processing structured documents stored in a database |
US13/239,695 US9600597B2 (en) | 2003-08-28 | 2011-09-22 | Processing structured documents stored in a database |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US12/398,716 Continuation US8037090B2 (en) | 2003-08-28 | 2009-03-05 | Processing structured documents stored in a database |
Publications (2)
Publication Number | Publication Date |
---|---|
US20120011136A1 US20120011136A1 (en) | 2012-01-12 |
US9600597B2 true US9600597B2 (en) | 2017-03-21 |
Family
ID=34217699
Family Applications (4)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US10/652,662 Expired - Fee Related US7171430B2 (en) | 2003-08-28 | 2003-08-28 | Method and system for processing structured documents in a native database |
US11/530,839 Expired - Fee Related US7512608B2 (en) | 2003-08-28 | 2006-09-11 | Method for processing structured documents stored in a database |
US12/398,716 Expired - Fee Related US8037090B2 (en) | 2003-08-28 | 2009-03-05 | Processing structured documents stored in a database |
US13/239,695 Expired - Fee Related US9600597B2 (en) | 2003-08-28 | 2011-09-22 | Processing structured documents stored in a database |
Family Applications Before (3)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US10/652,662 Expired - Fee Related US7171430B2 (en) | 2003-08-28 | 2003-08-28 | Method and system for processing structured documents in a native database |
US11/530,839 Expired - Fee Related US7512608B2 (en) | 2003-08-28 | 2006-09-11 | Method for processing structured documents stored in a database |
US12/398,716 Expired - Fee Related US8037090B2 (en) | 2003-08-28 | 2009-03-05 | Processing structured documents stored in a database |
Country Status (1)
Country | Link |
---|---|
US (4) | US7171430B2 (en) |
Families Citing this family (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7171430B2 (en) * | 2003-08-28 | 2007-01-30 | International Business Machines Corporation | Method and system for processing structured documents in a native database |
WO2007076327A2 (en) * | 2005-12-19 | 2007-07-05 | Supplyscape Corporation | Method and system for compression of structured textual documents |
US20080183657A1 (en) * | 2007-01-26 | 2008-07-31 | Yuan-Chi Chang | Method and apparatus for providing direct access to unique hierarchical data items |
US8086633B2 (en) | 2009-08-27 | 2011-12-27 | International Business Machines Corporation | Unified user identification with automatic mapping and database absence handling |
KR101122629B1 (en) * | 2011-11-18 | 2012-03-09 | 김춘기 | Method for creation of xml document using data converting of database |
US9898523B2 (en) | 2013-04-22 | 2018-02-20 | Abb Research Ltd. | Tabular data parsing in document(s) |
CN106503003A (en) * | 2015-09-06 | 2017-03-15 | 阿里巴巴集团控股有限公司 | A kind of compression of expandable mark language XML document, decompressing method and device |
Citations (26)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5642514A (en) | 1995-05-24 | 1997-06-24 | International Business Machines Corporation | Method and system for constructing compact executable files by eliminating redundant debugging strings |
US5956704A (en) | 1997-06-05 | 1999-09-21 | Oracle Corporation | Method and apparatus for parallelizing operations that insert data into an existing data container |
EP0992873A2 (en) | 1998-10-09 | 2000-04-12 | Kabushiki Kaisha Toshiba | Access-right setting system and storage medium |
US6212629B1 (en) | 1989-02-24 | 2001-04-03 | Advanced Micro Devices, Inc. | Method and apparatus for executing string instructions |
US6236996B1 (en) | 1997-10-31 | 2001-05-22 | Sun Microsystems, Inc. | System and method for restricting database access to managed object information using a permissions table that specifies access rights to the managed objects |
US6308173B1 (en) | 1994-12-13 | 2001-10-23 | Microsoft Corporation | Methods and arrangements for controlling resource access in a networked computing environment |
US6366934B1 (en) | 1998-10-08 | 2002-04-02 | International Business Machines Corporation | Method and apparatus for querying structured documents using a database extender |
US6421656B1 (en) | 1998-10-08 | 2002-07-16 | International Business Machines Corporation | Method and apparatus for creating structure indexes for a data base extender |
US20020099715A1 (en) | 2001-01-22 | 2002-07-25 | Sun Microsystems, Inc. | Method and structure for storing data of an XML-document in a relational database |
US20020156811A1 (en) | 2000-05-23 | 2002-10-24 | Krupa Kenneth A. | System and method for converting an XML data structure into a relational database |
US6480865B1 (en) | 1998-10-05 | 2002-11-12 | International Business Machines Corporation | Facility for adding dynamism to an extensible markup language |
US6487566B1 (en) | 1998-10-05 | 2002-11-26 | International Business Machines Corporation | Transforming documents using pattern matching and a replacement language |
US6502101B1 (en) | 2000-07-13 | 2002-12-31 | Microsoft Corporation | Converting a hierarchical data structure into a flat data structure |
WO2003005236A2 (en) | 2001-07-05 | 2003-01-16 | Lion Bioscience Ag | Method and apparatus for creating, maintaining and using a reference database |
US6519597B1 (en) | 1998-10-08 | 2003-02-11 | International Business Machines Corporation | Method and apparatus for indexing structured documents with rich data types |
US6581060B1 (en) | 2000-06-21 | 2003-06-17 | International Business Machines Corporation | System and method for RDBMS to protect records in accordance with non-RDBMS access control rules |
US6581062B1 (en) | 2000-03-02 | 2003-06-17 | Nimble Technology, Inc. | Method and apparatus for storing semi-structured data in a structured manner |
US6631371B1 (en) | 1998-10-05 | 2003-10-07 | Oracle International Corporation | Database fine-grained access control |
US6658652B1 (en) | 2000-06-08 | 2003-12-02 | International Business Machines Corporation | Method and system for shadow heap memory leak detection and other heap analysis in an object-oriented environment during real-time trace processing |
US20040044959A1 (en) | 2002-08-30 | 2004-03-04 | Jayavel Shanmugasundaram | System, method, and computer program product for querying XML documents using a relational database system |
US6757680B1 (en) | 2000-07-03 | 2004-06-29 | International Business Machines Corporation | System and method for inheriting access control rules |
US6785728B1 (en) | 1997-03-10 | 2004-08-31 | David S. Schneider | Distributed administration of access to information |
US6804677B2 (en) | 2001-02-26 | 2004-10-12 | Ori Software Development Ltd. | Encoding semi-structured data for efficient search and browsing |
US20040210826A1 (en) * | 2003-04-15 | 2004-10-21 | Microsoft Corporation | System and method for maintaining a distributed database of hyperlinks |
US6938204B1 (en) | 2000-08-31 | 2005-08-30 | International Business Machines Corporation | Array-based extensible document storage format |
US7171430B2 (en) | 2003-08-28 | 2007-01-30 | International Business Machines Corporation | Method and system for processing structured documents in a native database |
-
2003
- 2003-08-28 US US10/652,662 patent/US7171430B2/en not_active Expired - Fee Related
-
2006
- 2006-09-11 US US11/530,839 patent/US7512608B2/en not_active Expired - Fee Related
-
2009
- 2009-03-05 US US12/398,716 patent/US8037090B2/en not_active Expired - Fee Related
-
2011
- 2011-09-22 US US13/239,695 patent/US9600597B2/en not_active Expired - Fee Related
Patent Citations (28)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6212629B1 (en) | 1989-02-24 | 2001-04-03 | Advanced Micro Devices, Inc. | Method and apparatus for executing string instructions |
US6308173B1 (en) | 1994-12-13 | 2001-10-23 | Microsoft Corporation | Methods and arrangements for controlling resource access in a networked computing environment |
US5642514A (en) | 1995-05-24 | 1997-06-24 | International Business Machines Corporation | Method and system for constructing compact executable files by eliminating redundant debugging strings |
US6785728B1 (en) | 1997-03-10 | 2004-08-31 | David S. Schneider | Distributed administration of access to information |
US5956704A (en) | 1997-06-05 | 1999-09-21 | Oracle Corporation | Method and apparatus for parallelizing operations that insert data into an existing data container |
US6236996B1 (en) | 1997-10-31 | 2001-05-22 | Sun Microsystems, Inc. | System and method for restricting database access to managed object information using a permissions table that specifies access rights to the managed objects |
US6480865B1 (en) | 1998-10-05 | 2002-11-12 | International Business Machines Corporation | Facility for adding dynamism to an extensible markup language |
US6631371B1 (en) | 1998-10-05 | 2003-10-07 | Oracle International Corporation | Database fine-grained access control |
US6487566B1 (en) | 1998-10-05 | 2002-11-26 | International Business Machines Corporation | Transforming documents using pattern matching and a replacement language |
US6421656B1 (en) | 1998-10-08 | 2002-07-16 | International Business Machines Corporation | Method and apparatus for creating structure indexes for a data base extender |
US6366934B1 (en) | 1998-10-08 | 2002-04-02 | International Business Machines Corporation | Method and apparatus for querying structured documents using a database extender |
US6519597B1 (en) | 1998-10-08 | 2003-02-11 | International Business Machines Corporation | Method and apparatus for indexing structured documents with rich data types |
EP0992873A2 (en) | 1998-10-09 | 2000-04-12 | Kabushiki Kaisha Toshiba | Access-right setting system and storage medium |
US6581062B1 (en) | 2000-03-02 | 2003-06-17 | Nimble Technology, Inc. | Method and apparatus for storing semi-structured data in a structured manner |
US20020156811A1 (en) | 2000-05-23 | 2002-10-24 | Krupa Kenneth A. | System and method for converting an XML data structure into a relational database |
US6658652B1 (en) | 2000-06-08 | 2003-12-02 | International Business Machines Corporation | Method and system for shadow heap memory leak detection and other heap analysis in an object-oriented environment during real-time trace processing |
US6581060B1 (en) | 2000-06-21 | 2003-06-17 | International Business Machines Corporation | System and method for RDBMS to protect records in accordance with non-RDBMS access control rules |
US6757680B1 (en) | 2000-07-03 | 2004-06-29 | International Business Machines Corporation | System and method for inheriting access control rules |
US6502101B1 (en) | 2000-07-13 | 2002-12-31 | Microsoft Corporation | Converting a hierarchical data structure into a flat data structure |
US6938204B1 (en) | 2000-08-31 | 2005-08-30 | International Business Machines Corporation | Array-based extensible document storage format |
US20020099715A1 (en) | 2001-01-22 | 2002-07-25 | Sun Microsystems, Inc. | Method and structure for storing data of an XML-document in a relational database |
US6804677B2 (en) | 2001-02-26 | 2004-10-12 | Ori Software Development Ltd. | Encoding semi-structured data for efficient search and browsing |
WO2003005236A2 (en) | 2001-07-05 | 2003-01-16 | Lion Bioscience Ag | Method and apparatus for creating, maintaining and using a reference database |
US20040044959A1 (en) | 2002-08-30 | 2004-03-04 | Jayavel Shanmugasundaram | System, method, and computer program product for querying XML documents using a relational database system |
US20040210826A1 (en) * | 2003-04-15 | 2004-10-21 | Microsoft Corporation | System and method for maintaining a distributed database of hyperlinks |
US7171430B2 (en) | 2003-08-28 | 2007-01-30 | International Business Machines Corporation | Method and system for processing structured documents in a native database |
US7512608B2 (en) | 2003-08-28 | 2009-03-31 | International Business Machines Corporation | Method for processing structured documents stored in a database |
US20090171926A1 (en) | 2003-08-28 | 2009-07-02 | International Business Machines Corporation | Processing Structured Documents Stored in a Database |
Non-Patent Citations (5)
Title |
---|
Damiani, Ernesto et al., "A Fine-Grained Access Control System for XML Documents", ACM Transactions on Information and System Security, vol. 5, No. 2, May 2002, pp. 169-202. |
Lyons, Seamus et al., "Domain-Specific Information Extraction Structures", Proceedings of the 13th International Workshop on Database and Expert Systems Applications (DEXA '02), 2002, pp. 1-5. |
U.S. Appl. No. 10/652,662. |
U.S. Appl. No. 11/530,839. |
U.S. Appl. No. 12/398,716. |
Also Published As
Publication number | Publication date |
---|---|
US20070005620A1 (en) | 2007-01-04 |
US20050050467A1 (en) | 2005-03-03 |
US20120011136A1 (en) | 2012-01-12 |
US8037090B2 (en) | 2011-10-11 |
US20090171926A1 (en) | 2009-07-02 |
US7171430B2 (en) | 2007-01-30 |
US7512608B2 (en) | 2009-03-31 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9448944B2 (en) | Method and system for dynamic templatized query language in software | |
US5737736A (en) | Method and apparatus for storing objects using a c-structure and a bind descriptor | |
US9600597B2 (en) | Processing structured documents stored in a database | |
US6449620B1 (en) | Method and apparatus for generating information pages using semi-structured data stored in a structured manner | |
US6581062B1 (en) | Method and apparatus for storing semi-structured data in a structured manner | |
US8145685B2 (en) | Object relational mapping layer | |
US8145668B2 (en) | Associating information related to components in structured documents stored in their native format in a database | |
US20020078041A1 (en) | System and method of translating a universal query language to SQL | |
US20110184969A1 (en) | Techniques for fast and scalable xml generation and aggregation over binary xml | |
US6915303B2 (en) | Code generator system for digital libraries | |
CN111831684B (en) | Data query method, device and computer readable storage medium | |
US20050050011A1 (en) | Method and system for querying structured documents stored in their native format in a database | |
US7536398B2 (en) | On-line organization of data sets | |
CN112347794B (en) | Data translation method, device, equipment and computer storage medium | |
KR100678123B1 (en) | Method for storing xml data in relational database |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
FEPP | Fee payment procedure |
Free format text: MAINTENANCE FEE REMINDER MAILED (ORIGINAL EVENT CODE: REM.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
LAPS | Lapse for failure to pay maintenance fees |
Free format text: PATENT EXPIRED FOR FAILURE TO PAY MAINTENANCE FEES (ORIGINAL EVENT CODE: EXP.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
STCH | Information on status: patent discontinuation |
Free format text: PATENT EXPIRED DUE TO NONPAYMENT OF MAINTENANCE FEES UNDER 37 CFR 1.362 |
|
FP | Lapsed due to failure to pay maintenance fee |
Effective date: 20210321 |