State transition logic for a persistent object graph

1. A system that facilitates handling a change associated with a database, comprising at least a processor executing the following components:

an interface that receives data associated with a change to an object graph that is a cached view of the database; and

a state transition logic component that maintains the change related to the object graph utilizing a context and a respective set of rules, wherein a rules component enforces the following set of rules to the object graph: 1) a detached object cannot be related to a non-detached object; and 2) a deleted object cannot be related to a non-deleted object, the context employs metadata to view the object graph with an abstraction of at least one of an entity or a relationship.

2. The system of claim 1 , further comprising at least one of the following: the entity is a real-world object with independent existence and is an instance of the entity type; or the relationship is an instance of the relationship type and expresses a linkage between instances of two or more entity types.

3. The system of claim 2 , further comprising an association relationship that models and implements a peer-to-peer relationship between at least two entities.

4. The system of claim 2 , further comprising a containment relationship that models and implements a parent-child relationship between at least two entities.

5. The system of claim 1 , the object graph utilizes a buffer to tabulate the change, such change is maintained by the context.

6. The system of claim 1 , the change is at least one of flushed to the database or discarded.

7. The system of claim 1 , further comprising the rules component employs at least one of the following operations: 1) add an object; 2) delete object; 3) accept change; or 4) reject change.

8. The system of claim 7 , the operation add an object is implemented to at least one of the following: an object that is detached; an object that is already added; an object that is unchanged/modified; or an object that is deleted.

9. The system of claim 7 , the operation delete object is implemented to at least one of the following: an object that is unchanged/modified; or an object that is in a state of at least one of added, deleted, or detached.

10. The system of claim 7 , further including a transitive add operation that provides a creation of a relationship between a detached object and a non-detached object which transitions the detached object to an added state.

11. The system of claim 7 , further including a child deletion operation that provides a deletion of a relationship in a parent-child relationship will delete the child.

12. The system of claim 7 , further including a re-parenting relationship operation that provides a creation of a new parent-child relationship to a child object which participates in an existing parent-child relationship, the existing parent-child relationship is cauterized based on the creation of the new parent-child relationship.

13. The system of claim 7 , further including a re-adding deleted object operation that provides at least one of an addition of a deleted object to a context, or an addition of a deleted object via a relationship that transitions the object back to an unchanged state.

14. The system of claim 1 , the state transition logic component utilizes an object state transition with the following states: an added state; a detached state; a deleted state, an unchanged state; and a modified state.

15. The system of claim 14 , further comprising the following: an accept between the added state and the unchanged state; at least one of a modify, an accept, or a reject between the unchanged state and the modified state; at least one of a delete and an add between the added state and the detached state; an accept between the detached state and the deleted state; at least one of an add, a reject, and a delete between the unchanged state and the deleted state; or a delete between the deleted state and the modified state.

16. A computer-implemented method that facilitates maintaining a manipulation associated with data, comprising:

receiving data associated with a change to an object graph related to a database, wherein the change to the object graph is executed by a processor; and

maintaining and handling the change to the object graph utilizing a context and respective set of rules, wherein the rules are 1) a detached object cannot be related to a non-detached object; and 2) a deleted object cannot be related to a non-deleted object, the context employs metadata to view the object graph with an abstraction of at least one of an entity or a relationship.

17. The system of claim 16 , further comprising employing at least one of the following operations: 1) add an object; 2) delete object; 3) accept change; 4) reject change.

18. A computer-implemented system that facilitates maintaining a manipulation associated with data, comprising the following components stored in computer memory and executable by a processor:

means for receiving data associated with a change to data in a database via an object graph executed by a processor, the object graph is a cached view of the database; and

means for maintaining the change related to the object graph utilizing a processor, a context and a respective set of rules, wherein the rules are 1) a detached object cannot be related to a non-detached object; and 2) a deleted object cannot be related to a non-deleted object, the context employs metadata to view the object graph with an abstraction of at least one of an entity or a relationship.