Objects can be selected by querying the defined property using the selection criteria “d”. All objects that are defined (i.e., described in the Object Dictionary) are selected. For example, in the following command, all the defined objects are selected for use by the ZOMLIST service:
ZOMList +p d
In the next example, all objects that are not defined are selected:
ZOMList +p d!
Objects can be selected by querying the compilestatus property using the selection criteria “ca”. All compiled objects (i.e. document objects that have been compiled) are selected. For example, in the following command, all compiled objects are selected for use by the ZOMLIST service:
ZOMList +p ca
In the next example, only those compiled objects that encountered errors during their most recent compilation are selected:
ZOMList +p ce
The ” e” here implies Errors.
Objects can be selected by querying the compilestatus property to determine if the object needs to be recompiled. All document objects that are considered to be in need of recompilation (e.g., program source is more recent than compiled program, object definitions have changed, and so on) are selected. For example, in the following command, all objects in need of recompilation are selected for use by the ZOMLIST service:
ZOMList +p cn
The ” n” here implies that the objects need recompiling.
All ZOM services use a common mechanism for selecting objects on which to operate. This mechanism consists of a series of one or more selection items that specify a set of objects to be processed by the service. This section provides an overview of object selection using a number of examples. Following sections contain detailed descriptions of all selection options that are possible.
Note: Keywording is described in Keywording Objects.
The following example contains a single selection criteria that indicates all objects of type EntitySet:
ZOMList +t Ent
The +t indicates selection by Type and Ent indicates only objects of type EntitySet are to be considered. In English, this example would literally read:
List the set of objects of type EntitySet.
The t in +t is the selection criteria; t meaning type. There are several different criteria you can use to select objects. In specifying the objects to process, each selection criteria you use must be prefixed with a set operator which is one of
| + | plus sign, indicating a set union operation |
| – | minus sign, indicating a set minus operation |
| ^ | caret, indicating a set intersection operation |
The first selection item establishes an initial set of objects and this set is further refined by any subsequent selections. The first selection item should always use a union operation (+) to establish an initial object set with which to work. This can seem overly mathematical, but the model of taking sets and operating on them becomes very useful as more complex selections are made.
For example, if you wanted to list the objects that are EntitySets as well as the objects that are Relationships, enter
ZOMList +t Ent +t Rel
This example selects the set of objects of type EntitySet and unions this set with the set of objects of type Relationship, then lists the objects in the resulting set.
Because both selections in the preceding example are by the same criteria (i.e., Type), you can express the selection in a simpler way:
ZOMList +t Ent, Rel
Here you have combined the two selection items “+t Ent” and “+t Rel” into a single selection by separating the two arguments by a comma (‘,’).
Continuing with this example, if there was an object named “Customers” which you want to exclude from the listing, enter
ZOMList +t Ent, Rel -n Customers
The minus (-) operator causes the set operation “minus” to be applied. The selection criteria “n” means “name”. The result of “-n Customers” is to remove objects with the name “Customers” from the set of objects selected so far. Since selection items are processed left to right, this example selects all objects of type EntitySet or Relationship, and then removes all objects named “Customers” from this set.
Alternately, you could select only those EntitySet or Relationship objects which also have been assigned the keyword “Sales_System”:
ZOMList +t Ent, Rel ^k Sales_System
The caret (^) operator causes the set operation “intersection” to be applied. The selection criteria k means keyword. The result of “^k Sales_System” is to select only objects that have been assigned (by the user) the keyword “Sales_System” from the set of objects selected so far. Since selection items are processed left to right, this example selects all objects of type EntitySet or Relationship, and then selects all objects keyworded by “Sales_System” from this set.
Complex selections often cannot be done in a single ZOM command. If this occurs, use ZOM’s keywording capability to first identify the objects on which to operate and then invoke the desired service using the keywords to select the desired objects. The next example uses keywording (and other techniques that have not been introduced yet) to select a particular set of objects. Although you might not be familiar with the specific syntax, this example gives you a flavor of how ZOM can handle arbitrarily complex object selections.
ZOMSet +n Cust* +itp ;k Used_By_Cust
ZOMSet +n Inv* +itp ;k Used_By_Inv
ZOMList +k Used_By_Cust ^k Used_By_Inv
This example has the effect of listing all objects that are used by objects whose names begin with “Cust” and are used by objects whose names begin with “Inv.” (The first ZOMSet command assigns the keyword “Used_By_Cust” to all objects used by objects whose names begin with “Cust”. The second ZOMSet command assigns the keyword “Used_By_Inv” to all objects used by objects whose names begin with “Inv”. The ZOMSet service and the selection criteria and processing options used here are all explained in the following subsections.)
The power of the various selection criteria becomes much more potent in the context of these composite selections. However, there is a danger in this power. With ZOM, you can very easily select large numbers of objects for a ZOM service to process. Therefore, you should be very careful that only the desired objects are selected.
Until you become familiar with the use of these selection criteria, it is recommended you preview your selections by using the ZOMList service before using any ZOM service that performs update operations on the object involved.
The subsections below describe each of the various selection criteria available for selecting objects to be processed by a ZOM service.
There are several different criteria for selecting objects. You can select objects by name, by type, by keyword, by interdependencies on other objects and by various properties. Each of these selection criteria is represented by a different letter:
| Selection Criteria | Select Objects by |
| n | Name. The Name criteria (n) enables you to select objects by name. You provide the name(s) or pattern(s) (using wild card characters) to match. You can also select objects by the name(s) of the Zim directory to which they belong. |
| t | Type. The Type criteria (t) enables you to select objects by their type. You provide an indicator of what type(s) of object (e.g., EntitySet, form, variable, etc.) you are interested in. |
| k | Keyword. The Keyword criteria (k) enables you to select objects by the keywords they have been assigned. You provide the keyword(s) in which you are interested. (ZOM also provides processing options to enable you to assign keywords to objects.) |
| p | Property. The Property criteria (p) enables you to select objects by any of the properties that ZOM records for the objects in your system. These include status, defined, exists, selected, locked, active, data, datasave, compilable, and compilestatus. You provide a symbol indicating the property(s) in which you are interested. |
| x | Dependency Explosion. The Dependency Explosion criteria (x) enables you to select objects that depend on (i.e. uses) other objects. |
| I | Dependency Implosion. The Dependency Implosion criteria (i) enables you to select objects that are depended on (i.e. used by) other objects. |
| . | Previously Selected. The Previously Selected criteria (.) enables you to select the objects that were selected by the last ZOM service invoked. This is very useful for processing the same set of objects over and over again. It is also convenient for re-selecting a set of objects that you first previewed using ZOMList. |
s | Named Set. You can select objects by a named set that contain a list of objects. The set should contain the object list EntitySet. |
Objects can be selected by name using the selection criteria “n” followed by the object name(s) to match. All objects matching the given name are selected. For example, in the following command all objects named “Customers” are selected for use by the ZOMLIST service:
ZOMList +n Customers
The name can be specified as a character string pattern. For example, the following command lists all objects whose object name begins with “Cust”
ZOMList +n Cust*
In specifying a name to match, certain characters have special meaning:
| ? | question mark matches any single character |
| * | asterisk matches any sequence of zero or more characters |
| backslash causes the next character to be taken literally and ignores any special meaning that character might otherwise have |
The next example selects all objects whose name begins with “Cust”, followed by any character, followed by “XXX”, followed by any number of characters:
ZOMList +n Cust?XXX*
This pattern would match object names such as “Cust1XXX” and “CustaXXXabc”.
If more than one name is used with the same selection criteria, you can use commas to separate the names. The following examples both select all objects named “Customers”, “Employees” or “SalesPeople”:
ZOMList +n Customers +n Employees +n SalesPeople
ZOMList +n Customers,Employees,SalesPeople
In the latter case, we have combined the three selection items into a single selection by separating the three name patterns by commas (‘,’).
The next example shows the use of the minus set operator (‘-‘) to select all objects that do not have the name “Customers”, “Employees” or “SalesPeople”.
ZOMList +n * -n Customers,Employees,SalesPeople
Here the first selection item “+n *” selects all objects, then the minus item (“-n”) that follows excludes all objects with the “Customers”, “Employees” or “SalesPeople”.
Objects can also be selected by specifying the owning directory. For example, the next command lists all objects named “Customers” belonging to the directory “SalesSystem”:
ZOMList +n SalesSystem.Customers
The period (‘.’) separating the literals “SalesSystem” and “Customers” in this example indicates that SalesSystem is the owning directory and Customers is the object contained in this directory.
You can also use the pattern matching feature with directory names. For example, the following command selects all objects belonging to the Test directory:
ZOMList +n Test.*
The next example selects all objects whose name begins with “Cust” and belong to the Test directory:
ZOMList +n Test.Cust*
The next example selects all objects whose name begins with “Custs” and belong to any directory whose name ends with “Test”:
ZOMList +n *Test.Cust*
As a convenience, you do not have to specify “+n” if the first selection is by name. In this case, “+n” is assumed. For example, the following two commands are equivalent:
ZOMList +n Customers, Satellites
ZOMList Customers, Satellites
Objects can be selected based on their dependency on other objects by using the selection criteria “x”. The dependency explosion criteria uses the set of objects selected so far to select the objects that depend on those objects. It takes the set of currently selected objects and performs a dependency explosion operation on that set of objects. The nature and extent of the explosion is determined by attaching further criteria qualifiers. If no qualifier is attached, all objects that depend on the object are added to the set of objects selected. If a “p” is attached, this indicates a program dependency explosion. If followed by a “t”, this indicates an object creation dependency explosion. The “h” option indicates a Hollow explosion process, which results only in the set of exploded objects without the original objects.
In the following example, all objects named “Customers” are selected along with all other objects that depend on the “Customers” objects:
ZOMList Customers +x
Since the dependency explosion depends on having previously selected some objects, the “x” selection operator should never be used as the first selection criteria.
In a hollow dependency explosion, the original set of objects is excluded from the result. The following command finds all objects which depend on objects named “Customers” but excludes the “Customers” objects:
ZOMList Customers +x h
The following command finds all objects which depend on the object “Customers” and all objects depending on them, and recurses until no further depending objects are found. Program references are omitted from the dependency tree exploded.
ZOMList Customers +x t
The following command finds all objects that depend on the object “pMainMenu” and all objects that depending on them, and recurses until no further depending objects are found. Program references are used rather than object creation dependencies when the dependency tree is exploded.
ZOMList pMainMenu +x p
Note: Dependencies between objects and dependency explosions are explained in Object Dependencies.
Objects can be selected based on the dependency of other objects on them by using the selection criteria “i”. The dependency implosion criteria uses the set of objects selected so far to select the objects depending on those objects. It takes the set of currently selected objects and performs the implosion operation on that set of objects. The nature and extent of the implosion is determined by attaching further criteria qualifiers. If no qualifier is attached, all objects that the object depends on are added to the set of objects selected. If a “p” is attached, this indicates a program dependency implosion. If followed by a “t”, this indicates an object creation dependency implosion. The “h” option indicates a Hollow implosion process, which results in only the set of imploded objects without the original objects.
Note: Dependencies between objects and dependency implosions are explained in Object Dependencies.
The following command finds all objects depended on by the object “Customers,” and includes the original object as well.
ZOMList Customers +i
Since the dependency implosion depends on having previously selected some objects, the “i” selection operator should never be used as the first selection criteria.
In a hollow dependency implosion, the original set of objects is excluded from the result. The following command finds all objects depended on by objects named “Customers” but excludes the “Customers” objects:
ZOMList Customers +i h
The following command finds all objects depended on by the object “Customers,” and all objects on which they depend, and recurses until no further dependent objects are found. Program references are omitted from the dependency tree imploded.
ZOMList Customers +i t
The following command finds all objects depended on by the object “pMainMenu,” and all objects on which they depend, and recurses until no further dependent objects are found. Program references are used rather than object creation dependencies when the dependency tree is imploded.
ZOMList pMainMenu +i p
Objects can be selected based on whether or not they are referenced by another object by using the selection operator “u”. An unreferenced object is an object that is not depended on by any other object; e.g., a variable which is not used in a program, relationship, role condition, or a virtual field is ” unreferenced”. For example, in the following command, all unreferenced objects are selected for use by the ZOMLIST service:
ZOMList +p u
Generally, unreferenced objects are unused by a program, but this is not always so. For example, the main menu of a program can be unreferenced, because it is, by definition, the starting point of the application. Similarly, object references hidden in Zim macros are not detectable. Nevertheless, the unreferenced criteria is a great assistant in identifying objects that are no longer needed in an application, and helps the process of clean up.
An example of how to effectively use the unreferenced criteria is shown below. Upon reviewing the results of the ZOMList command above, we determined that all unreferenced objects but ” pMainMenu” are no longer needed. Instead of destroying these objects, they are assigned the keyword “Garbage”. Then the “Garbage” objects are erased. Erase is a better choice than destroy because you can test the application and recover any needed objects. If a problem arises because some of the “Garbage” objects are actually needed, those objects can be created since ZOMErase does not remove the description from the Object Dictionary.
ZOMSet + pu – n pMainMenu ; k Garbage
ZOMErase + k Garbage
Once the application has been tested following the erase, the final act of cleanup is to destroy the key-worded objects. The destroy operation removes both the object and its Object Dictionary description.
ZOMDestroy + k Garbage
Objects can be selected by keyword using the selection criteria “k” followed by the keyword (s) to match. All objects that have been assigned the given keyword (s) are selected. For example, in the following command, all objects that have been assigned the keyword “User_Interface” are selected for use by the ZOMLIST service:
ZOMList +k User_Interface
The keyword criteria performs an keyword match against a specified keyword, and finds all objects which have been assigned that keyword.
The keyword can also be specified as a character string pattern. For example, the following command lists all objects that have been assigned keywords that begin with “Version2”:
ZOMList +k Version2*
The rules for specifying keyword patterns are the same as for selecting by name.
If more than one keyword is used with the same selection criteria, you can use commas to separate the keywords. The following examples both select all objects assigned the keywords “Version1”, “Version2” or “Version3”:
ZOMList +k Version1 +k Version2 +k Version3
ZOMList +k Version1,Version2,Version3
In the latter case, we have combined the three selection items into a single selection by separating the three keywords by commas (‘,’).
Objects have various properties which record the status of the object. You can select objects based on these status properties using the selection operator “p”. Since there are many properties available, you identify the desired property explicitly. Each status property has its own symbol that is used for both selecting and setting the property.
For example in the following command, all objects that have the locked property are selected for use by the ZOMLIST service:
ZOMList +p l
Here the selection criteria “p” indicates property and the argument “l” indicates the property to match is the locked property.
You can also select objects by specifying those that do not have a specific property. The next example selects all object that are not locked:
ZOMList +p l!
The exclamation point (!) negates the specified property. In other words, the “!” selects those object that do not have the specified property.
The following subsections describe how to select objects by each of the various status properties.
English 
Portuguese