Understanding Design Time Rule Error Messages

When creating an analytic model, it is important that you create rules that follow certain guidelines. For example, a multiplication symbol needs a value or expression on both sides of the symbol; therefore, if you create a rule such as 3 + 5 *, the analytic calculation engine cannot interpret the rule.

When you either click the Accept Changes button to accept a rule or you select Tools, Validate Project, the analytic calculation engine examines the analytic model's rules for errors. All error messages for rules appear in the Output window. When you click an error message, the cursor moves to the part or rule in the analytic model definition that caused the error message. At this time, you can edit the rule in question and fix the error.

The following table describes Analytic Calculation Engine's rule error messages and how to resolve them.

Note: When %1 or %2 appears in this table, it denotes that the actual error message includes context-specific information. For example, the Invalid Dimension %1 error message would yield the error Invalid dimension PRODUCTS in the Output window if a rule referred to a nonexistent PRODUCTS dimension.

Error Message

Description

A dimension argument cannot be used here.

An invalid argument was passed to the function. The function does not take a dimension as an argument. Please check the number and argument types for the function in question.

Analytic model with name %1 not found.

The analytic model was not found in the PeopleSoft database. Please make sure that the model is saved before the validate is called.

All dimension arguments must be declared before any expression arguments are declared.

All the dimension arguments must be declared before expression arguments are declared. Dimension arguments are declared with a prefix of $, and expression arguments are declared with a prefix of @. For example:

