Application module: Numeric expression ISO/TS 10303-1526:2018-11(E)
© ISO

Cover page
Table of contents
Copyright
Foreword
Introduction
1 Scope
2 Normative references
3 Terms, definitions and abbreviated terms
    3.1 Terms and definitions
    3.2 Abbreviated terms

4 Information requirements
   4.1 Required AM ARMs
   4.2 ARM entity definitions
   4.3 ARM function definitions
5 Module interpreted model
   5.1 Mapping specification
   5.2 MIM EXPRESS short listing

A MIM short names
B Information object registration
C ARM EXPRESS-G   EXPRESS-G
D MIM EXPRESS-G   EXPRESS-G
E Computer interpretable listings
F Change history
Bibliography
Index

(*
ISO/TC 184/SC 4/WG 12 N9889 - ISO/TS 10303-1526 Numeric expression - EXPRESS ARM
Supersedes ISO/TC 184/SC 4/WG 12 N7867
*)



SCHEMA Numeric_expression_arm;

USE FROM Expression_arm;    -- ISO/TS 10303-1342

USE FROM Generic_expression_arm;    -- ISO/TS 10303-1341

USE FROM Numeric_function_arm;    -- ISO/TS 10303-1346


ENTITY And_expression
  SUBTYPE OF (Multiple_arity_boolean_expression);
END_ENTITY;

ENTITY Binary_boolean_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Xor_expression,
                                Equals_expression))
  SUBTYPE OF (Boolean_expression, Binary_generic_expression);
END_ENTITY;

ENTITY Binary_numeric_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Minus_expression,
                                Div_expression,
                                Mod_expression,
                                Slash_expression,
                                Power_expression))
  SUBTYPE OF (Numeric_expression, Binary_generic_expression);
  SELF\Binary_generic_expression.operands : LIST[2:2] OF Numeric_expression;
END_ENTITY;

ENTITY Boolean_defined_function
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Defined_function, Boolean_expression);
END_ENTITY;

ENTITY Boolean_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Simple_boolean_expression,
                                Unary_boolean_expression,
                                Binary_boolean_expression,
                                Multiple_arity_boolean_expression,
                                Comparison_expression,
                                Boolean_defined_function,
                                Interval_expression))
  SUBTYPE OF (Expression);
END_ENTITY;

ENTITY Boolean_literal
  SUBTYPE OF (Simple_boolean_expression, Generic_literal);
  the_value : BOOLEAN;
END_ENTITY;

ENTITY Boolean_variable
  SUBTYPE OF (Simple_boolean_expression, Variable);
END_ENTITY;

ENTITY Comparison_equal
  SUBTYPE OF (Comparison_expression);
END_ENTITY;

ENTITY Comparison_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Comparison_equal,
                                Comparison_greater,
                                Comparison_greater_equal,
                                Comparison_less,
                                Comparison_less_equal,
                                Comparison_not_equal))
  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 (('NUMERIC_EXPRESSION_ARM.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND ('NUMERIC_EXPRESSION_ARM.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2]))) OR (('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND ('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2])));
END_ENTITY;

ENTITY Comparison_greater
  SUBTYPE OF (Comparison_expression);
END_ENTITY;

ENTITY Comparison_greater_equal
  SUBTYPE OF (Comparison_expression);
END_ENTITY;

ENTITY Comparison_less
  SUBTYPE OF (Comparison_expression);
END_ENTITY;

ENTITY Comparison_less_equal
  SUBTYPE OF (Comparison_expression);
END_ENTITY;

ENTITY Comparison_not_equal
  SUBTYPE OF (Comparison_expression);
END_ENTITY;

ENTITY Defined_function
  ABSTRACT SUPERTYPE ;
END_ENTITY;

ENTITY Div_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;

ENTITY Equals_expression
  SUBTYPE OF (Binary_boolean_expression);
END_ENTITY;

ENTITY Expression
  ABSTRACT SUPERTYPE OF (ONEOF (Numeric_expression,
                                Boolean_expression))
  SUBTYPE OF (Generic_expression);
END_ENTITY;

