Category: Commands

An IN comparison is logically true if expression is equal to at least one of the values in the specified list.
A NOT IN comparison is logically true if expression is not equal to any of the values in the specified list.
In either case, the comparison ends as soon as a logically true instance is found.

The syntax of a call to a procedure is

procname (expression)

Parameters

Comments

The list of expressions must be enclosed in parentheses; even when no expressions are required, the parentheses must still appear.
At the prompt level, you can issue a call to the main procedure of any procedure program.
Within a procedure program, you can issue a call to

• any local procedure in the current program
• the main procedure in the current program
• the main procedure in any other procedure program

Any procedure in a procedure program can issue a call to itself.
In a call to a procedure, you must supply one expression for each parameter specified in the PROCEDURE or LOCALPROCEDURE command that describes the called procedure. The number and type of expressions listed in the call to a particular procedure must match the number and type of parameters in the PROCEDURE command in order for the procedure to execute. The value of expression can be assigned to the corresponding parameter (IN parameters), or expression can take on the value of the corresponding parameter when the procedure ends (OUT parameters), or both (INOUT parameters).
When you specify more than one expression, each must be separated from the next by a comma.

Names for objects defined in the Object Dictionary must conform to the following conventions:

Examples of Object Names

Compare these to the following invalid names:

There are two types of permissions – object permissions (EntitySets, relationships, and directories) and field-level permissions. Field level permissions take precedence over object permissions. The permissions are set as follows: The following chart summarizes the permissions needed in order to successfully execute a given form of data manipulation on an object where permissions are currently in place. Definitions are as follows:

• Owner refers to the user who created an object.
• Group refers to any user who shares a common group ID with the object’s owner.
• Other refers to any user who does not share a common group ID with the object’s owner.

Note: Any user with a GroupID equal to 0 is considered to be a superuser. Superusers are not governed by permissions currently in place on objects, fields, or both. Thus, an object is created by a person logged in as superuser, then permissions applied to the Group are ignored since every user in the creator’s group is a super user. It is not advisable to create objects while logged in as a superuser, in order to take full advantage of Zim’s security features. Different permissions can be assigned to objects, fields, or both for users inside the owner’s group (Group) and to users outside the objects’ owner group (Other).

where R = read, A = Add, C = Change, and D = Delete (1) Null values for all fields with no update permission

Except in certain limited instances (e.g., security passwords, values held in objects of data type CHAR and VARCHAR), the software is case insensitive. Insensitivity to case means that the software makes no distinction between uppercase and lowercase letters in any part of a statement. For example, the following statements are identical, provided LastName is not a CHAR or VARCHAR field:

list all employees where lastname = ‘smith’

LIST ALL EMPLOYEES WHERE LASTNAME = ‘SMITH’

lIsT aLl EmPlOyEeS wHeRe LaStNaMe = ‘SmItH’

list all employees where LastName = ‘Smith’

Normally, in a statement, you can use the combination of uppercase and lowercase letters that makes the statement most readable.

Any value expression used in an application – including the names of objects that represent values – must conform to one of the available data types.

Data Types and Objects

Objects that represent values (constants, variables, fields and form fields) have an explicit data type attribute defined in the Object Dictionary. Value expressions that are not defined objects take implicit data types. The data type of an object or expression determines the values that an object or expression can represent and how the software handles the value. The software recognizes nine different data types:

Output masks are employed to format the output of fields, form fields, and data values in output operations. The MASK format option in Zim Reports specifies an output mask pattern for a report item. The $mask function specifies an output masking pattern to be applied to fields, form fields, and data values and returns a character string with the result of the masking operation. The Field Mask attribute defines the expected output format of a field’s data value when it is printed or listed in Zim Reports, or by the list or output commands.   Mask patterns used with any of the three options described above are constructed in the same manner using the same set of available characters. However, the set of characters available varies according to the data type of the item being masked. For more information on mask patterns and their relation to data types, see Masking.

Selected Examples of Mask Patterns for Numbers

In the following examples, leading or trailing spaces are indicated by / in the Output column.

Output of Sign Placeholders

Behaviour of Fixed Text Characters

Behaviour of Float Characters

Mask Patterns and the Language Customizer

Certain characters inserted into the output value by a mask are defined internally in the software. The Language Customizer (ZIMLANG) administrative utility is used to redefine the internal characters and strings used by the software in a variety of circumstances, such as output masks.

For example, the currency placeholder $,  is by default the dollar sign $. However, it can be redefined to output other symbols, such as the Euro sign €, the pound sign  £, etc. To achieve this, the Language Customizer can redefine the currency symbol output by the currency placeholder.

When using the Language Customizer to edit the software’s internal characters and strings, note the following:

• In application programs, output masks are always specified using the standard mask pattern characters. This rule applies to mask patterns specified in reports, in field and form field definitions, and in the $mask function.
• In user interface displays and output, the characters output by a mask pattern are determined by the software’s internal values.

For example, in Zim application programs, the dollar sign $ is universally used as the currency placeholder. However, the currency symbol output by the placeholder depends on the current language customization (if any).

Any meaningful combination of the following options can be applied to any value displayed in a report:

Triggers an exception handler in the absence of an exception condition.

Syntax

SET EXCEPTION condition

Parameters

Comments

A SET EXCEPTION command mimics the specified condition, triggering the associated exception handler, if such a handler has been declared (by the ON command). The SET EXCEPTION command cannot be used in the body of an exception handler. The SET EXCEPTION command has no effect on system variables such as $InTransaction, $ErrCode, or $ErrLevel. The SET EXCEPTION command is not affected by the SET RESET and SET RESTORE commands.

Example

localprocedure LocProc (inout $Deadlock)
   on deadlock
      let $Deadlock = $true
      return
   endon
   ... other commands ...
endprocedure
procedure MainProc ()
   on deadlock
      goto RetryTransaction
   endon
   ... other commands ...
RetryTransaction:
   transaction
   ... other commands ...
   LocProc ($Deadlock)
   if $Deadlock = $true
      set exception deadlock
   endif
   ... other commands ...
   endtransaction
endprocedure

In the preceding example, SET EXCEPTION mimics a DEADLOCK condition, triggering the declared deadlock exception handler in one procedure when the deadlock has actually occurred in another procedure.

See Also

ON

A macro is a dynamically declared name that represents a character string. When a macro call is encountered in an application program the macro call is replaced by the current character string value of the macro. Macros are sometimes called replacement parameters or substitution variables.
The following topics discuss how to work with macros in applications: