Abstract:
A content management system is provided including a plurality of tables forming a tree-based storage hierarchy. The system includes a stored procedure which enables information to be retrieved from different arbitrary locations throughout the storage hierarchy. Advantageously, the system retrieves information from both simple and complex tree-based storage hierarchies.

Description:
CROSS REFERENCE TO RELATED PATENT APPLICATIONS 
   This patent application relates to U.S. patent application, Ser. No. 10/128,450 entitled Content Management System and Methodology Employing a Tree-Based Table Hierarchy Which Accommodates Opening a Dynamically Variable Number of Cursors, the disclosure of which is incorporated herein by reference. 
   FIELD OF THE INVENTION 
   The disclosures herein relate generally to databases and more particularly to methods and apparatus for accessing information stored in content management systems. 

   BACKGROUND 
   Conventional content management systems  50 , such as that shown in  FIG. 1A , typically include a Library Server (LS)  52 , one or more Resource Managers (RMs)  54  and a client access application program interface (API)  56 . A client  58  is coupled by a network to the API  56  and seeks information stored in the Resource Manager  54 . The Library Server  52  stores metadata relating to all objects or data stored in the Resource Manager  54 . The Library Server  52  also controls the particular objects that a particular client user can access. Client  58  users can submit requests known as queries through the API  56  to search or retrieve metadata stored in the Library Server  52  or objects stored in the Resource Manager  54 . 
   One approach employed to store items in a content management system is to model an item in a single table. Unfortunately, such as single table approach results in many fields among the rows and columns of the table being unused. Such an approach is inefficient from the storage viewpoint. In the past, flat data models have been used to store data in a content management system. For example,  FIG. 1B  shows an Item Type  60  which is represented by one root table  62  to form such a flat data storage model. 
   What is needed is a methodology and apparatus for providing a superior manner of storing and retrieving information in a content management system through the use of improved table structures. 
   SUMMARY 
   The disclosure herein involves a content management system which employs a hierarchical item type tree-based structure including tables at different levels to store metadata for items. A principal advantage of the embodiment disclosed herein is the ability to arbitrarily select or group component tables forming a complex tree-based structure and to then retrieve items therefrom in response to a query. 
   In one embodiment of the disclosed methodology, a method is provided for organizing information in a content management system including the step of creating a database including a root table and at least one child table together forming a tree hierarchy which stores information. The method also includes providing a stored procedure for accessing a selected arbitrary portion of the tree hierarchy. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
       FIG. 1A  is a high level block diagram of a conventional content management system showing both server and client. 
       FIG. 1B  is a representation of a flat storage data model showing one root table. 
       FIG. 2  is a block diagram of one embodiment of the content management system. 
       FIG. 3A  shows two representation complex tree structure data storage hierarchies as Item Type  1  and Item Type  2 . 
       FIG. 3B  is a more detailed representation of tables within a tree hierarchy. 
       FIG. 4  shows a representative multi-level tree structure data storage hierarchy including views thereof in more detail. 
       FIG. 5  is a flowchart showing more detail regarding the operation and capabilities of the GetItem Stored Procedure (GetItem SP) employed to retrieve information from arbitrary locations within a tree-based data storage hierarchy. 
   

   DETAILED DESCRIPTION 
     FIG. 2  is a block diagram of one embodiment of content management system  10 . A client computer  15  is coupled to content management system  10  via the system&#39;s application program interface (API)  20 . A library server (LS)  25  is coupled to API  20  and receives queries from client  15 . These queries seek information which is stored in library server  25  and/or resource manager  30 . Library server  25  is coupled to resource manager  30  and contains metadata concerning the data or objects that are stored in resource manager  30 . Many types of data can be stored in resource manager  30 , for example, business information, applications, operating systems, text, audio, video and streaming data, just to name a few. 
   Content manage system  10  employs a hierarchical item type tree structure in terms of a group of component tables (or views) at different levels to store metadata for items. A “GetItem” Stored Procedure  35  in library server  25  is used to arbitrarily select or group the component tables (or views) from a complex tree structure and then retrieve item information from selected component tables. Such a complex tree structure is shown in  FIG. 3A  which depicts a tree structure for Item Type  1  and another tree structure for Item Type  2 . More particularly, the Item Type  1  tree structure includes a root table  100  with child tables  105  and  110  extending therefrom. In turn, child tables  115  and  120  extend from child table  105 . Child table  125  extends from child table  120 . In this example, root table  100  and child tables,  105 ,  110 ,  115 ,  120  and  125  are component tables. Together all of these tables form a complex tree hierarchy for Item Type  1 . 
   A second complex tree structure data storage hierarchy is shown in  FIG. 3A  as Item Type  2 . The Item Type  2  tree structure includes a root table  150  with child tables  155  and  160  extending therefrom. Child table  165  extends from child table  160  and child table  170  extends from child table  165 . In this example, root table  150  and child tables,  150 ,  155 ,  160 ,  165  and  170  are component tables. Together all of these tables form the complex tree hierarchy of Item Type  2 . 
     FIG. 3B  illustrates a representative tree hierarchy in more detail. This tree hierarchy includes a user-defined component table  200  alternatively called a root table. Table  200  includes the columns ITEM ID, COMPONENT ID, and other system and user defined columns. The ellipses indicate that the table can extend further both vertically and horizontally from the representative portion shown. A child table  205  extends from root table  200  and includes a COMPONENT ID column and a PARENT COMPONENT ID column. The PARENT COMPONENT ID column is a foreign key that points back to a particular unique COMPONENT ID in root table  200 . Another child table  210  extends from child table  205  and includes a COMPONENT ID column and a PARENT COMPONENT ID column. The PARENT COMPONENT ID column is a foreign key that points back to a particular unique COMPONENT ID in child table  205 . A representative multi-level tree-based data storage hierarchy is thus shown in FIG.  3 B. 
     FIG. 4  is a more detailed representation of the tree hierarchy shown in  FIG. 3A  as Item Type  1 . It is often desirable to mask certain portions of a database from certain users. A “view” function is used to achieve this end. For example, it might be desirable for a particular database user to have access to another employee&#39;s home address but not their salary information. Views are used to accomplish this task. In  FIG. 4  such views are shown as component view  100 A, component view  105 A, child view  110 A, child view  115 A, child view  120 A and child view  125 A. 
   Returning to  FIG. 2 , the GetItem stored procedure  35  allows application users to arbitrarily select a group of component tables (or views) from any hierarchical levels within an item type (or item type view). Advantageously, this feature allows skipping levels in the tree hierarchy and/or skipping of siblings of the selected component table or component tables. Moreover, in an operational scenario where there are several item types (or item type views) in tree structures, users may select or group component tables (or views). The user can then retrieve items in a similar fashion in several different item types (or item type views) simultaneously. 
     FIG. 5  is a flowchart showing more detail regarding the operation and capabilities of the GetItem Stored Procedure (GetItem SP)  35 . GetItem SP  35  begins at start block  300 . At block  305  the following inputs are provided to GetItem SP  35 : 1) the number of Item Types (or views), 2) the Item Type ID or Item Type View ID of each Item Type (or view), 3) Component Type (or Component View) to start, 4) Item ID&#39;s or Component ID&#39;s with version information, and 5) Level Information. The above input parameters are parsed from LOB into structures at block  310 . LOB is a large object which is a data type used in DB2 to manage unstructured date. A “For Each Item Type (view)” loop is commenced at block  315 . At decision block  320  a determination is made regarding at which level the subject of the current input query request is located, namely 1) the current level, 2) the next level, or 3) all levels of the hierarchy. 
   If a determination is made that the subject of the current input query is the current level, then process flow continues to block  325 . A query of the component table is then conducted based on the input item ID&#39;s/component ID&#39;s. A cursor is opened using a dynamic linked library (DLL). Process flow then continues to block  330  where the system builds component type ID&#39;s (view ID&#39;s) sequence information into an LOB and sends the LOB back to the client  15  via API  20 . Then process flow continues back to start block  300 . 
   If a determination is made at decision block  320  that the subject of the current input query is the next level of the tree hierarchy, then process flow continues to block  335 . A query is then conducted of a system table to find all child component tables forming the next level. At block  340 , for each child table, a “Do query” is performed based on the parent child relation of the component ID using foreign keys in the child tables. A cursor is opened by invoking a DLL as described earlier. Process flow then continues to block  330  where the system builds component type ID&#39;s (view ID&#39;s) sequence information into an LOB and sends the LOB back to the client  15  via API  20 . Then process block continues back to start block  300 . 
   However, if a determination is made at decision block  320  that all levels in the tree hierarchy are the subject of the current input query, then process flow continues to block  345 . Note that a “for loop” within a “for loop” within still another “for loop” follows. More particularly, for each level in the tree hierarchy ( 345 ), for each table at this level all child tables are found ( 350 ) and for each of these child tables a query is performed ( 355 ) based on the parent-child relation of the component ID using the foreign key in the child table. A cursor is opened by invoking a DLL as earlier described. A determination is then made at decision block  360  to see if the bottom of the hierarchical tree has been reached. If the bottom of the tree has not been reached, then process flow continues back to block  350  at which GetItem SP  35  continues to cycle through levels. When decision block  360  ultimately determines that the bottom of the hierarchical tree has been reached, then process flow continues to decision block  365 . Decision block  365  checks to see if all Item Types (views) have been exhausted. If all Item Types (views) have not been exhausted than process flow continues back to block  315  where GetItem SP  35  cycles or moves on to the next Item Type (or view). However, when decision block  365  ultimately determines that all Item Types (or views) have been exhausted, then process flow continues to block  330 . At block  330  the system builds component type ID&#39;s (view ID&#39;s) sequence information into an LOB and sends the LOB back to the client  15  via API  20 . 
   In summary, to permit GetItem SP  35  to arbitrarily select or group the component tables (or views) from different hierarchical levels of the tree vertically and across several item types or item type views horizontally, “GetItem” stored procedure  35  is responsive to data at its input  35 A which 1) instructs GetItem SP  35  to retrieve items from a particular component table (or view) at any hierarchical level; 2) instructs GetItem SP  35  to retrieve items from all next-level child tables (or views) belonging to a specified component table (view) at any hierarchical level; and 3) instructs GetItem SP  35  to retrieve items from a specified component table (or view) and all of its child tables (or views) of all hierarchical levels below. 
   Moreover, a list of item types (or multiple item types) or item type view ID&#39;s can also be provided as input to GetItem SP  35 . Each ID can be repeated several times. It is noted that the number of the Item Type, or Item Type view IDs (sNumOf ItemType ViewID) should be specified as an input to GetItem SP  35 . For example, a representative input ID to GetItem SP  35  could be “ItemTypeView 1, ItemTypeView 1, and ItemTypeView2) wherein ItemTypeView 1 appears twice. In this particular example, the input for sNumOf ItemType would be 3. 
   The combination of GetInfo SP  35  input and sLevel and the list of item types or item type view IDs (including the repeated IDs) during an invocation of the GetItem SP provides application users with the ability to arbitrarily select component tables in multiple hierarchical structures. 
   In conclusion, when the GetItem  35  stored procedure is invoked and provided with the following data from a query from the client 1) number of Item Types (Item Type views; 2) Item Type ID (or Item Type View ID) for each Item Type (or view) 3) Component Type (or component view)—a starting point, 4) Item ID or Component ID and 5) Level (current level, immediate child or all children below), the disclosed content management system and methodology permit the user to locate information in virtually any arbitrary location in the often complex tree hierarchy which stores data in the system. 
   The disclosed content management system methodology and apparatus advantageously solves the problem of accessing information in a complex tree-based table data hierarchy. The content management system can be stored on virtually any computer-readable storage media, such as CD, DVD and other magnetic and optical media in either compressed or non-compressed form. Of course, it can also be stored on a server computer system or other information handling system. 
   Although illustrative embodiments have been shown and described, a wide range of modification, change and substitution is contemplated in the foregoing disclosure and in some instances, some features of an embodiment may be employed without a corresponding use of other features. Accordingly, it is appropriate that the appended claims be construed broadly and in a manner consistent with the scope of the embodiments disclosed herein.