AP scope | AP module | AP contents | AP index | |
Application module: Expression | ISO/TS 10303-1342:2005(E) © ISO |
This clause specifies the information requirements for the Expression application module. The information requirements are specified as the Application Reference Model (ARM) of this application module.
NOTE 1 A graphical representation of the information requirements is given in Annex C.
NOTE 2 The mapping specification is specified in 5.1. It shows how the information requirements are met by using common resources and constructs defined or imported in the MIM schema of this application module.
The following EXPRESS specification begins the Expression_arm schema and identifies the necessary external references.
The Expression module represents expression itself. It can represent a numeric, boolean and a string expression. EXPRESS specification:
*)
SCHEMA Expression_arm;
(*
The following EXPRESS interface statement specifies the elements imported from the ARM of another application module.
EXPRESS specification:
*)
USE FROM
Generic_expression_arm;
--
ISO/TS 10303-1341
(*
NOTE 1 The schemas referenced above are specified in the following part of ISO 10303:
Generic_expression_arm ISO/TS 10303-1341
NOTE 2 See Annex C, Figures C.1, C.2, C.3, C.4, C.5, C.6, C.7, C.8, C.9, C.10, C.11and C.12 for a graphical representation of this schema.
This subclause specifies the ARM entities for this module. Each ARM application entity is an atomic element that embodies a unique application concept and contains attributes specifying the data elements of the entity. The ARM entities and definitions are specified below.
NOTE The AND operator requires at least two Boolean expressions and evaluates to a Boolean value that is the conjunction of the two operands.
EXPRESS specification:
*)
ENTITY And_expression
SUBTYPE OF (Multiple_arity_boolean_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Binary_boolean_expression
ABSTRACT SUPERTYPE
OF (ONEOF (Xor_expression,
Equals_expression))
SUBTYPE OF (Boolean_expression, Binary_generic_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Binary_function_call
ABSTRACT SUPERTYPE
OF (Atan_function)
SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Binary_numeric_expression
ABSTRACT SUPERTYPE
OF (ONEOF (Minus_expression,
Div_expression,
Mod_expression,
Slash_expression,
Power_expression,
Binary_function_call))
SUBTYPE OF (Numeric_expression, Binary_generic_expression);
SELF\Binary_generic_expression.operands : LIST[2:2] OF Numeric_expression;
END_ENTITY;
(*
Attribute definitions:
operands: a list containing the two parameters of the binary operator.
EXPRESS specification:
*)
ENTITY Boolean_defined_function
ABSTRACT SUPERTYPE
SUBTYPE OF (Defined_function, Boolean_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Boolean_expression
ABSTRACT SUPERTYPE
OF (ONEOF (Simple_boolean_expression,
Unary_boolean_expression,
Binary_boolean_expression,
Multiple_arity_boolean_expression,
Comparison_expression,
Interval_expression,
Boolean_defined_function))
SUBTYPE OF (Expression);
END_ENTITY;
(*
NOTE The EXPRESS Boolean data type has as its domain the set containing the two literals TRUE and FALSE.
EXPRESS specification:
*)
ENTITY Boolean_literal
SUBTYPE OF (Simple_boolean_expression, Generic_literal);
the_value : BOOLEAN;
END_ENTITY;
(*
Attribute definitions:
the_value: a BOOLEAN literal value.
NOTE The EXPRESS Boolean data type has as its domain the set containing the two literals TRUE and FALSE.
EXPRESS specification:
*)
ENTITY Boolean_variable
SUBTYPE OF (Simple_boolean_expression, Variable);
END_ENTITY;
(*
NOTE The Comparison_equal evaluates to TRUE if the two operands evaluate to the same value.
EXPRESS specification:
*)
ENTITY Comparison_equal
SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Comparison_expression
ABSTRACT SUPERTYPE
OF (ONEOF (Comparison_equal,
Comparison_greater,
Comparison_greater_equal,
Comparison_less,
Comparison_less_equal,
Comparison_not_equal,
Like_expression))
SUBTYPE OF (Boolean_expression, Binary_generic_expression);
SELF\Binary_generic_expression.operands : LIST[2:2] OF Expression;
WHERE
WR1: (('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION'
IN TYPEOF(SELF\Binary_generic_expression.operands[2]))) OR(('BOOLEAN_EXPRESSION_ARM.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1]))
AND('BOOLEAN_EXPRESSION_ARM.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2]))) OR(('STRING_EXPRESSION_ARM.STRING_EXPRESSION'
IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND('STRING_EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2])));
END_ENTITY;
(*
Attribute definitions:
operands: a list of Generic_expressions that contains the expressions to be compared.
Formal propositions:
WR1: the operands of the Comparison_expression shall be of compatible in type.
EXPRESS specification:
*)
ENTITY Comparison_greater
SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Comparison_greater_equal
SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Comparison_less
SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Comparison_less_equal
SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Comparison_not_equal
SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Concat_expression
SUBTYPE OF (String_expression, Multiple_arity_generic_expression);
SELF\Multiple_arity_generic_expression.operands : LIST[2:?] OF String_expression;
END_ENTITY;
(*
Attribute definitions:
operands: the String_expression to be concatenated.
EXPRESS specification:
*)
ENTITY Defined_function
ABSTRACT SUPERTYPE
;
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Div_expression
SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Equals_expression
SUBTYPE OF (Binary_boolean_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Expression
ABSTRACT SUPERTYPE
OF (ONEOF (Numeric_expression,
Boolean_expression,
String_expression))
SUBTYPE OF (Generic_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Format_function
SUBTYPE OF (String_expression, Binary_generic_expression);
DERIVE
value_to_format : Generic_expression := SELF\Binary_generic_expression.operands[1];
format_string : Generic_expression := SELF\Binary_generic_expression.operands[2];
WHERE
WR1: (('EXPRESSION_ARM.NUMERIC_EXPRESSION') IN TYPEOF(value_to_format)) AND (('EXPRESSION_ARM.STRING_EXPRESSION') IN TYPEOF(format_string));
END_ENTITY;
(*
Attribute definitions:
value_to_format: the Numeric_expression to be formatted.
format_string: the formatting commands that defines the appearance of the result.
Formal propositions:
WR1: the value_to_format shall be a Numeric_expression and the format_string shall be a String_expression.
EXPRESS specification:
*)
ENTITY Index_expression
SUBTYPE OF (String_expression, Binary_generic_expression);
DERIVE
operand : Generic_expression := SELF\Binary_generic_expression.operands[1];
index : Generic_expression := SELF\Binary_generic_expression.operands[2];
WHERE
WR1: ('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(operand)) AND ('EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(index));
WR2: is_int_expr (index);
END_ENTITY;
(*
Attribute definitions:
operand: the String_expression that represents the STRING.
index: the integer Numeric_expression that indicates the index value.
Formal propositions:
WR1: the first operand shall be a String_expression and the second operand shall be a Numeric_expression.
WR2: the position described by the index operand shall be an integer value.
EXPRESS specification:
*)
ENTITY Int_literal
SUBTYPE OF (Literal_number);
SELF\Literal_number.the_value : INTEGER;
END_ENTITY;
(*
Attribute definitions:
the_value: an INTEGER literal value.
EXPRESS specification:
*)
ENTITY Int_numeric_variable
SUBTYPE OF (Numeric_variable);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Interval_expression
SUBTYPE OF (Boolean_expression, Multiple_arity_generic_expression);
DERIVE
interval_low : Generic_expression := SELF\Multiple_arity_generic_expression.operands[1];
interval_item : Generic_expression := SELF\Multiple_arity_generic_expression.operands[2];
interval_high : Generic_expression := SELF\Multiple_arity_generic_expression.operands[3];
WHERE
WR1: ('EXPRESSION_ARM.EXPRESSION' IN TYPEOF(interval_low)) AND ('EXPRESSION_ARM.EXPRESSION' IN TYPEOF(interval_item)) AND
('EXPRESSION_ARM.EXPRESSION' IN TYPEOF(interval_high));
WR2: (('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF (SELF.Interval_low)) AND ('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF
(SELF.Interval_high)) AND ('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF (SELF.Interval_item))) OR(('EXPRESSION_ARM.STRING_EXPRESSION'
IN TYPEOF(SELF.Interval_low)) AND ('EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF.Interval_item)) AND ('EXPRESSION_ARM.NUMERIC_EXPRESSION'
IN TYPEOF(SELF.Interval_high)));
END_ENTITY;
(*
Attribute definitions:
interval_low: the interval_low operand of the interval expression (see 12.2.4 of ISO 10303-11).
interval_item: the interval_item operand of the interval expression (see 12.2.4 of ISO 10303-11).
interval_high: the interval_high operand of the interval expression (see 12.2.4 of ISO 10303-11).
Formal propositions:
WR1: the data type of the operands shall be Expression.
WR2: the types of the Expression to be compared in the Interval_expression shall evaluates to comparable Expression.
EXPRESS specification:
*)
ENTITY Like_expression
SUBTYPE OF (Comparison_expression);
WHERE
WR1: ('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(SELF\Comparison_expression.operands[1])) AND('EXPRESSION_ARM.STRING_EXPRESSION'
IN TYPEOF(SELF\Comparison_expression.operands[2]));
END_ENTITY;
(*
Formal propositions:
WR1: the operand list shall contain two Generic_expressions instances that are String_expression.
EXPRESS specification:
*)
ENTITY Literal_number
ABSTRACT SUPERTYPE
OF (ONEOF (Int_literal,
Real_literal))
SUBTYPE OF (Simple_numeric_expression, Generic_literal);
the_value : NUMBER;
END_ENTITY;
(*
Attribute definitions:
the_value: a NUMBER literal value.
EXPRESS specification:
*)
ENTITY Minus_expression
SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Mod_expression
SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Mult_expression
SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Multiple_arity_boolean_expression
ABSTRACT SUPERTYPE
OF (ONEOF (And_expression,
Or_expression))
SUBTYPE OF (Boolean_expression, Multiple_arity_generic_expression);
SELF\Multiple_arity_generic_expression.operands : LIST[2:?] OF Boolean_expression;
END_ENTITY;
(*
Attribute definitions:
operands: the occurrences of Boolean_expression that represents the parameters of the m-arity operator.
EXPRESS specification:
*)
ENTITY Multiple_arity_function_call
ABSTRACT SUPERTYPE
SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Multiple_arity_numeric_expression
ABSTRACT SUPERTYPE
OF (ONEOF (Plus_expression,
Mult_expression,
Multiple_arity_function_call))
SUBTYPE OF (Numeric_expression, Multiple_arity_generic_expression);
SELF\Multiple_arity_generic_expression.operands : LIST[2:?] OF Numeric_expression;
END_ENTITY;
(*
Attribute definitions:
operands: a list containing the parameters of the multiple arity operator. The length of this list is equal to the arity of the operator.
EXPRESS specification:
*)
ENTITY Not_expression
SUBTYPE OF (Unary_boolean_expression);
SELF\Unary_generic_expression.operand : Boolean_expression;
END_ENTITY;
(*
Attribute definitions:
operand: the Boolean_expression that represents the operand of the 'NOT' operator.
EXPRESS specification:
*)
ENTITY Numeric_expression
ABSTRACT SUPERTYPE
SUBTYPE OF (Expression);
DERIVE
is_int : BOOLEAN := Is_int_expr (SELF);
sql_mappable : BOOLEAN := Is_sql_mappable (SELF);
END_ENTITY;
(*
Attribute definitions:
is_int: a Boolean attribute that indicates if an expression evaluates to integer or not.
sql_mappable: a Boolean attribute that indicates if an expression is mappable to the SQL, defined in ISO/IEC 9075:1992, query language.
EXPRESS specification:
*)
ENTITY Numeric_variable
SUPERTYPE OF (ONEOF (Int_numeric_variable,
Real_numeric_variable))
SUBTYPE OF (Simple_numeric_expression, Variable);
WHERE
WR1: ('EXPRESSION_ARM.INT_NUMERIC_VARIABLE' IN TYPEOF(SELF)) OR('EXPRESSION_ARM.REAL_NUMERIC_VARIABLE' IN TYPEOF(SELF));
END_ENTITY;
(*
Formal propositions:
WR1: A Numeric_variable can only be a real variable or an integer variable.
NOTE The OR operator requires at least two Boolean expressions and evaluates to a Boolean value that is the inclusive disjunction of the two operands.
EXPRESS specification:
*)
ENTITY Or_expression
SUBTYPE OF (Multiple_arity_boolean_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Plus_expression
SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Power_expression
SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*
NOTE An EXPRESS REAL literal represents a real VALUE that is composed of a mantissa and an optional exponent; the mantissa shall include a decimal point.
EXPRESS specification:
*)
ENTITY Real_literal
SUBTYPE OF (Literal_number);
SELF\Literal_number.the_value : REAL;
END_ENTITY;
(*
Attribute definitions:
the_value: a REAL literal value.
EXPRESS specification:
*)
ENTITY Real_numeric_variable
SUBTYPE OF (Numeric_variable);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Simple_boolean_expression
ABSTRACT SUPERTYPE
OF (ONEOF (Boolean_literal,
Boolean_variable))
SUBTYPE OF (Boolean_expression, Simple_generic_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Simple_numeric_expression
ABSTRACT SUPERTYPE
OF (ONEOF (Literal_number,
Numeric_variable))
SUBTYPE OF (Numeric_expression, Simple_generic_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Simple_string_expression
ABSTRACT SUPERTYPE
OF (ONEOF (String_literal,
String_variable))
SUBTYPE OF (String_expression, Simple_generic_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Slash_expression
SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Sql_mappable_defined_function
ABSTRACT SUPERTYPE
SUBTYPE OF (Defined_function);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY String_defined_function
ABSTRACT SUPERTYPE
SUBTYPE OF (Defined_function, String_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY String_expression
ABSTRACT SUPERTYPE
OF (ONEOF (Simple_string_expression,
Index_expression,
Substring_expression,
Concat_expression,
Format_function,
String_defined_function))
SUBTYPE OF (Expression);
END_ENTITY;
(*
NOTE The EXPRESS STRING data type has as its domain sequences of characters.
EXPRESS specification:
*)
ENTITY String_literal
SUBTYPE OF (Simple_string_expression, Generic_literal);
the_value : STRING;
END_ENTITY;
(*
Attribute definitions:
the_value: a STRING literal value.
EXPRESS specification:
*)
ENTITY String_variable
SUBTYPE OF (Simple_string_expression, Variable);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Substring_expression
SUBTYPE OF (String_expression, Multiple_arity_generic_expression);
DERIVE
operand : Generic_expression := SELF\Multiple_arity_generic_expression.operands[1];
index1 : Generic_expression := SELF\Multiple_arity_generic_expression.operands[2];
index2 : Generic_expression := SELF\Multiple_arity_generic_expression.operands[3];
WHERE
WR1: ('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(operand)) AND ('EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(index1)) AND
('EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(index2));
WR2: SIZEOF(SELF\Multiple_arity_generic_expression.operands)=3;
WR3: is_int_expr (index1);
WR4: is_int_expr (index2);
END_ENTITY;
(*
Attribute definitions:
operand: the String_expression from which a substring is extracted.
index1: the Numeric_expression that indicates the low bound of the substring in operand.
index2: the Numeric_expression that indicates the high bound of the substring in operand.
Formal propositions:
WR1: operand shall be a String_expression, index1 and index2 shall be a Numeric_expression.
WR2: the Substring_expression operands LIST shall contain three elements.
WR3: the index1 shall evaluate to an INTEGER value.
WR4: the index2 shall evaluate to an INTEGER value.
EXPRESS specification:
*)
ENTITY Unary_boolean_expression
ABSTRACT SUPERTYPE
SUBTYPE OF (Boolean_expression, Unary_generic_expression);
END_ENTITY;
(*
EXPRESS specification:
*)
ENTITY Unary_numeric_expression
ABSTRACT SUPERTYPE
OF (Unary_function_call)
SUBTYPE OF (Numeric_expression, Unary_generic_expression);
SELF\Unary_generic_expression.operand : Numeric_expression;
END_ENTITY;
(*
Attribute definitions:
operand: a Numeric_expression that represents the parameter of the unary operator.
NOTE The XOR operator requires two Boolean operands and evaluates to a Boolean value that is the exclusive disjunction of the two operands.
EXPRESS specification:
*)
ENTITY Xor_expression
SUBTYPE OF (Binary_boolean_expression);
SELF\Binary_generic_expression.operands : LIST[2:2] OF Boolean_expression;
END_ENTITY;
(*
Attribute definitions:
operands: the two Binary_boolean_expression operands of the XOR operator that shall be Binary_boolean_expression.
This subclause specifies the ARM functions for this module. The ARM functions and definitions are specified below.
EXPRESS specification:
*)
FUNCTION Is_sql_mappable (arg : expression) :BOOLEAN;
LOCAL i: INTEGER; END_LOCAL; IF 'EXPRESSION_ARM.SIMPLE_NUMERIC_EXPRESSION' IN TYPEOF (arg) THEN RETURN (TRUE); END_IF; IF 'EXPRESSION_ARM.SQL_MAPPABLE_DEFINED_FUNCTION' IN TYPEOF (arg) THEN RETURN (TRUE); END_IF; IF 'EXPRESSION_ARM.MINUS_FUNCTION' IN TYPEOF(arg) THEN RETURN (Is_sql_mappable(arg\Unary_numeric_expression.operand)); END_IF; IF ('EXPRESSION_ARM.ABS_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.SIN_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.COS_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.TAN_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.ASIN_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.ACOS_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.ATAN_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.EXP_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.LOG_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.LOG2_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.LOG10_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.VALUE_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.LENGTH_FUNCTION' IN TYPEOF(arg)) THEN RETURN (FALSE); END_IF; IF ('EXPRESSION_ARM.PLUS_EXPRESSION' IN TYPEOF(arg)) OR('EXPRESSION_ARM.MULT_EXPRESSION' IN TYPEOF(arg)) OR('EXPRESSION_ARM.MAXIMUM_FUNCTION' IN TYPEOF(arg)) OR('EXPRESSION_ARM.MAXIMUM_FUNCTION' IN TYPEOF(arg)) THEN REPEAT i :=1 TO SIZEOF ( arg\Multiple_arity_numeric_expression.operands); IF NOT Is_sql_mappable( arg\Multiple_arity_numeric_expression.operands[i]) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; IF ('EXPRESSION_ARM.MINUS_EXPRESSION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.SLASH_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (Is_sql_mappable( arg\Binary_numeric_expression.operands[1]) AND Is_sql_mappable(arg\Binary_numeric_expression.operands[2])); END_IF; IF ('EXPRESSION_ARM.DIV_EXPRESSION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.MOD_EXPRESSION' IN TYPEOF(arg)) OR('EXPRESSION_ARM.POWER_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (FALSE); END_IF; IF 'EXPRESSION_ARM.SIMPLE_BOOLEAN_EXPRESSION' IN TYPEOF (arg) THEN RETURN (TRUE); END_IF; IF 'EXPRESSION_ARM.NOT_EXPRESSION' IN TYPEOF (arg) THEN RETURN (Is_sql_mappable (arg\UNARY_GENERIC_EXPRESSION.OPERAND)); END_IF; IF ('EXPRESSION_ARM.ODD_FUNCTION'IN TYPEOF (arg)) OR ('EXPRESSION_ARM.XOR_EXPRESSION' IN TYPEOF (arg)) THEN RETURN (FALSE); END_IF; IF ('EXPRESSION_ARM.AND_EXPRESSION' IN TYPEOF (arg)) OR ('EXPRESSION_ARM.OR_EXPRESSION' IN TYPEOF (arg)) THEN REPEAT i:=1 TO SIZEOF ( arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.OPERANDS); IF NOT Is_sql_mappable ( arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.OPERANDS[i]) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; IF 'EXPRESSION_ARM.EQUALS_EXPRESSION' IN TYPEOF (arg) THEN RETURN(Is_sql_mappable ( arg\Binary_generic_expression.OPERANDS [1]) AND Is_sql_mappable( arg\Binary_generic_expression.OPERANDS [2])); END_IF; IF ('EXPRESSION_ARM.COMPARISON_EQUAL' IN TYPEOF (arg)) OR ('EXPRESSION_ARM.COMPARISON_GREATER' IN TYPEOF (arg)) OR ('EXPRESSION_ARM.COMPARISON_GREATER_EQUAL' IN TYPEOF (arg)) OR ('EXPRESSION_ARM.COMPARISON_LESS' IN TYPEOF (arg)) OR ('EXPRESSION_ARM.COMPARISON_LESS_EQUAL' IN TYPEOF (arg)) OR ('EXPRESSION_ARM.COMPARISON_NOT_EQUAL' IN TYPEOF (arg)) OR ('EXPRESSION_ARM.LIKE_EXPRESSION' IN TYPEOF (arg)) THEN RETURN (Is_sql_mappable (arg\COMPARISON_EXPRESSION.OPERANDS[1]) AND Is_sql_mappable (arg\COMPARISON_EXPRESSION.OPERANDS[2])); END_IF; IF 'EXPRESSION_ARM.INTERVAL_EXPRESSION' IN TYPEOF(arg) THEN RETURN (Is_sql_mappable(arg\Interval_expression.interval_low) AND Is_sql_mappable(arg\Interval_expression.interval_high) AND Is_sql_mappable(arg\Interval_expression.interval_item)); END_IF; IF ('NUMERIC_FUNCTION_ARM.NUMERIC_DEFINED_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.BOOLEAN_DEFINED_FUNCTION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.STRING_DEFINED_FUNCTION' IN TYPEOF(arg)) THEN RETURN (FALSE) ; END_IF; IF 'EXPRESSION_ARM.SIMPLE_STRING_EXPRESSION' IN TYPEOF(ARG) THEN RETURN (TRUE); END_IF; IF ('EXPRESSION_ARM.INDEX_EXPRESSION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.SUBSTRING_EXPRESSION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.CONCAT_EXPRESSION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.FORMAT_FUNCTION' IN TYPEOF(arg)) THEN RETURN (FALSE); END_IF; RETURN (FALSE);
END_FUNCTION;
(*
Argument definitions:
arg: an Expression.
EXPRESS specification:
*)
FUNCTION Is_int_expr (arg : Numeric_expression) :BOOLEAN;
LOCAL i: INTEGER; END_LOCAL; IF 'EXPRESSION_ARM.INT_LITERAL' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF 'EXPRESSION_ARM.REAL_LITERAL' IN TYPEOF(arg) THEN RETURN (FALSE); END_IF; IF 'EXPRESSION_ARM.INT_NUMERIC_VARIABLE' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF 'EXPRESSION_ARM.REAL_NUMERIC_VARIABLE' IN TYPEOF(arg) THEN RETURN (FALSE); END_IF; IF 'NUMERIC_FUNCTION_ARM.ABS_FUNCTION' IN TYPEOF(arg) THEN RETURN (Is_int_expr(arg\Unary_numeric_expression.operand)); END_IF; IF 'NUMERIC_FUNCTION.MINUS_FUNCTION' IN TYPEOF(arg) THEN RETURN (Is_int_expr(arg\Unary_numeric_expression.operand)); END_IF; IF ('NUMERIC_FUNCTION_ARM.SIN_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.COS_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.TAN_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.ASIN_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.ACOS_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.Atan_function' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.EXP_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.LOG_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.LOG2_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.LOG10_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg)) THEN RETURN (FALSE); END_IF; IF ('EXPRESSION_ARM.PLUS_EXPRESSION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.MULT_EXPRESSION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.MAXIMUM_FUNCTION' IN TYPEOF(arg)) OR ('NUMERIC_FUNCTION_ARM.MINIMUM_FUNCTION' IN TYPEOF(arg)) THEN REPEAT i :=1 TO SIZEOF ( arg\Multiple_arity_numeric_expression.operands); IF NOT Is_int_expr(arg\Multiple_arity_numeric_expression.operands[i]) THEN RETURN (FALSE); END_IF; END_REPEAT; RETURN (TRUE); END_IF; IF ('EXPRESSION_ARM.MINUS_EXPRESSION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.POWER_EXPRESSION' IN TYPEOF(arg)) THEN RETURN (Is_int_expr(arg\Binary_numeric_expression.operands[1]) AND Is_int_expr(arg\Binary_numeric_expression.operands[2])); END_IF; IF ('EXPRESSION_ARM.DIV_EXPRESSION' IN TYPEOF(arg)) OR ('EXPRESSION_ARM.MOD_EXPRESSION' IN TYPEOF(arg)) THEN RETURN(TRUE); END_IF; IF 'EXPRESSION_ARM.SLASH_EXPRESSION' IN TYPEOF(arg) THEN RETURN (FALSE); END_IF; IF 'NUMERIC_FUNCTION_ARM.LENGTH_FUNCTION' IN TYPEOF(arg) THEN RETURN (TRUE); END_IF; IF 'NUMERIC_FUNCTION_ARM.VALUE_FUNCTION' IN TYPEOF(arg) THEN IF 'NUMERIC_FUNCTION_ARM.INT_VALUE_FUNCTION' IN TYPEOF(arg) THEN RETURN (TRUE); ELSE RETURN (FALSE); END_IF; END_IF; IF 'NUMERIC_FUNCTION_ARM.INTEGER_DEFINED_FUNCTION' IN TYPEOF(arg) THEN RETURN(TRUE) ; END_IF; IF'NUMERIC_FUNCTION_ARM.REAL_DEFINED_FUNCTION' IN TYPEOF(arg) THEN RETURN(FALSE) ; END_IF ; IF 'EXPRESSION_ARM.BOOLEAN_DEFINED_FUNCTION' IN TYPEOF(arg) THEN RETURN(FALSE) ; END_IF ; IF 'EXPRESSION_ARM.STRING_DEFINED_FUNCTION' IN TYPEOF(arg) THEN RETURN (FALSE) ; END_IF ; RETURN (FALSE);
END_FUNCTION;
(*
Argument definitions:
arg: it is a Numeric_expression.
*)
END_SCHEMA; -- Expression_arm
(*
© ISO 2005 — All rights reserved