ENTITY Int_literal
  SUBTYPE OF (Literal_number);
  SELF\Literal_number.the_value : INTEGER;
END_ENTITY;

ENTITY Int_numeric_variable
  SUBTYPE OF (Numeric_variable);
END_ENTITY;

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: ('NUMERIC_EXPRESSION_ARM.EXPRESSION' IN TYPEOF(interval_low)) AND ('NUMERIC_EXPRESSION_ARM.EXPRESSION' IN TYPEOF(interval_item) ) AND ('NUMERIC_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 (('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF.Interval_low)) AND ('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF.Interval_item)) AND ('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF.Interval_high)));
END_ENTITY;

ENTITY Literal_number
  ABSTRACT SUPERTYPE OF (ONEOF (Int_literal,
                                Real_literal))
  SUBTYPE OF (Simple_numeric_expression, Generic_literal);
  the_value : NUMBER;
END_ENTITY;

ENTITY Minus_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;

ENTITY Mod_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;

ENTITY Mult_expression
  SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;

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;

ENTITY Multiple_arity_function_call
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;

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;

ENTITY Not_expression
  SUBTYPE OF (Unary_boolean_expression);
  SELF\Unary_generic_expression.operand : Boolean_expression;
END_ENTITY;

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;

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;

ENTITY Or_expression
  SUBTYPE OF (Multiple_arity_boolean_expression);
END_ENTITY;

ENTITY Plus_expression
  SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;

ENTITY Power_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;

ENTITY Real_literal
  SUBTYPE OF (Literal_number);
  SELF\Literal_number.the_value : REAL;
END_ENTITY;

ENTITY Real_numeric_variable
  SUBTYPE OF (Numeric_variable);
END_ENTITY;

ENTITY Simple_boolean_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Boolean_literal,
                                Boolean_variable))
  SUBTYPE OF (Boolean_expression, Simple_generic_expression);
END_ENTITY;

ENTITY Simple_numeric_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Literal_number,
                                Numeric_variable))
  SUBTYPE OF (Numeric_expression, Simple_generic_expression);
END_ENTITY;

ENTITY Slash_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;

ENTITY Unary_boolean_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Boolean_expression, Unary_generic_expression);
END_ENTITY;

ENTITY Unary_numeric_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Numeric_expression, Unary_generic_expression);
  SELF\Unary_generic_expression.operand : Numeric_expression;
END_ENTITY;

ENTITY Xor_expression
  SUBTYPE OF (Binary_boolean_expression);
  SELF\Binary_generic_expression.operands : LIST[2:2] OF Boolean_expression;
END_ENTITY;

FUNCTION Is_int_expr
 (arg : Numeric_expression) : BOOLEAN;
LOCAL
	i: INTEGER;
END_LOCAL;

IF 'NUMERIC_EXPRESSION_ARM.INT_LITERAL' IN TYPEOF(arg) 
THEN 
	RETURN (TRUE); 
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.REAL_LITERAL' IN TYPEOF(arg) 
THEN 
	RETURN (FALSE); 
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.INT_NUMERIC_VARIABLE' IN TYPEOF(arg) 
THEN 
	RETURN (TRUE); 
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.REAL_NUMERIC_VARIABLE' IN TYPEOF(arg) 
THEN 
	RETURN (FALSE); 
END_IF;
IF 'ELEMENTARY_FUNCTION_ARM.ABS_FUNCTION' IN TYPEOF(arg) 
THEN 
	RETURN (Is_int_expr(arg\Unary_numeric_expression.operand));
END_IF;
IF 'ELEMENTARY_FUNCTION_ARM.MINUS_FUNCTION' IN TYPEOF(arg) 
THEN 
	RETURN (Is_int_expr(arg\Unary_numeric_expression.operand)); 
