# US 2014/0156709 A1 · Aggregating keys of dependent objects for a given primary object

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2014/0156709 A1
- Document ID: US20140156709A1
- Status: Published application
- Kind: A1
- Application number: 13/693,412
- Filed: 2012-12-04
- Published: 2014-06-05
- Earliest claimed: 2012-12-04
- Assignees: CA, Inc.
- Applicants: Ca, Inc.
- Inventors: B.V.K.VENU GOPALA RAO; MURUGANANDAM SOMASUNDARAM; JAMES L. BROADHURST; TIMOTHY J. WELTZER
- Web page: https://patentgrep.com/patent/US20140156709A1

## CPC

- G06F 16/2282: {Tablespace storage structures; Management thereof}
- G06F 16/282: {Hierarchical databases, e.g. IMS, LDAP data stores or Lotus Notes}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Keys are obtained and aggregated by storing a primary object as an entry in a parent keys storage and a child keys storage, the entry identified as unvisited in each. An object evaluation process is then performed until all unique entries in the parent keys storage and all unique entries in the child keys storage have been visited and by committing the keys of at least one related object as an entry to the hierarchical database. The object evaluation process visits each unvisited object in the parent keys storage and child keys storage by selecting, for the unvisited object, objects in the parent direction that have not already been visited and objects in the child direction that have not already been visited and by inserting the keys of the selected related objects as entries in the parent keys storage or child keys storage.

## Claims

### Claim 1

A method of obtaining and aggregating keys of objects, comprising:
obtaining a primary object input comprising a primary object of a hierarchical database;
storing the primary object as an entry in a parent keys storage, the entry identified as unvisited;
storing the primary object as an entry in a child keys storage, the entry identified as unvisited;
performing an object evaluation process until all unique entries in the parent keys storage and all unique entries in the child keys storage have been visited, wherein the object evaluation process selects related objects of the primary object by:
visiting each unvisited object in the parent keys storage to select related parent keys objects by:
selecting, for the unvisited object, related objects comprising parent objects in the parent direction that have not already been visited and child objects in the parent direction that have not already been visited; and
inserting the selected related objects as entries in the parent keys storage identified as unvisited; and
visiting each unvisited object in the child keys storage to select related child keys objects by:
selecting, for the unvisited object, related objects comprising child objects in the child direction that have not already been visited and parent objects in the child direction that have not already been visited; and
inserting the selected related objects as entries in the child keys storage identified as unvisited; and
committing the keys of at least one related object as an entry to the hierarchical database.

### Claim 2 (depends on 1)

The method of claim 1, wherein:
obtaining a primary object input comprises receiving a set of parameters passed as inputs, the parameters including a name of a results table, the object type of the primary object input and the at least one primary key;
storing the primary object as an entry in a parent keys storage comprises storing the object type of the primary object input and the at least one primary key; and
storing the primary object as an entry in a child keys storage comprises storing the object type of the primary object input and the at least one primary key.

### Claim 3 (depends on 1)

The method of claim 1 further comprising:
creating the parent keys storage as two temporary tables comprising a visited parent keys table and an unvisited parent keys table;
creating the child keys storage as two temporary tables comprising a visited child keys table and an unvisited child keys table;
deleting each object from the unvisited parent keys table after the object has been visited; and
deleting each object from the unvisited child keys table after the object has been visited;
wherein:
storing the primary object as an entry in a parent keys storage, the entry identified as unvisited, comprises inserting the primary object in the unvisited parent keys table;
storing the primary object as an entry in a child keys storage, the entry identified as unvisited, comprises inserting the primary object in the unvisited child keys table;
visiting each unvisited object in the parent keys storage further comprises identifying a next unvisited object in the unvisited parent keys table and inserting the identified next unvisited object in the visited parent keys table;
inserting the selected related objects as entries in the parent keys storage identified as unvisited, comprises inserting the selected related parent keys objects in the unvisited parent keys table;
visiting each unvisited object in the child keys storage further comprises identifying a next unvisited object in the unvisited child keys table and inserting the identified next unvisited object in the visited child keys table; and
inserting the selected related objects as entries in the child keys storage identified as unvisited, comprises inserting the selected related child keys objects in the unvisited child keys table.

