Saving and restoring an interlocking trees datastore

Abstract

A tree-based datastore comprising a forest of interconnected trees that can be generated and/or accessed may require specialized saving and restoring processes to ensure that all the links are properly maintained whether it will be restored in full or in part. A previous process acted on known features of the trees based datastore to generate a file of metadata and packetize each of the nodes of the structure, carefully saving the links and lists of links with old memory addresses accounted for. This shows how to build a save file without saving all links, using a new restore process to restore the links instead.

1 . A method of saving an interlocking trees data store from a memory wherein said interlocking trees datastore has a least one BOT node, at least on subcomponent node and at least a plurality of root nodes, wherein said BOT nodes have a list of asCase pointers to subcomponent nodes, wherein said subcomponent nodes have a list of asCase pointers to other subcomponent nodes and wherein said root nodes have a list of asResult pointers to subcomponent nodes that depend from said BOT node, wherein said method comprises: 
 traversing the interlocking trees data store to access each node,    creating a node packet for each node wherein said node packet creation process includes at least capturing a case pointer and a result pointer for each node, but not capturing pointers from said asCase list and not capturing pointers from said asResult list, and writing the node packet to another memory.    
     
     
         2 . The method of  claim 1  wherein said writing from one memory to another memory is accomplished using a main memory as said one memory.  
     
     
         3 . The method of  claim 1  wherein said writing is to at least one of the following types of memories including, a type that is relatively permanent and retrievable by a computer, a memory local to the machine housing said one memory, a distant memory in a system accessible through a network, a partition memory in a partitioned machine, another part of said one memory.  
     
     
         4 . The method of  claim 1  further comprising the step of restoring said node packet to an active memory.  
     
     
         5 . The method of  claim 1  wherein at least some of said nodes' packets are saved in a larger packet, and wherein when said larger packet in written to another memory, said larger packet is written with metadata about said nodes.  
     
     
         6 . The method of  claim 1  wherein said creating a node packet process further comprises capturing a count of the pointers in the asCase pointer lists and asResult pointer lists from any nodes which have them.  
     
     
         7 . The method of  claim 6  wherein said capturing comprises counting the pointers on the lists to determine a count.  
     
     
         8 . The method of  claim 1  further comprising; 
 selecting a node packet type into which information from said nodes will be stored in said creating a node packet process.    
     
     
         9 . The method of  claim 8  wherein said selecting process provides up to three types of node packets to select from, said three types comprising a second type which has no information regarding asCase pointer lists nor information regarding asResult pointer lists, a first type which has a field to retain a count of pointers in an asCase pointer list and a field to retain a count of pointers in an asResult pointer list, and a third type which has a field to retain a count of either pointers in an asCase pointer list or pointers in an asResult pointer list, but not both.  
     
     
         10 . The method of  claim 9  wherein said third type of node packets stores said retained pointer list count in a field called Pointer List Count.  
     
     
         11 . The method of  claim 9  wherein a least one type for selection is a node packet which has no information regarding asCase pointer lists nor information regarding asResult pointer lists.  
     
     
         12 . The method of  claim 9  wherein at least one type for selection is a packet which has a field to retain a count of pointers in an asCase pointer list and a field to retain a count of pointers in an asResult pointer list.  
     
     
         13 . The method of  claim 9  wherein at least one type for selection is a packet which has a field to retain a count of either pointers in an asCase pointer list or a field to retain a count of pointers in an asResult pointer list, but not both values.  
     
     
         14 . The method of  claim 1  further comprising saving support structures.  
     
     
         15 . The method of  claim 14  wherein said saving of said support structures is done in two steps, a first step saves any support structures that can be restored before an address translation table is built during a restore process, and a second step saves any supporting structures that can be used after all remaining node packets are restored, and the address translation table is completed.  
     
     
         16 . The method of  claim 14  wherein said supporting structures which are also saved, include at least one of the following support structures: 
 a file header containing a file type and creation date,    a file ID,    a list of values for elemental roots nodes or their addresses which point to their values,    a list of strings representing the end product nodes of interlocking trees datastore,    metadata describing data structures of the underlying OS or computer system in which it resides,    password protection for the file itself    a code identifying how lists of pointers are ordered in the nodes,    information of that nature that may be needed to restore the structure in a particular environment,    information of a nature to enable determination of the addresses of information in the structure which is being saved,    version and cycle of Save program that created the save file,    OS underlying structure information including at least size of fields used information,    elemental root nodes values or pointers to their values and any associated delimiters,    metadata including field types such as a user defined types, column descriptions and permissions,    Kstore variables including switches, data stream, node structure,    data sources including types locations and affiliated data streams' ID information,    security features including administrative passwords, permissions, saved query locations and triggers, and    XML related meta data.    
     
     
         17 . The method of  claim 1  wherein at least the following information is saved for each node packet in said create a node packet process, 
 result pointer,    case pointer,    any additional field data,    old memory address, and    any count field data.    
     
     
         18 . The method of  claim 17  wherein a value related to packet size is also saved in said node packet in said create a node packet process.  
     
     
         19 . The method of  claim 14  wherein said writing supports structures process saves said supporting structures into a header file for the saved interlocking trees datastore data file created by said method.  
     
     
         20 . The method of  claim 17  wherein said node packets are saved into a large packet containing a set of said nodes packets.  
     
     
         21 . The method of  claim 20  wherein each of the node packets in said set of node packets being saved into said larger packet share at least one characteristic and wherein an indication of said characteristic is stored into a header area of said large packet.  
     
     
         22 . The method of  claim 21  further including saving a plurality of large packets, each having a set of node packets differing in at least one characteristic from the node packets of other large packets.  
     
     
         23 . The method of  claim 1  wherein said saving of an interlocking trees data store from memory of another memory further comprises the step of: saving supporting structures to said another memory.  
     
     
         24 . A machine readable signal medium containing a data file having a set of node packets created in the process of  claim 1 .  
     
     
         25 . The machine readable signal medium set forth in  claim 24  wherein said medium is a magnetic disk.  
     
     
         26 . A machine readable data medium including therein a set of instructions which when loaded into a computer and allowed to execute, cause said computer to execute the method of  claim 1 .  
     
     
         27 . (canceled)  
     
     
         28 . (canceled)  
     
     
         29 . (canceled)  
     
     
         30 . (canceled)  
     
     
         31 . (canceled)  
     
     
         32 . (canceled)  
     
     
         33 . (canceled)  
     
     
         34 . (canceled)  
     
     
         35 . (canceled)  
     
     
         36 . (canceled)  
     
     
         37 . (canceled)  
     
     
         38 . (canceled)  
     
     
         39 . A method of saving an interlocking trees data store from a memory wherein said interlocking trees datastore has at least one BOT node, at least one subcomponent node and at least a plurality of root nodes, wherein said BOT nodes have a list of asCase pointers to subcomponent nodes, wherein said subcomponent nodes have a list of asCase pointers to other subcomponent nodes and wherein said root nodes have a list of asResult pointers to subcomponent nodes that depend from said BOT node, wherein said method comprises: 
 traversing the interlocking trees data store to access each node,    creating a node packet for each node wherein said node packet creation process includes at least capturing a case pointer and a result pointer for each node, but not capturing pointers from said asCase list and not capturing pointers from said asResult list, and    writing the node packet to said memory.    
     
     
         40 . The method of  claim 13  wherein an additional field is added to the node packet to differentiate the type of pointer list represented by the count in the Pointer List Count.