END_IF;
IF ('ELEMENTARY_FUNCTION_ARM.SIN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.COS_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.TAN_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.ASIN_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.ACOS_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.ATAN_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.EXP_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.LOG_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.LOG2_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.LOG10_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg))
THEN 
	RETURN (FALSE);
END_IF;
IF 	('NUMERIC_EXPRESSION_ARM.PLUS_EXPRESSION' IN TYPEOF(arg))
		OR ('NUMERIC_EXPRESSION_ARM.MULT_EXPRESSION' IN TYPEOF(arg))
		OR ('ELEMENTARY_FUNCTION_ARM.MAXIMUM_FUNCTION' IN TYPEOF(arg))
		OR ('ELEMENTARY_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 	('NUMERIC_EXPRESSION_ARM.MINUS_EXPRESSION' IN TYPEOF(arg))
		OR ('NUMERIC_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	('NUMERIC_EXPRESSION_ARM.DIV_EXPRESSION' IN TYPEOF(arg))
		OR ('NUMERIC_EXPRESSION_ARM.MOD_EXPRESSION' IN TYPEOF(arg))
THEN 
	RETURN(TRUE);	
END_IF;
IF 'NUMERIC_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.FUNCTION_PARAMETER_VALUE' 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 'ELEMENTARY_FUNCTION_ARM.INTEGER_DEFINED_FUNCTION' IN TYPEOF(arg)
THEN 
	RETURN(TRUE) ;
END_IF;
IF'ELEMENTARY_FUNCTION_ARM.REAL_DEFINED_FUNCTION' IN TYPEOF(arg) 
THEN 
	RETURN(FALSE) ;
END_IF ;
IF 'NUMERIC_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;

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 ('ELEMENTARY_FUNCTION_ARM.ABS_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.SIN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.COS_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.TAN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.ASIN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.ACOS_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.ATAN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.EXP_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.LOG_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.LOG2_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.LOG10_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg)) 
	OR ('NUMERIC_FUNCTION_ARM.FUNCTION_PARAMETER_VALUE' IN TYPEOF(arg)) 
	OR ('NUMERIC_FUNCTION_ARM.LENGTH_FUNCTION' IN TYPEOF(arg))
THEN 
	RETURN (FALSE);
END_IF;
IF ('NUMERIC_EXPRESSION_ARM.PLUS_EXPRESSION' IN TYPEOF(arg)) 
	OR('NUMERIC_EXPRESSION_ARM.MULT_EXPRESSION' IN TYPEOF(arg)) 
	OR('NUMERIC_EXPRESSION_ARM.MAXIMUM_FUNCTION' IN TYPEOF(arg)) 
	OR('NUMERIC_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 ('NUMERIC_EXPRESSION_ARM.DIV_EXPRESSION' IN TYPEOF(arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.MOD_EXPRESSION' IN TYPEOF(arg)) 
	OR('NUMERIC_EXPRESSION_ARM.POWER_EXPRESSION' IN TYPEOF(arg))
THEN 
	RETURN (FALSE); 	
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.SIMPLE_BOOLEAN_EXPRESSION' IN TYPEOF (arg) 
THEN 
	RETURN (TRUE);
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.NOT_EXPRESSION' IN TYPEOF (arg) 
THEN 
	RETURN (Is_sql_mappable (arg\UNARY_GENERIC_EXPRESSION.OPERAND));
END_IF;
IF ('NUMERIC_FUNCTION_ARM.ODD_FUNCTION'IN TYPEOF (arg)) 
		OR ('NUMERIC_EXPRESSION_ARM.XOR_EXPRESSION' IN TYPEOF (arg)) 
THEN	
	RETURN (FALSE);
END_IF;
IF ('NUMERIC_EXPRESSION_ARM.AND_EXPRESSION' IN TYPEOF (arg)) 
		OR ('NUMERIC_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 'NUMERIC_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	('NUMERIC_EXPRESSION_ARM.COMPARISON_EQUAL' IN TYPEOF (arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.COMPARISON_GREATER' IN TYPEOF (arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.COMPARISON_GREATER_EQUAL' 	IN TYPEOF (arg))
	OR ('NUMERIC_EXPRESSION_ARM.COMPARISON_LESS' IN TYPEOF (arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.COMPARISON_LESS_EQUAL' IN TYPEOF (arg)) 
	OR ('NUMERIC_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 ('NUMERIC_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;

END_SCHEMA;  -- Numeric_expression_arm


© ISO 2018 — All rights reserved