### Claim 4 (depends on 1)

The method of claim 1, wherein:
visiting each unvisited object in the parent keys storage to select related parent keys objects, further comprises initially setting a compound query to empty;
selecting, for the unvisited object, related objects comprising parent objects in the parent direction that have not already been visited and child objects in the parent direction that have not already been visited, comprises preparing a select query to obtain the values of the primary keys of the related objects and appending the select query to the compound query;
inserting the selected related objects as entries in the parent keys storage identified as unvisited, comprises adding the selected related objects using the compound query;
visiting each unvisited object in the child keys storage to select related child keys objects, further comprises initially setting a compound query to empty;
selecting, for the unvisited object, related objects comprising child objects in the child direction that have not already been visited and parent objects in the child direction that have not already been visited, comprises preparing a select query to obtain the values of the primary keys of the related objects and appending the select query to the compound query; and
inserting the selected related child keys objects as entries in the child keys storage marked as unvisited, comprises adding the selected related objects using the compound query.

### Claim 5 (depends on 1)

The method of claim 1, wherein:
selecting, for the unvisited object, related objects comprising parent objects in the parent direction that have not already been visited and child objects in the parent direction that have not already been visited, comprises:
obtaining the primary keys of the unvisited object;
preparing a select query for related objects in the parent direction; and
performing for each related object,
obtaining the primary keys of the related object;
preparing a select query that obtains the values of the primary keys of the related object; and
appending the select query to a compound query.

### Claim 6 (depends on 5)

The method of claim 5 further comprising:
preparing a select query for Minor objects; and
performing for each Minor object:
obtaining the primary keys of the Minor object;
preparing a select query that obtains the values of the primary keys of the Minor object; and
appending the select query to a compound query;
wherein:
inserting the selected related objects as entries in the parent keys storage identified as unvisited comprises adding unvisited keys using the compound query statement.

### Claim 7 (depends on 1)

The method of claim 1, wherein:
selecting, for the unvisited object, related objects comprising child objects in the child direction that have not already been visited and parent objects in the child direction that have not already been visited, comprises:
obtaining the primary keys of the unvisited object;
preparing a select query for related objects in the child direction; and
performing for each related object,
obtaining the primary keys of the related object;
preparing a select query that obtains the values of the primary keys of the related object; and
appending the select query to a compound query.

### Claim 8 (depends on 7)

The method of claim 7 further comprising:
preparing a select query for Major objects; and
performing for each Major object:
obtaining the primary keys of the Major object;
preparing a select query that obtains the values of the primary keys of the Major object; and
appending the select query to a compound query;
wherein:
inserting the selected related objects as entries in the child keys storage identified as unvisited comprises adding unvisited keys using the compound query statement.

### Claim 9

A computer program product that obtains and aggregates keys of objects, comprising:
a computer readable storage medium comprising computer readable program code embodied therewith, the computer readable program code comprising:
computer readable program code to obtain a primary object input comprising a primary object of a hierarchical database;
computer readable program code to store the primary object as an entry in a parent keys storage, the entry identified as unvisited;
computer readable program code to store the primary object as an entry in a child keys storage, the entry identified as unvisited;
computer readable program code to perform an object evaluation process until all unique entries in the parent keys storage and all unique entries in the child keys storage have been visited, wherein the object evaluation process selects related objects of the primary object comprising:
computer readable program code to visit each unvisited object in the parent keys storage to select related parent keys objects by:
computer readable program code to select, for the unvisited object, related objects comprising parent objects in the parent direction that have not already been visited and child objects in the parent direction that have not already been visited; and
computer readable program code to insert the selected related objects as entries in the parent keys storage identified as unvisited;
computer readable program code to visit each unvisited object in the child keys storage to select related child keys objects comprising:
computer readable program code to select, for the unvisited object, related objects comprising child objects in the child direction that have not already been visited and parent objects in the child direction that have not already been visited; and
computer readable program code to insert the selected related objects as entries in the child keys storage identified as unvisited; and
computer readable program code to commit the keys of at least one related object as an entry to the hierarchical database.