ARGUMENTS($DIM, @ExprToLookup,
 @Condition,
 @Direction := #FORWARD);

All required arguments must be declared before any optional arguments are declared.

Optional arguments should be placed at the end of the declaration. If there are two or more optional arguments, place the most optional argument last. For example:

ARGUMENTS($Dim, @ExprToLookup,
 @Condition,
 @Direction := #FORWARD);

In this example, @Direction is an optional argument and is placed after the non-optional @Condition argument.

Note: Optional arguments should have a default value.

Circular reference.

See the Circular Reference section below.

Comment is not terminated.

The comment in a rule was not terminated with the symbols >>.

See Inserting a Blank Line into a Rule.

Data cube name is not terminated by a single quote.

The data cube reference in a rule contained a starting single quote but was not terminated with a single quote. Valid syntax for a data cube reference is either of these:

  • DATA_CUBE

  • 'Data Cube'

Duplicate argument name %1.

The argument mentioned in the error is a duplicate. Another argument with the same name is used in the context. Please check the formula in question.

Duplicate dimensions in member references.

Two or more member references in a data cube slice use the same dimension. A data cube slice can refer to only one member from each dimension. For this reason, you must remove one of the clashing member references.

See Slicing Analytic Grid Data.

Error in ARGUMENTS of user function %1.

The analytic calculation engine encountered an error while parsing the ARGUMENTS section of the user function. Please check this section to make sure that it conforms to the following syntax:

ARGUMENTS(argument1, argument2...argumentN)

Dimension arguments should be declared with a prefix of $, and expression arguments should be declared with a prefix of @.

The following error occurred while preprocessing user function %1 %2.

This error occurred while processing the user function, which was referred to in another rule or user function.

Function not allowed in this context.

You used a function that is not allowed in the current context.

Functions are nested too deeply.

Functions are nested when one function is used inside another function. For example, the SIN function is nested inside the ABS function in the expression ABS(SIN(A)). The nesting depth refers to the number of levels of functions within functions. For example, the expression ABS(SIN(MAX(A, B))) has a depth of three, while MAX(ABS(A), SIN(B)) has a depth of two, because the SIN function is not used inside the ABS function. Functions can be nested up to 32 levels deep. This error message appears when you try to nest functions beyond this limit.

Internal error. Uncompiled user function reference made in the formula.

The analytic calculation engine encountered an internal error while compiling rules. Please analyze and correct the user function in question.

Invalid constant.

The rule contains an invalid constant reference. Please refer to the valid constants that are supported by Analytic Calculation Engine.

See Understanding the Elements of Rules.

Invalid dimension %1.

A function is referring to a dimension that does not exist. Make sure that all of the dimension names in the rule are spelled correctly.

Invalid function %1.

The rule contains a user function or built-in function name that the analytic calculation engine does not recognize. The analytic calculation engine reads a name as a function when it is followed by an opening parenthesis. For example, the expression A + BLOOPER(X) generates this error because Analytic Calculation Engine does not contain a function called BLOOPER.

Invalid member reference.

You incorrectly entered a member reference. When this error message occurs, check for one of these problems:

  • The dimension name in the member reference is not spelled correctly.

  • The member name in the member reference is not spelled correctly.

Invalid member reference syntax. Valid syntax is [DIMENSION:Member].

A member reference uses invalid syntax. When referring to members in rules, please make sure that the member is fully qualified with a dimension name. The valid syntax is [DIMENSION_NAME: Member Name]. The brackets ([ ]) are required.

Invalid number.

The current rule contains an invalid number. When this is the case, verify that:

  • The number does not contain any commas.

  • The number does not contain more than one decimal point.

  • If the number is negative, the minus sign precedes the number.

Syntax error.

See the Syntax Error section below.

Text not terminated by quote.

The rule contains a text value that does not have a closing quote. Text values must be enclosed within quotes.

The ARGUMENTS declaration must appear at the beginning of a user function.

The ARGUMENTS function should be placed at the starting block of the body of the user function. Please check the syntax of the ARGUMENTS function.

See ARGUMENTS Declaration.

This argument has not been declared in the ARGUMENTS section.

You used an argument to a user function, in the body of the user function, before declaring it in the ARGUMENTS section. Please check the syntax of the ARGUMENTS function and ensure that all arguments are declared before they are used.

Unbalanced parentheses.

The rule does not contain a closing parenthesis for every opening parenthesis. For example, the expression A + (B * C generates this error because there should be a closing parenthesis following C.

Could not find the user function with the name %1.

The user function was referred to in a rule but was not found in the analytic model.

Could not find the user function rule with the name %1.

The user function that is referenced in the rule was not found in the analytic model. Please check the body of the user function.

Undefined data cube %1.

You referred to a nonexistent data cube in a formula or user function. You must create the data cube before referring to it.

Circular Reference

If a data cube's formula refers directly or indirectly to a current value of the same data cube, the analytic calculation engine generates a circular reference error. Following are some examples of circular references:

Case 1:

A = A + B

When the analytic calculation engine evaluates the formula A + B, the analytic calculation engine changes the value of A. Then, the analytic calculation engine must evaluate the formula again, using the new value of A, consequently changing the value of A again. For this reason, the analytic calculation engine must evaluate the formula again, and so on. Because the analytic calculation engine does not contain a method to exit this cycle, it refuses to accept a formula that contains a circular reference.

This formula contains a direct circular reference because A refers to itself in its own formula.

Case 2:

A = B + C
B = A + D

This case is slightly more complex, but is a result of the same issue presented in Case 1. When the analytic calculation engine evaluates the formula B + C, the analytic calculation engine changes the value of A. The analytic calculation engine must then evaluate the formula A + D, using the new value of A, consequently changing the value of B. For this reason, the analytic calculation engine must reevaluate B + C, consequently changing the value of A. For this reason, the analytic calculation engine must reevaluate A + D, and so on. These two formulas create an endless circle.

These formulas contain an indirect circular reference because neither A nor B refers to itself in its own formula. Instead, the circularity is created by the two formulas working together. The following statement describes this circularity: A depends on B, which depends on A.

Case 3:

A = B + C
B = D + E
D = F + G
F = A + H

In this case, A depends on B, which depends on D, which depends on F, which depends on A.

The analytic calculation engine traps all circular errors and does not allow you to inadvertently create circular references. Though this is the case, you may have to rethink the logic of the analytic model to ensure proper calculation. A circular reference is often the result of a logical error, which is an attempt to define something in terms of itself. If you encounter a circular reference error, you may need to step through the formulas in the analytic model definition to discover where the thinking is circular. After you find this answer, you must rework the logic to remove the circularity.

A circular reference error occurs when a data cube directly or indirectly refers to a current value of itself. On the other hand, if a data cube refers to a previous value of itself, the formula is not only valid but useful.

See PREVSELF.

See Working with Circular Formulas and Circular Systems.

Syntax Error

When you receive a syntax error, the current rule does not follow the basic guidelines for a rule. This is often the result of a typographical error. Possible violations of the rule guidelines include:

  • An arithmetic operator does not have a value on both sides.

    For example, the expression A+B+ generates a syntax error because the second plus operator does not have a value on both sides.

  • Two values exist without an operator between the values.

    For example, the expression Profit 0.50 generates a syntax error because there is no operator between the data cube reference and the number.

  • The rule contains a symbol that the analytic calculation engine does not recognize.

    For example, a dollar sign ($) generates a syntax error.

  • Either a function does not contain the correct number of arguments, or it contains an argument of the wrong type.

    If the syntax error occurs within a function, you may need to check the entry for that function in the built-in function reference.

    See Built-in Function Reference.

  • The rule contains too many closing parentheses.

    For example, the expression A * (B + C)) generates a syntax error because there is an extra closing parenthesis.

    Note: If there are too few closing parentheses, you receive the error Unbalanced parentheses.