U.S. patent application number 12/640656 was filed with the patent office on 2010-06-17 for utilities for deriving values and information from within an interlocking trees data store.
Invention is credited to Jane Van Keuren Claar, Jane Campbell Mazzagatti.
Application Number | 20100153439 12/640656 |
Document ID | / |
Family ID | 41785088 |
Filed Date | 2010-06-17 |
United States Patent
Application |
20100153439 |
Kind Code |
A1 |
Mazzagatti; Jane Campbell ;
et al. |
June 17, 2010 |
Utilities for Deriving Values and Information From Within an
Interlocking Trees Data Store
Abstract
A method for accessing a KStore including at least one K path
having at least one subcomponent node and at least one root node
includes providing a utility routine and accessing the KStore using
the utility routine. The accessing may include traversing the at
least one K path. The at least one K path includes a further node
and bidirectional links between the at least one subcomponent node
and the further node. The method includes traversing between the at
least one subcomponent node and the further node by way of the
bidirectional links. The further node can be a beginning of thought
node, an end of thought node, root node, or a subcomponent node. A
location may be determined within the KStore. The K Store may be
queried. Searches for information within the KStore may be
performed. The KStore may be traversed to constrain and focus the
KStore. The KStore may be updated.
Inventors: |
Mazzagatti; Jane Campbell;
(Blue Bell, PA) ; Claar; Jane Van Keuren;
(Bethlehem, PA) |
Correspondence
Address: |
Unisys Corporation
Unisys Way, MS/E8-114
Blue Bell
PA
19424-0001
US
|
Family ID: |
41785088 |
Appl. No.: |
12/640656 |
Filed: |
December 17, 2009 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
11258293 |
Oct 24, 2005 |
7676477 |
|
|
12640656 |
|
|
|
|
60625922 |
Nov 8, 2004 |
|
|
|
Current U.S.
Class: |
707/769 ;
707/705; 707/797; 707/E17.012; 707/E17.014 |
Current CPC
Class: |
G06F 16/00 20190101 |
Class at
Publication: |
707/769 ;
707/797; 707/E17.012; 707/E17.014; 707/705 |
International
Class: |
G06F 17/30 20060101
G06F017/30 |
Claims
1-25. (canceled)
26. A computer-readable data product containing encoded data that
when read represents programmable instruction that when executed
within a computing system implements a method for accessing a
KStore including at least one K path having at least one
subcomponent node and at least one root node, the method
comprising: (a) providing a utility routine; and (b) accessing said
KStore using said utility routine, said KStore comprising an
interlocking trees datastore structure comprising elemental root
nodes, subcomponent nodes and end product nodes using asCase and
asResult bidirectional links between the elemental root nodes,
subcomponent nodes and end product nodes for determining paths
within the interlocking trees datastore structure, said
interlocking trees datastore comprising a first tree depending from
a first root node and including at least one of a plurality of
branches, wherein each of the plurality of branches ends in an end
product node comprising a leaf node, said interlocking trees
datastore further comprising a second root of a second tree linked
to each end product node, said interlocking trees datastore further
comprising at least a third tree, wherein a root of the third tree
comprises an elemental node representing a particle, the root of
the third tree linked to at least one node in at least one branch
of the first tree; and wherein a first Case node, said first Case
node referencing a node in a Case path; a first Result node, said
first Result node referencing a node in a Result path; and a first
subcomponent node wherein said first subcomponent node (i)
represents a logical relationship between said first Case node and
said first Result node in accordance with said data and (ii) is
adapted to serve as a second Case node; asCase link represents a
link to the first of the two nodes from which a node is created;
and asResult link represents a link to the second of the two nodes
from which a node is created.
27. The computer-readable data product for accessing a KStore of
claim 26, wherein said accessing further comprises traversing said
at least one K path.
28. The computer-readable data product for accessing a KStore of
claim 27, wherein said at least one K path includes a further node
and bidirectional links between said at least one subcomponent node
and said further node further comprising traversing between said at
least one subcomponent node and said further node by way of said
bidirectional links.
29. The computer-readable data product for accessing a KStore of
claim 28, wherein said further node comprises a beginning of
thought node, said beginning of thought node comprising a last node
of the at least one K path traversed in a direction beginning with
an end product node or a first node of the at least one K path
traversed in a direction beginning with the beginning of thought
node.
30. The computer-readable data product for accessing a KStore of
claim 28, wherein said further node comprises an end of thought
node, said end of thought node representing a complete particle
sequence.
31. The computer-readable data product for accessing a KStore of
claim 28, wherein said further node comprises a subcomponent node,
said subcomponent node referencing a particle of a particle
sequence.
32. The computer-readable data product for accessing a KStore of
claim 26, wherein said further node comprises a root node, said
root node referencing a particle value.
33. The computer-readable data product for accessing a KStore of
claim 26, further comprising determining a location within said
KStore.
34. The computer-readable data product for accessing a KStore of
claim 26, further comprising querying said KStore.
35. The computer-readable data product for accessing a KStore of
claim 34, further comprising searching for information within said
KStore.
36. The method for accessing a KStore of claim 34, further
comprising determining information about said KStore.
37. The computer-readable data product for accessing a KStore of
claim 35, further comprising searching in accordance with a
mask.
38. The computer-readable data product for accessing a KStore of
claim 34, further comprising traversing said KStore to constrain
said KStore.
39. The computer-readable data product for accessing a KStore of
claim 26, wherein said utility routine retrieves a particle value
from the at least one root node of the at least one K path, the at
least one root node comprising an elemental root node.
40. The computer-readable data product for accessing a KStore of
claim 26, wherein said utility routine returns a value for the at
least one K path or for sets of nodes on a level of the KStore by
traversing a structure of the KStore and returning particle
sequences associated with the traversed structure.
41. The computer-readable data product for accessing a KStore of
claim 26, further comprising updating said KStore.
42. A computer-readable data product containing encoded data that
when read represents programmable instruction that when executed
within a computing system implements a method for transmitting
information in a KStore wherein said KStore is operably coupled to
an application layer further comprising preventing internal KStore
information from being transmitted from said KStore to said
application layer, said KStore including at least one K path having
at least one subcomponent node and at least one root node, said
method comprising: (a) providing a utility routine; and (b)
accessing said KStore using said utility routine, said KStore
comprising an interlocking trees datastore structure comprising
elemental root nodes, subcomponent nodes and end product nodes
using asCase and asResult bidirectional links between the elemental
root nodes, subcomponent nodes and end product nodes for
determining paths within the interlocking trees datastore
structure, said interlocking trees datastore comprising a first
tree depending from a first root node and including at least one of
a plurality of branches, wherein each of the plurality of branches
ends in an end product node comprising a leaf node, said
interlocking trees datastore further comprising a second root of a
second tree linked to each end product node, said interlocking
trees datastore further comprising at least a third tree, wherein a
root of the third tree comprises an elemental node representing a
particle, the root of the third tree linked to at least one node in
at least one branch of the first tree; and wherein a first Case
node, said first Case node referencing a node in a Case path; a
first Result node, said first Result node referencing a node in a
Result path; and a first subcomponent node wherein said first
subcomponent node (i) represents a logical relationship between
said first Case node and said first Result node in accordance with
said data and (ii) is adapted to serve as a second Case node; an
asCase link represents a link to the first of the two nodes from
which a node is created; and an asResult link represents a link to
the second of the two nodes from which a node is created.
Description
BACKGROUND OF THE INVENTION
[0001] 1. Field of Invention
[0002] This invention relates to computing and in particular to the
field of data structures such as interlocking trees datastores.
[0003] 2. Description of Related Art
[0004] Practically, in the field of computer programming, utilities
are programs that perform very specific tasks, usually related to
managing system resources, but may perform other practical
functions as well. Within the realm of traditional relational
databases, utilities used to query tables within databases in order
to retrieve, update, or track data are fairly common in the art.
For example, U.S. Pat. No. 6,643,649, entitled "Utility for cross
platform database query" teaches a utility for cross platform
database query, where the utility resides at an object server in a
data system. The utility obtains a set of data items from a library
server in the data system; places the set of data items from the
library server in a temporary table at the object server; obtains
each data item from the temporary table and the base object table;
and converts each data item from the temporary table and the base
object table, if a conversion is required, such that each data item
from the temporary table and the base object table may be
compared.
[0005] Specifically, in terms of retrieving data from within a
database, U.S. Pat. No. 5,129,082, entitled "Method and apparatus
for searching database component files to retrieve information from
modified files" teaches a method where each database component file
contains information regarding the text contained in the source
file which enables the user to quickly determine the frequency of
occurrence of the specified text and the location of the specified
text in the source fife.
[0006] Updating data in traditional relational databases is
addressed in U.S. Pat. No. 6,564,215, entitled "Update support in
database content management." This patent teaches a method for
updating data objects that are maintained in data storage external
to a database management system (DBMS). Also, U.S. Pat. No.
4,648,036, entitled "Method for controlling query and update
processing in a database system" teaches a method of performing
update transactions in a database system to preserve consistent
logical data states at all times.
[0007] Determining locations within databases is another function
of utilities. For example, U.S. Pat. No. 6,697,797, entitled,
"Method and apparatus for tracking data in a database, employing
last-known location registers" teaches a data tracking scheme that
employs a "last-known location" register as a part of a data
block's ID.
[0008] While producing satisfactory results in traditional
relational databases, the methods cited above do not apply to
KStore technology.
[0009] All references cited herein are incorporated herein by
reference in their entireties.
BRIEF SUMMARY OF THE INVENTION
[0010] A method for accessing or updating a KStore including at
least one K path having at least one subcomponent node and at least
one root node includes providing at least one utility routine and
accessing the KStore using the at least one utility routine. The
accessing may include traversing the at least one K path. The at
least one K path includes a further node and bidirectional links
between the at least one node and the further node. The method
includes traversing between the at least one node and the further
node by way of the bidirectional links. The further node can be a
beginning of thought node, an end of thought node, root node or a
subcomponent node. A location may be determined within the KStore.
The K Store is queried. Searches for information within the KStore
may be performed. The KStore may be traversed to constrain and
focus the KStore. The K Store may be updated.
[0011] The KStore technology addresses the problems associated with
traditional relational databases. As described in copending U.S.
patent application Ser. No. 10/385,421, filed Mar. 3, 2003 and
entitled "System and method for storing and accessing data in an
interlocking trees datastore" (now published as US 20040181547 A1)
and copending Ser. No. 10/666,382, filed Sep. 19, 2003 and entitled
"System and method for storing and accessing data in an
interlocking trees datastore" (now published as US 20050076011 A1)
both by Mazzagatti the KStore structure eliminates the distinction
between transactional data and stored (relational) data.
[0012] With the development of the KStore technology, there is a
need for utilities to access the unique interlocking trees
datastore and provide information from within the K to other
internal procedures for use in handling requests from external
applications, data sources, and GUIs.
[0013] We have developed a system and various methods for creating
and accessing interlocking trees datastores and various features of
said interlocking trees datastores. We refer to an instantiation of
these interlocking trees datastores that we have developed as a
"KStore" or just "K". In particular, these structures and methods
have been described in U.S. patent application Ser. Nos.
10/385,421, and 10/666,382. Additionally, we described a system in
which such interlocking trees datastores could more effectively be
used in U.S. Ser. No. 10/879,329 filed on Jun. 29, 2005 and
entitled "Functional operations for accessing and/or building
interlocking trees datastores to enable their use with applications
software." While the system and method we describe in this patent
relate with particularity to the specific interlocking trees
datastores which inventor Mazzagatti hereof described in the
above-referenced patent (applications), it should be readily
apparent that the system and methods described herein may also be
applicable to similar structures.
[0014] The invention described herein below relates to interlocking
trees datastores, a structure described in prior patent
applications and can be readily used by and adapted to devices
described in patent applications U.S. patent application Ser. No.
10/759,466 filed on Jun. 16, 2004 and entitled "Saving and
restoring an interlocking trees datastore" (now published as US
20050165749 A1) which is for use with such interlocking trees
datastores.
[0015] As explained in the above mentioned patents, a KStore
structure can be built within the memory of a computer system or
computer systems. Depending on the amount of data loaded into K,
the KStore structure and the amount of computer memory used can be
quite large. As well, the more nodes there are in the data
structure, the more nodes will be searched during a query of the
data. The more nodes searched, the more time it takes to provide an
answer to the query.sub.[A1].
[0016] The invention described herein overcomes the inherent
limitations associated with the prior art by providing a series of
KStore utilities, which are a group of programming routines or
procedures (or potentially hardware or some other as yet
unidentified medium), that are called and used repeatedly within
KStore to access, update, traverse, and search the structure,
resulting in the return of information from the structure to other
routines for processing if required .sub.[A2].
BRIEF DESCRIPTION OF SEVERAL VIEWS OF THE DRAWINGS
[0017] The invention will be described in conjunction with the
following drawings in which like reference numerals designate like
elements and wherein:
[0018] FIG. 1 shows a block diagram representation illustrating the
interaction of the main components used in preferred embodiments of
this invention.
[0019] FIG. 2 shows a graphical representation of interlocking
trees datastore.
[0020] FIG. 3 shows a flowchart of the logic of a procedure
reconstructing a set of particle data.
[0021] FIG. 4 is an exemplary node within K containing a count as
an additional field.
[0022] FIG. 5. shows a graphical representation of interlocking
trees datastore with nodes constructed from fictional furniture
store data used to illustrate other procedures to determine K
locations.
DETAILED DESCRIPTION OF THE INVENTION
[0023] As taught in U.S. patent application Ser. No. 10/879,329, we
have integrated KStore components into a system that is facile at
handling data for nearly any desired use. While the above mentioned
patent taught how the components of the KStore system integrate, in
order to understand the topic of this current invention, a brief
summary of the KStore system is presented below.
[0024] In a preferred embodiment, data coming into KStore can be
learned, formed into an interlocking tree structure (K), and read
into computer memory. Refer to FIG. 1. FIG. 1 shows a block diagram
representation illustrating the interaction of the main components
that can be used in preferred embodiments of this invention.
Generally, the KStore interlocking trees datastore 14a can be built
into a relatively fixed structure within the memory of a computer
system or computer systems, although a memory of a computer system
is not necessary. The K can be built using a resource called a K
Engine 11a, which has a set of rules it applies to data that can be
particlized for it and sent to it, in order to support the K Engine
11a task of recording the particlized data as events in the KStore.
The KStore 14a itself can be accessed to answer queries about the
data, preferably using resources such as the API Utility 5 either
directly or by way of the Utility 4. The API utility 5 can be
accessed by a user by way of the GUI 12 and the applications 7. A
user can also use the GUI 13 and the data source applications 8 in
order to use the learn engine 6 with the KEngine 11a and the K 14a
directly or by way of the Utility 4. These procedures are described
in more detail in the above referenced patents.
[0025] Additionally, the KEngine 11a can provide output according
to the information received from the KStore 14a. The output can be
displayed on a graphical display device (not shown). Furthermore,
input can be received and information can be determined by the.
KEngine 11a simultaneously with the building or testing of the
KStore 14a. For example the KStore 14a can be built from a data
source 8. Any number of threads can be streamed simultaneously from
the data source 8 to the KStore 14a by way of a learn engine 6
within the KStore system 10. Additionally, the data source 8 can be
another KStore 14a, a data repository storing data records from a
dataset or another KStore or any other source of record sets
suitable for storage in the KStore 14a. In a preferred embodiment
of the invention input from the application program
interface/utility 5 and the learn engine 6 can be received by the
utility 4. The utility 4 can include any routines useful for
performing tasks within the KStore 14a such as routines for
receiving particles and traversing the interlocking trees datastore
within the KStore 14a.
[0026] In addition to the set of routines to access the KStore
structure and return information for processing taught in U.S.
patent Ser. No. 10/666,382 many other utility routines that derive
values and other information from within an interlocking trees
datastore can be developed and programmed by those skilled in the
art. "Application programming interface to KStore interlocking
trees datastore" which is owned by the Assignee of the instant
application teaches the application programming interface (API)
which includes the API Utility 5 and the Learn Engine 6. API 5
enables user programmers to develop and execute multiple
application programs without having to understand the processes
required to traverse and return address locations within a KStore
interlocking trees datastore. The present invention includes the
utility routines 4 that are not visible to end users. The present
invention also includes utilities that are located anywhere in the
KStore system 10 whether they are visible to end users or not, if
they are used to access and derive K values or information from the
KStore structure or perform other tasks upon the information in the
KStore 14a. In a preferred embodiment, however, utilities that are
visible to end users never permit node locations or addresses or K
location pointers out of level 16. The utility tasks of the present
invention can include, for example, querying, accessing,
traversing, searching or other tasks required for managing KStore
resources.
[0027] In the field of computer programming, a "utility" is a
program that performs a specific task, for example, a task related
to managing system resources. Operating systems contain a number of
utilities for managing disk drives, printers, and other devices.
Utilities differ from applications mostly in terms of size,
complexity and function. For example, word processors, spreadsheet
programs, and database applications are considered applications
because they are large programs that perform a variety of functions
not directly related to managing computer resources. In the current
embodiment, KStore utilities are a group of programming routines or
procedures (or potentially hardware or some other as yet
unidentified medium) that are called and used repeatedly when the
KStore structure is accessed, updated, traversed and searched,
resulting in the return of information from the structure to other
routines for processing if required. We have chosen to
differentiate between those utilities visible to end users, such as
API utilities, and those not visible to the end user, such as the
utilities described within this patent.
[0028] In the current embodiment we identify sets of utilities that
perform different functions. It should be noted that these do not
make Up the complete set of potential utilities that will be
integrated within KStore. Those skilled in the art will recognize
that many other utilities can be programmed and integrated into the
space identified in KStore system 10 as Utility 4.
Utility Sets
[0029] As mentioned above, within the current embodiment there are
sets (groups) of utilities. The main function that ties all of
these utilities together is that they can all work to access a
KStore datastore, in order to derive values and information from
within the structure, and return information to other routines. The
following are examples of utilities:
[0030] Retrieve information from K
[0031] Update K structure
[0032] Determine K locations
[0033] Each of these groups contains one or more utilities that
function to perform a specific task. In the following discussion,
we will define what each group of utilities does.
Retrieve Information from K
[0034] The utilities in this group retrieve information from a K
structure. This may be accomplished by traversing a KStore
structure, finding values or returning information to other system
components and applications which may in turn supply the
information to users. The utilities within this group can be
further subdivided into at least the following sub-groupings
according to the functions they accomplish: retrieve particle
values and retrieve structure information.
[0035] The retrieve particle values sub group contains procedures
to obtain values or particle sequences from within a KStore
interlocking trees datastore. These procedures may retrieve
particle values from single nodes. In the preferred embodiment,
these single nodes are the elemental root nodes of a K
structure.
[0036] There are also procedures within this sub group that may
return values for entire paths or from between sets of nodes on any
level of a K by traversing the structure and returning the
associated particle sequences. The structure may be traversed in
any manner that is convenient to obtain the particle values.
[0037] An example of a procedure in this sub group is one that
reconstructs a set of particle data that was previously inputted
into K and learned. For example, this procedure can obtain the
value or particle sequence for end product node 252. Refer to FIG.
2. From end product node 252 the procedure can traverse the Case
path toward the BOT node 270 to subcomponent node 228. The
traversal can be performed by following the pointers of the
bi-directional links between the nodes. The procedure can then
obtain the particle value "S" from the elemental root node "S" 272
through the Result path connection of the subcomponent node 228.
The particle value, which in this case is "S", can be written to a
string buffer in memory.
[0038] Next the procedure can proceed toward the next node along
the path to subcomponent node 236. As with the subcomponent node
228, the procedure can determine the particle value of the
elemental root node associated through the Result path of the
subcomponent node 236. In this case the particle value is "T" from
the elemental node 276. The procedure can write this value to a
string buffer in memory as it did with the first node. This process
can be continued at each node in the path between the end product
node 252 and the BOT node 270, writing each value to the string
buffer. In this way, input can be reconstructed by traversing the
Case path, finding all of the values or particles of data for the
path, and writing them to string buffer memory. The particle
sequence or values in the string buffer can then be presented to
the user, used in a calculation, or any other process or procedure
commonly used in computer operations.
[0039] The logic of this procedure is shown in FIG. 3. An end
product node such as the end product node 252 is found as shown in
block 280. The procedure can traverse the Case path from the
located end product node to reconstruct the particle values as
shown in block 282. If a node located during the traversal is not
the BOT node as determined in decision 284, the value can be added
to the string buffer as shown in block 286. If the node is the BOT
node the procedure ends.
[0040] This procedure can be used to reconstruct multiple input
sequences by starting at a higher level in K and traversing from
higher to lower end product nodes using the Result bidirectional
pointers. For example, to reconstruct a multiple input sequence in
the KStore of FIG. 2 a traversal from the end product node 260
toward the BOT node 270 can be performed. The subcomponent nodes
258, 256 and 254 can be traversed to reconstruct the particle
sequence "CATS ARE FURRY." The procedure traverses from the
subcomponent nodes 258, 256 and 254 to the end product nodes 240,
230 and 252, respectively. The process can be continued from each
end product node 240, 230 and 252 toward the BOT node 270 until all
values or particle sequences are reconstructed. It should be noted
that because the nodes are traversed from the end product node
toward the BOT node 270, letters or words are written to the string
buffer in reverse order.
[0041] Note that particle values may be any digitized data.
Digitized data may be returned as sound, pixels, or other like
values.
[0042] The retrieve structure information sub group can find and
return specific information about the interlocking trees structure.
This may include but is not limited to, the number of nodes in a
specific asCase list or asResult list, the location of nodes in
relation to other nodes or information from additional fields that
may be contained within the nodes. One of the procedures can return
the value in the count field of each root node for the field values
associated with a specific column within a K. For example, assume
that for the field "salesperson" in an exemplary data set, there
are two values "Bill" and "Tom." The procedure can determine the
count or the number of times each of these values has been recorded
within the structure.
Update the Structure
[0043] The utilities in this group can update individual nodes
(which may include fields, information, or counts) or sets of nodes
in a K structure. The utilities within this group are subdivided,
in the current embodiment, into at least the following
sub-groupings according to the functions they accomplish: updating
K by adding, removing, and modifying nodes and update fields within
nodes.
Update K
[0044] The update K sub group can provide a method to add, change,
remove, or rearrange nodes within an existing structure. Another
example procedure in this sub group adds new nodes to the end of a
path. A preferred method to update K is taught in "Updating
information in an interlocking trees datastore" which is owned by
the Assignee of the instant application.
Update Fields within Nodes
[0045] Fields can be changed in any way, for example by changing
the values of fields, changing Case, Result, asCase, and asResult
pointers. As well, additional fields within nodes can be updated
and changed.
[0046] To understand some of the importance of updating fields
within nodes, one must understand that all nodes of an interlocking
trees data store may also include additional fields representing
information associated with said nodes. As taught in U.S. patent
application Ser. No. 10/666,382, the nodes within an interlocking
trees datastore may have additional fields. This may be illustrated
using FIG. 4. The subcomponent and elemental root node fields are
shown as fields in a block of fields for teaching purposes. An
exemplary node 20 is shown in FIG. 4. A node may contain a value 23
(elemental root node) or a count field 22. The count field 22 may
be initialized and incremented with an intensity variable, whose
value can vary with conditions at times when the count field is
being referenced. A simple example form of an intensity variable
would be a single ordinal field value, such as `1` to be used to
increment or decrement count fields to record the number of times
that a node has been accessed or traversed. In the current
embodiment, there are procedures to update and modify the numeric
count within count fields 22. There can be many uses for additional
fields and the nodes such as node 20 need not be limited to one
additional field 23.
[0047] There are other procedures to update information in
individual nodes and others to update fields in a node. For
example, there are procedures to lock a node by setting a value in
a lock field that can be provided within a node, and procedures to
reorganize lists pointed to by pointers from within a node. A
preferred method for locking a node is taught in "Method for
reducing the scope of the lock" which is owned by the Assignee of
the instant application.
[0048] Those with knowledge of the KStore interlocking trees
datastore structure will recognize that there are many potential
reasons to update and modify fields in nodes. One example is taught
in "Updating information in an interlocking trees datastore" which
is owned by the Assignee of the instant application.
Determine K Locations
[0049] This group of utilities can traverse and determine locations
in a KStore known as K location pointers. Location pointers are
discussed in U.S. patent Ser. No. 11/100,830, and entitled
"Facilitated reuse of k locations in a knowledge store."
[0050] The utilities within this group can be further subdivided
according to the functions they accomplish into at least the
following sub groupings: determine K locations from particle
sequences and determine K locations from other nodes.
Determine K Locations from Particle Sequences
[0051] These utilities use particlized data and call the KEngine
which returns locations in K. Routines in this sub-group are used
in different ways to find nodes associated with a given particle
sequence. One example utility is called masking to permit locating
structure within a KStore.
[0052] The masking utility may be used to determine a set of K
paths in a KStore that satisfies an input sequence including a
plurality of particles. This method can include receiving the input
sequence by the KStore, processing the input sequence by the KStore
and determining the set of K paths in accordance with the input
sequence. The method can also include determining whether a
selected particle of the plurality of particles is a mask. If the
selected particle is a mask a mask type is determined and an
initial set of K paths is determined in accordance with the mask
type. Masking is taught in U.S. Ser. No. 11/132,490 entitled
"Variable masking" and filed on May 18, 2005.
Determine K Locations from Other Nodes
[0053] Given a node, these routines can find other nodes based on
certain criteria.
[0054] For example, one exemplary routine can search through a
node's asCase list for a node with a specific Result pointer.
[0055] Another routine finds associated root or end product nodes
at various levels in an interlocking trees structure which are
associated with another node or set of nodes. Assume we have a root
node for a field. We may then determine all record paths by end
product nodes that contain pointers to that field.
[0056] Constraining utility groups determine K locations from
particle sequences and determine K locations from other nodes.
First, the node associated with the particle sequence for the
constraint can be found. Then, using that root node, all paths or
record end product nodes associated with the constraint root node
may be found. For example, this routine could obtain the pointer
location for the node for the variable "Sold." Using this node the
list of all end product node paths that contain the variable "Sold"
can be located in the asResult list as shown in FIG. 5 as the
dotted lines leading from "Sold" node 600. The resulting list of
end product nodes 620, 640, and 660 of each record that contains
"Sold" may then be used to sum a sales value column to obtain a
total sales value. Additionally, the set of "Sold" record end
product nodes can be further reduced to the set of "Sold" end
product nodes for a particular product "Sofa" by traversing the
paths of each end product node and eliminating the paths that do
not contain "Sofa."
* * * * *