### Claim 10 (depends on 9)

The computer program product of claim 9, wherein:
the computer readable program code to obtain a primary object input comprises computer readable program code to receive a set of parameters passed as inputs, the parameters including a name of a results table, the object type of the primary object input and the at least one primary key;
the computer readable program code to store the primary object as an entry in a parent keys storage comprises computer readable program code to store the object type of the primary object input and the at least one primary key; and
the computer readable program code to store the primary object as an entry in a child keys storage comprises computer readable program code to store the object type of the primary object input and the at least one primary key.

### Claim 11 (depends on 9)

The computer program product of claim 9 further comprising:
computer readable program code to create the parent keys storage as two temporary tables comprising a visited parent keys table and an unvisited parent keys table;
computer readable program code to create the child keys storage as two temporary tables comprising a visited child keys table and an unvisited child keys table;
computer readable program code to delete each object from the unvisited parent keys table after the object has been visited; and
computer readable program code to delete each object from the unvisited child keys table after the object has been visited;
wherein:
the computer readable program code to store the primary object as an entry in a parent keys storage, the entry identified as unvisited, comprises computer readable program code to insert the primary object in the unvisited parent keys table;
the computer readable program code to store the primary object as an entry in a child keys storage, the entry identified as unvisited, comprises computer readable program code to insert the primary object in the unvisited child keys table;
the computer readable program code to visit each unvisited object in the parent keys storage further comprises computer readable program code to identify a next unvisited object in the unvisited parent keys table and insert the identified next unvisited object in the visited parent keys table;
the computer readable program code to insert the selected related objects as entries in the parent keys storage identified as unvisited, comprises computer readable program code to insert the selected related parent keys objects in the unvisited parent keys table;
the computer readable program code to visit each unvisited object in the child keys storage further comprises computer readable program code to identify a next unvisited object in the unvisited child keys table and insert the identified next unvisited object in the visited child keys table; and
the computer readable program code to insert the selected related objects as entries in the child keys storage identified as unvisited, comprises computer readable program code to insert the selected related child keys objects in the unvisited child keys table.

### Claim 12 (depends on 9)

The computer program product of claim 9, wherein:
the computer readable program code to visit each unvisited object in the parent keys storage to select related parent keys objects, further comprises computer readable program code to initially set a compound query to empty;
the computer readable program code to select, for the unvisited object, related objects comprising parent objects in the parent direction that have not already been visited and child objects in the parent direction that have not already been visited, comprises computer readable program code to prepare a select query to obtain the values of the primary keys of the related objects and append the select query to the compound query;
the computer readable program code to insert the selected related objects as entries in the parent keys storage identified as unvisited, comprises computer readable program code to add the selected related objects using the compound query;
the computer readable program code to visit each unvisited object in the child keys storage to select related child keys objects, further comprises computer readable program code to initially set a compound query to empty;
the computer readable program code to select, for the unvisited object, related objects comprising child objects in the child direction that have not already been visited and parent objects in the child direction that have not already been visited, comprises computer readable program code to prepare a select query to obtain the values of the primary keys of the related objects and append the select query to the compound query; and
the computer readable program code to insert the selected related child keys objects as entries in the child keys storage marked as unvisited, comprises computer readable program code to add the selected related objects using the compound query.

### Claim 13 (depends on 9)

The computer program product of claim 9, wherein:
the computer readable program code to select, for the unvisited object, related objects comprising parent objects in the parent direction that have not already been visited and child objects in the parent direction that have not already been visited, comprises:
computer readable program code to obtain the primary keys of the unvisited object;
computer readable program code to prepare a select query for related objects in the parent direction; and
computer readable program code to perform for each related object:
computer readable program code to obtain the primary keys of the related object;
computer readable program code to prepare a select query that obtains the values of the primary keys of the related object; and
computer readable program code to append the select query to a compound query.

