Methods and systems for recursive saving of hierarchical objects to a database

• US 8,548,942 B2
• Filed: 03/19/2010
• Issued: 10/01/2013
• Est. Priority Date: 10/04/2006
• Status: Active Grant

• Current Assignee: Salesforce.com, Inc.
• Original Assignee: Salesforce.com, Inc.
• Inventors: Wong, Simon Y., Macklem, Walter, Hofhansl, Lars, Rajaram, Varadarajan, Bezar, Eric
• Primary Examiner(s): Lee, Wilson
• Assistant Examiner(s): Le, Jessica N
• Application Number:
  US12/727,464
• Publication Number:
  US 20100185593A1
• Time in Patent Office: 1,292 Days
• Field of Search: 707/609, 707/661, 707/758
• US Class Current: 707/609
• CPC Class Codes: G06F 11/1402 Saving, restoring, recovering or retrying
• CPC Class Codes: G06F 16/2379 Updates performed during online database operations; commit processing

Abstract

Methods and systems include embodiments that recursively save parent, grandparent, and other records in a database that depend from a record. User-provided code within a save event or trigger can thus call further save methods without corrupting the database. Junction objects, objects that reflect records with two or more parents, can also be recursively saved.

Claims

1. A method for recursively saving an inserted or updated object that is part of a hierarchy to a database, the method comprising:

receiving a value for a first record in a database;

determining that a parent record of the first record has a field that is dependent on the received value;

recursively determining that a grandparent record of the first record has a field that is dependent on the received value;

loading the first record from the database into a first object;

updating, using a processor operatively coupled to a memory, the first object with the received value;

flushing the updated first object to the first record in the database;

loading the parent record from the database into a second object;

updating the second object based on the received value;

flushing the updated second object to the parent record in the database;

recursively loading the grandparent record from the database into a third object;

recursively updating the third object based on the received value;

recursively flushing the updated third object to the grandparent record in the database;

wherein the method further comprises;

detecting a fault in processing a set of records of the database, wherein at least one of the records includes at least one side effect;

rolling back each of the records processed including the first record and retrying processing on a subset of the set of records in which records associated with faults have been removed until a subset of the set of records in which each record of the subset of records is configured to be processed to the database without fault is determined; and

processing the subset of records to the database and executing the at least one side effect, thereby ensuring that no side effects have occurred from executing code on behalf of any records associated with a fault.

2. The method of claim 1, further comprising:

determining that a second parent record of the first record has a field that is dependent on the received value, such that the first record has at least two parents;

loading the second parent record from the database into a fourth object;

updating the fourth objected based on the received value; and

flushing the updated fourth object to the second parent record in the database.

3. The method of claim 1, further comprising using recursion to recursively load, update, and flush objects corresponding to a great-grandparent record and other records related to the first record.

4. The method of claim 1, further comprising locking the records in the database in the order of:

the grandparent record, the parent record, and then the first record.

5. The method of claim 1, further comprising:

executing user-supplied code for the first object, the executing triggered by the updating of the first object.

6. The method of claim 1, further comprising:

validating the updated first object, updated second object, and updated third object using validation rules.

7. The method of claim 1, further comprising:

executing a workflow on the first object, the workflow including a rule selected from the group consisting of an assignment rule, an auto-response rule, a workflow rule, and a case escalation rule.

8. The method of claim 1, wherein the method is performed with an order of operations, comprising:

performing the receiving;

then performing the determining;

then performing the recursively determining;

then performing the loading the first record;

then performing the updating the first object;

then performing the flushing the updated first object to the first record in the database;

then performing the loading the parent record;

then performing the updating the second object;

then performing the flushing the updated second object to the parent record in the database;

then performing the recursively loading;

then performing the recursively updating; and

then performing the recursively flushing.

9. The method of claim 1, wherein each operation is performed by the computer processor operatively coupled to the memory.

10. A computer system having a processor and a memory therein for executing instructions in a computer program, the computer program instructions comprising program code for performing the operations of claim 1.

11. A non-transitory machine-readable storage medium having instructions stored thereon for recursively saving an inserted or updated object that is part of a hierarchy to a database, that, when executed by one or more processors, the instructions cause the one or more processors to perform operations comprising:

receiving a value for a first record in a database;

determining that a parent record of the first record has a field that is dependent on the received value;

recursively determining that a grandparent record of the first record has a field that is dependent on the received value;

loading the first record from the database into a first object;

updating, using a processor operatively coupled to a memory, the first object with the received value;

flushing the updated first object to the first record in the database;