### Claim 14 (depends on 13)

The computer program product of claim 13 further comprising:
computer readable program code to prepare a select query for Minor objects; and
performing for each Minor object,
computer readable program code to obtain the primary keys of the Minor object;
computer readable program code to prepare a select query that obtains the values of the primary keys of the Minor object; and
computer readable program code to append the select query to a compound query;
wherein:
the computer readable program code to insert the selected related objects as entries in the parent keys storage identified as unvisited comprises computer readable program code to add unvisited keys using the compound query statement.

### Claim 15 (depends on 9)

The computer program product of claim 9, wherein:
the computer readable program code to select, for the unvisited object, related objects comprising child objects in the child direction that have not already been visited and parent objects in the child direction that have not already been visited, comprises:
computer readable program code to obtain the primary keys of the unvisited object;
computer readable program code to prepare a select query for related objects in the child direction; and
computer readable program code to perform for each related object:
computer readable program code to obtain the primary keys of the related object;
computer readable program code to prepare a select query that obtains the values of the primary keys of the related object; and
computer readable program code to append the select query to a compound query.

### Claim 16 (depends on 15)

The computer program product of claim 15 further comprising:
computer readable program code to prepare a select query for Major objects; and
performing for each Major object,
computer readable program code to obtain the primary keys of the Major object;
computer readable program code to prepare a select query that obtains the values of the primary keys of the Major object; and
computer readable program code to append the select query to a compound query;
wherein:
the computer readable program code to insert the selected related objects as entries in the child keys storage identified as unvisited comprises computer readable program code to add unvisited keys using the compound query statement.

### Claim 17

A machine for obtaining and aggregating keys, comprising:
a microprocessor coupled to a memory, wherein the microprocessor is programmed by code in the memory to obtain and aggregate keys of objects by:
obtaining a primary object input comprising a primary object of a hierarchical database;
storing the primary object as an entry in a parent keys storage, the entry identified as unvisited;
storing the primary object as an entry in a child keys storage, the entry identified as unvisited;
performing an object evaluation process until all unique entries in the parent keys storage and all unique entries in the child keys storage have been visited, wherein the object evaluation process selects related objects of the primary object by:
visiting each unvisited object in the parent keys storage to select related parent keys objects by:
selecting, for the unvisited object, related objects comprising parent objects in the parent direction that have not already been visited and child objects in the parent direction that have not already been visited; and
inserting the selected related objects as entries in the parent keys storage identified as unvisited;
visiting each unvisited object in the child keys storage to select related child keys objects by:
selecting, for the unvisited object, related objects comprising child objects in the child direction that have not already been visited and parent objects in the child direction that have not already been visited; and
inserting the selected related objects as entries in the child keys storage identified as unvisited; and
committing the keys of at least one related object as an entry to the hierarchical database.

### Claim 18 (depends on 17)

The machine of claim 17, wherein:
the code in the memory for obtaining a primary object input comprises code for receiving a set of parameters passed as inputs, the parameters including a name of a results table, the object type of the primary object input and the at least one primary key;
the code in the memory for storing the primary object as an entry in a parent keys storage comprises code for storing the object type of the primary object input and the at least one primary key; and
the code in the memory for storing the primary object as an entry in a child keys storage comprises code for storing the object type of the primary object input and the at least one primary key.

### Claim 19 (depends on 17)

The machine of claim 17 further comprising code in the memory for:
creating the parent keys storage as two temporary tables comprising a visited parent keys table and an unvisited parent keys table;
creating the child keys storage as two temporary tables comprising a visited child keys table and an unvisited child keys table;
deleting each object from the unvisited parent keys table after the object has been visited; and
deleting each object from the unvisited child keys table after the object has been visited;
wherein:
the code in the memory for storing the primary object as an entry in a parent keys storage, the entry identified as unvisited, comprises code for inserting the primary object in the unvisited parent keys table;
the code in the memory for storing the primary object as an entry in a child keys storage, the entry identified as unvisited, comprises code for inserting the primary object in the unvisited child keys table;
the code in the memory for visiting each unvisited object in the parent keys storage further comprises code for identifying a next unvisited object in the unvisited parent keys table and inserting the identified next unvisited object in the visited parent keys table;
the code in the memory for inserting the selected related objects as entries in the parent keys storage identified as unvisited, comprises code for inserting the selected related parent keys objects in the unvisited parent keys table;
the code in the memory for visiting each unvisited object in the child keys storage further comprises code for identifying a next unvisited object in the unvisited child keys table and inserting the identified next unvisited object in the visited child keys table; and
the code in the memory for inserting the selected related objects as entries in the child keys storage identified as unvisited, comprises code for inserting the selected related child keys objects in the unvisited child keys table.

### Claim 20 (depends on 17)

The machine of claim 17, wherein:
the code in the memory for visiting each unvisited object in the parent keys storage to select related parent keys objects, further comprises code for initially setting a compound query to empty;
the code in the memory for selecting, for the unvisited object, related objects comprising parent objects in the parent direction that have not already been visited and child objects in the parent direction that have not already been visited, comprises code for preparing a select query to obtain the values of the primary keys of the related objects and appending the select query to the compound query;
the code in the memory for inserting the selected related objects as entries in the parent keys storage identified as unvisited, comprises code for adding the selected related objects using the compound query;
the code in the memory for visiting each unvisited object in the child keys storage to select related child keys objects, further comprises code for initially setting a compound query to empty;
the code in the memory for selecting, for the unvisited object, related objects comprising child objects in the child direction that have not already been visited and parent objects in the child direction that have not already been visited, comprises code for preparing a select query to obtain the values of the primary keys of the related objects and appending the select query to the compound query; and
the code in the memory for inserting the selected related child keys objects as entries in the child keys storage marked as unvisited, comprises code for adding the selected related objects using the compound query.

### Claim 21 (depends on 17)

The machine of claim 17, wherein:
the code in the memory for selecting, for the unvisited object, related objects comprising parent objects in the parent direction that have not already been visited and child objects in the parent direction that have not already been visited, comprises code for:
obtaining the primary keys of the unvisited object;
preparing a select query for related objects in the parent direction; and
performing for each related object,
obtaining the primary keys of the related object;
preparing a select query that obtains the values of the primary keys of the related object; and
appending the select query to a compound query.

### Claim 22 (depends on 21)

The machine of claim 21 further comprising code stored in the memory for:
preparing a select query for Minor objects; and
performing for each Minor object:
obtaining the primary keys of the Minor object;
preparing a select query that obtains the values of the primary keys of the Minor object; and
appending the select query to a compound query;
wherein:
inserting the selected related objects as entries in the parent keys storage identified as unvisited comprises adding unvisited keys using the compound query statement.

### Claim 23 (depends on 17)

The machine of claim 17, wherein:
the code in the memory for selecting, for the unvisited object, related objects comprising child objects in the child direction that have not already been visited and parent objects in the child direction that have not already been visited, comprises code for:
obtaining the primary keys of the unvisited object;
preparing a select query for related objects in the child direction; and
performing for each related object,
obtaining the primary keys of the related object;
preparing a select query that obtains the values of the primary keys of the related object; and
appending the select query to a compound query.

### Claim 24 (depends on 23)

The machine of claim 23 further comprising code in the memory for:
preparing a select query for Major objects; and
performing for each Major object:
obtaining the primary keys of the Major object;
preparing a select query that obtains the values of the primary keys of the Major object; and
appending the select query to a compound query;
wherein:
inserting the selected related objects as entries in the child keys storage identified as unvisited comprises adding unvisited keys using the compound query statement.