loading the parent record from the database into a second object;

updating the second object based on the received value;

flushing the updated second object to the parent record in the database;

recursively loading the grandparent record from the database into a third object;

recursively updating the third object based on the received value;

recursively flushing the updated third object to the grandparent record in the database;

wherein the instructions cause the one or more processors to perform operations further comprising;

detecting a fault in processing a set of records of the database, wherein at least one of the records includes at least one side effect;

rolling back each of the records processed including the first record and retrying processing on a subset of the set of records in which records associated with faults have been removed until a subset of the set of records in which each record of the subset of records is configured to be processed to the database without fault is determined; and

processing the subset of records to the database and executing the at least one side effect, thereby ensuring that no side effects have occurred from executing code on behalf of any records associated with a fault.

12. A method for recursively deleting a record that is part of a hierarchy in a database, the method comprising:

receiving an instruction to delete a first record in a database;

determining that a parent record of the first record has a field that is dependent on the first record;

recursively determining that a grandparent record of the first record has a field that is dependent on the first record;

loading the first record from the database into a first object;

deleting the first record in the database;

loading the parent record from the database into a second object;

updating, using a processor operatively coupled to a memory, the second object based upon the deletion of the first record;

flushing the updated second object to the parent record in the database;

recursively loading the grandparent record from the database into a third object;

recursively updating the third object based on the deletion of the first record;

recursively flushing the updated third object to the grandparent record in the database;

wherein the method further comprises;

detecting a fault in processing the deleting of a set of records of the database, wherein at least one of the records includes at least one side effect;

rolling back each deleting of the set of records processed including the first record and retrying processing the deleting on a subset of the set of records in which records associated with faults have their deletion rolled back until a subset of the set of records in which each record of the subset of records is configured to be processed to the database without fault is determined; and

processing the deleting of the subset of records to the database and executing the at least one side effect, thereby ensuring that no side effects have occurred from executing code on behalf of any records associated with a fault.

13. The method of claim 12, further comprising:

determining that a second parent record of the first record has a field that is dependent on the received value, such that the first record has at least two parents;

loading the second parent record from the database into a fourth object;

updating the fourth objected based on the received value; and

flushing the updated fourth object to the second parent record in the database.

14. The method of claim 12, further comprising locking the records in the database in the order of:

the grandparent record, the parent record, and then the first record.

15. The method of claim 12, further comprising:

executing user-supplied code for the first object, the executing triggered by the deleting of the first record in the database.

16. The method of claim 12, further comprising:

validating the updated second object and updated third object using validation rules.

17. The method of claim 12, wherein the method is performed with an order of operations, comprising:

performing the receiving;

then performing the determining;

then performing the recursively determining;

then performing the loading the first record;

then performing the deleting;

then performing the loading the parent record;

then performing the updating the second object based upon the deletion of the first record;

then performing the flushing;

then performing the recursively loading;

then performing the recursively updating; and

then performing the recursively flushing.

18. The method of claim 12, wherein each operation is performed by the computer processor operatively coupled to the memory.

19. A computer system having a processor and a memory therein for executing instructions in a computer program, the computer program instructions comprising program code for performing the operations of claim 12.

20. A non-transitory machine-readable storage medium having instructions stored thereon for recursively deleting a record that is part of a hierarchy in a database that, when executed by one or more processors, the instructions cause the one or more processors to perform operations comprising:

receiving an instruction to delete a first record in a database;

determining that a parent record of the first record has a field that is dependent on the first record;

recursively determining that a grandparent record of the first record has a field that is dependent on the first record;

loading the first record from the database into a first object;

deleting the first record in the database;

loading the parent record from the database into a second object;

updating, using a processor operatively coupled to a memory, the second object based upon the deletion of the first record;

flushing the updated second object to the parent record in the database;

recursively loading the grandparent record from the database into a third object;

recursively updating the third object based on the deletion of the first record;

recursively flushing the updated third object to the grandparent record in the database;

wherein the instructions cause the one or more processors to perform operations further comprising;

detecting a fault in processing the deleting of a set of records of the database, wherein at least one of the records includes at least one side effect;

rolling back each deleting of the set of records processed including the first record and retrying processing the deleting on a subset of the set of records in which records associated with faults have their deletion rolled back until a subset of the set of records in which each record of the subset of records is configured to be processed to the database without fault is determined; and

processing the deleting of the subset of records to the database and executing the at least one side effect, thereby ensuring that no side effects have occurred from executing code on behalf of any records associated with a fault.