OpenText Analytics Database 26.2.x – Operators

Sql-Reference: Bitwise operators

Mon, 01 Jan 0001 00:00:00 +0000

Bitwise operators perform bit manipulations on INTEGER and BINARY/VARBINARY data types:

Operator	Description	Example	Result
`&`	AND	`12 & 4`	`4`
`\|`	OR	`32 \| 3`	`35`
`#`	XOR	`17 # 5`	`20`
`~`	NOT	`~1`	`-2`
`<<` ^†	Bitwise shift left	`1 << 4`	`16`
`>>` ^†	Bitwise shift right	`8 >> 2`	`2`

^† Invalid for BINARY/VARBINARY data types

String argument handling

String arguments must be explicitly cast as BINARY or VARBINARY data types for all bitwise operators. For example:

=> SELECT 'xyz'::VARBINARY & 'zyx'::VARBINARY AS AND;
 AND
-----
 xyx
(1 row)

=> SELECT 'xyz'::VARBINARY | 'zyx'::VARBINARY AS OR;
 OR
-----
 zyz
(1 row)

Bitwise operators treats all string arguments as equal in length. If the arguments have different lengths, the operator function right-pads the smaller string with one or more zero bytes to equal the length of the larger string.

For example, the following statement ANDs unequal strings xyz and zy. OpenText™ Analytics Database right-pads string zy with one zero byte. The last character in the result is represented accordingly, as \000:

=> SELECT 'xyz'::VARBINARY & 'zy'::VARBINARY AS AND;
  AND
--------
 xy\000
(1 row)

Sql-Reference: Logical operators

Mon, 01 Jan 0001 00:00:00 +0000

OpenText™ Analytics Database supports the logical operators AND, OR, and NOT:

AND evaluates to true when both of the conditions joined by AND are true.
OR evaluates to true when either condition is true.
NOT negates the result of any Boolean expression.

AND and OR are commutative—that is, you can switch left and right operands without affecting the result. However, the order of evaluation of sub-expressions is not defined. To force evaluation order, use a CASE construct.

Caution

Do not confuse Boolean operators with the Boolean predicate or Boolean data type, which can have only two values: true and false.

Logic

SQL uses a three-valued Boolean logic where NULL represents "unknown":

true AND NULL = NULL
true OR NULL = true
false AND NULL = false
false OR NULL = NULL
NULL AND NULL = NULL
NULL OR NULL = NULL
NOT NULL = NULL

Sql-Reference: Comparison operators

Mon, 01 Jan 0001 00:00:00 +0000

Comparison operators are available for all data types where comparison makes sense. All comparison operators are binary operators that return values of true, false, or NULL (unknown).

Operator	Description	Binary function
`<`	less than	`binary_lt`
`>`	greater than	`binary_gt`
`<=`	less than or equal to	`binary_le`
`>=`	greater than or equal to	`binary_ge`
`=`, `<=>`	equal Note Do not use the negation operator (`!`) with the `<=>` operator. Instead, use `!=` to test for inequality. `!`, except as part of `!=`, is the factorial operator.	`binary_eq`
`!=`, `<>`	not equal (unsupported for correlated subqueries)	`binary_ne`

NULL handling

Comparison operators return NULL (unknown) if either or both operands are null, with one exception: <=> returns true if both operands are NULL, and false if one operand is NULL.

Collections

When comparing collections, null collections are ordered last. Otherwise, collections are compared element by element until there is a mismatch, and then they are ordered based on the non-matching elements. If all elements are equal up to the length of the shorter one, then the shorter one is ordered first.

Sql-Reference: Data type coercion operators (CAST)

Mon, 01 Jan 0001 00:00:00 +0000

Data type coercion (casting) passes an expression value to an input conversion routine for a specified data type, resulting in a constant of the indicated type. Data type coercion can be invoked by an explicit cast request that uses one of the following constructs:

Syntax

SELECT CAST ( expression AS data-type )
SELECT expression::data-type
SELECT data-type 'string'

Parameters

`expression`	An expression of any type.
`data-type`	An SQL data type that OpenText™ Analytics Database supports to convert `expression`.

Truncation

If a binary value is cast (implicitly or explicitly) to a binary type with a smaller length, the value is silently truncated. For example:

=> SELECT 'abcd'::BINARY(2);
 ?column?
----------
 ab
(1 row)

Similarly, if a character value is cast (implicitly or explicitly) to a character value with a smaller length, the value is silently truncated. For example:

=> SELECT 'abcd'::CHAR(3);
 ?column?
----------
 abc
(1 row)

Binary casting and resizing

OpenText™ Analytics Database supports only casts and resize operations as follows:

BINARY to and from VARBINARY
VARBINARY to and from LONG VARBINARY
BINARY to and from LONG VARBINARY

On binary data that contains a value with fewer bytes than the target column, values are right-extended with the zero byte '\0' to the full width of the column. Trailing zeros on variable-length binary values are not right-extended:

=> SELECT 'ab'::BINARY(4), 'ab'::VARBINARY(4), 'ab'::LONG VARBINARY(4);
  ?column?  | ?column? | ?column?
------------+----------+----------
 ab\000\000 | ab       | ab
(1 row)

Automatic coercion

The explicit type cast can be omitted if there is no ambiguity as to the type the constant must be. For example, when a constant is assigned directly to a column, it is automatically coerced to the column's data type.

Examples

=> SELECT CAST((2 + 2) AS VARCHAR);
 ?column?
----------
 4
(1 row)

=> SELECT (2 + 2)::VARCHAR;
 ?column?
----------
 4
(1 row)

=> SELECT INTEGER '123';
 ?column?
----------
      123
(1 row)

=> SELECT (2 + 2)::LONG VARCHAR
 ?column?
----------
 4
(1 row)

=> SELECT '2.2' + 2;
   ERROR:  invalid input syntax for integer: "2.2"

=> SELECT FLOAT '2.2' + 2;
 ?column?
----------
      4.2
(1 row)

Sql-Reference: Date/time operators

Mon, 01 Jan 0001 00:00:00 +0000

OpenText™ Analytics Database supports the use of arithmetic operators on DATE/TIME operands:

+ (addition)
- (subtraction)
* (multiplication)
/ (division)

Examples

The operators described below that take TIME or TIMESTAMP input have two variants:

Operators that take TIME WITH TIME ZONE or TIMESTAMP WITH TIME ZONE input.
Operators that take TIME WITHOUT TIME ZONE or TIMESTAMP WITHOUT TIME ZONE input.

For brevity, these variants are not shown separately.

The + and * operators come in commutative pairs—for example, both DATE + INTEGER and INTEGER + DATE. Only one of each pair is shown.

Example	Result Type	Result
`DATE '2001-09-28' + INTEGER '7'`	`DATE`	`'2001-10-05'`
`DATE '2001-09-28' + INTERVAL '1 HOUR'`	`TIMESTAMP`	`'2001-09-28 01:00:00'`
DATE '2001-09-28' + TIME '03:00'	`TIMESTAMP`	`'2001-09-28 03:00:00'`
INTERVAL '1 DAY' + INTERVAL '1 HOUR'	`INTERVAL`	`'1 DAY 01:00:00'`
TIMESTAMP '2001-09-28 01:00' + INTERVAL '23 HOURS'	`TIMESTAMP`	`'2001-09-29 00:00:00'`
TIME '01:00' + INTERVAL '3 HOURS'	`TIME`	`'04:00:00'`
`- INTERVAL '23 HOURS'`	`INTERVAL`	`'-23:00:00'`
DATE '2001-10-01' – DATE '2001-09-28'	`INTEGER`	`'3'`
`DATE '2001-10-01' – INTEGER '7'`	`DATE`	`'2001-09-24'`
DATE '2001-09-28' – INTERVAL '1 HOUR'	`TIMESTAMP`	`'2001-09-27 23:00:00'`
`TIME '05:00' – TIME '03:00'`	`INTERVAL`	`'02:00:00'`
TIME '05:00' INTERVAL '2 HOURS'	`TIME`	`'03:00:00'`
TIMESTAMP '2001-09-28 23:00' – INTERVAL '23 HOURS'	`TIMESTAMP`	`'2001-09-28 00:00:00'`
INTERVAL '1 DAY' – INTERVAL '1 HOUR'	`INTERVAL`	`'1 DAY -01:00:00'`
TIMESTAMP '2001-09-29 03:00' – TIMESTAMP '2001-09-27 12:00'	`INTERVAL`	`'1 DAY 15:00:00'`
`900 * INTERVAL '1 SECOND'`	`INTERVAL`	`'00:15:00'`
`21 * INTERVAL '1 DAY'`	`INTERVAL`	`'21 DAYS'`
DOUBLE PRECISION '3.5' * INTERVAL '1 HOUR'	`INTERVAL`	`'03:30:00'`
INTERVAL '1 HOUR' / DOUBLE PRECISION '1.5'	`INTERVAL`	`'00:40:00'`

Sql-Reference: Mathematical operators

Mon, 01 Jan 0001 00:00:00 +0000

Mathematical operators are provided for many data types.

Operator	Description	Example	Result
`!`	Factorial	`5 !`	`120`
`+`	Addition	`2 + 3`	`5`
`–`	Subtraction	`2 – 3`	`–1`
`*`	Multiplication	`2 * 3`	`6`
`/`	Division (integer division produces NUMERIC results).	`4 / 2`	`2.00...`
`//`	With integer division, returns an INTEGER rather than a NUMERIC.	`117.32 // 2.5`	`46`
`%`	Modulo (remainder). For details, see `MOD`.	`5 % 4`	`1`
`^`	Exponentiation	`2.0 ^ 3.0`	`8`
`\|/`	Square root	`\|/ 25.0`	`5`
`\|\|/`	Cube root	`\|\|/ 27.0`	`3`
`!!`	Factorial (prefix operator)	`!! 5`	`120`
`@`	Absolute value	`@ -5.0`	`5`

Factorial operator support

OpenText™ Analytics Database supports use of factorial operators on positive and negative floating point (DOUBLE PRECISION) numbers and integers. For example:

=> SELECT 4.98!;
   ?column?
------------------
 115.978600750905
(1 row)

Factorial is defined in terms of the gamma function, where (-1) = Infinity and the other negative integers are undefined. For example:

(–4)! = NaN
–(4!) = –24

Factorial is defined as follows for all complex numbers z:

z! = gamma(z+1)

For details, see Abramowitz and Stegun: Handbook of Mathematical Functions.

Sql-Reference: NULL operators

Mon, 01 Jan 0001 00:00:00 +0000

To check whether a value is or is not NULL, use the following equivalent constructs:

Standard:

[expression IS NULL | expression IS NOT NULL]

Non-standard:

[expression ISNULL | expression NOTNULL]

Do not write expression = NULL: NULL represents an unknown value, and two unknown values are not necessarily equal. This behavior conforms to the SQL standard.

Note

Some applications might expect that expression = NULL returns true if expression evaluates to NULL. In this case, modify the application to comply with the SQL standard.

Sql-Reference: String concatenation operators

Mon, 01 Jan 0001 00:00:00 +0000

To concatenate two strings on a single line, use the concatenation operator (two consecutive vertical bars).

Syntax

string || string

Parameters

string Expression of type CHAR or VARCHAR

Notes

|| is used to concatenate expressions and constants. The expressions are cast to VARCHAR if possible, otherwise to VARBINARY, and must both be one or the other.
Two consecutive strings within a single SQL statement on separate lines are automatically concatenated

Examples

The following example is a single string written on two lines:

=> SELECT E'xx'-> '\\';
 ?column?
----------
 xx\
(1 row)

The following examples show two strings concatenated:

=> SELECT E'xx' ||-> '\\';
 ?column?
----------
 xx\\
(1 row)

=> SELECT 'auto' || 'mobile';
 ?column?
----------
 automobile
(1 row)

=> SELECT 'auto'-> 'mobile';
 ?column?
----------
 automobile
(1 row)

=> SELECT 1 || 2;
 ?column?
----------
 12
(1 row)


=> SELECT '1' || '2';
 ?column?
----------
 12
(1 row)
=> SELECT '1'-> '2';
 ?column?
----------
 12
(1 row)

OpenText Analytics Database 26.2.x – Operators

Sql-Reference: Bitwise operators

String argument handling

Sql-Reference: Logical operators

Caution

Logic

Sql-Reference: Comparison operators

Note

NULL handling

Collections

Sql-Reference: Data type coercion operators (CAST)

Syntax

Parameters

Truncation

Binary casting and resizing

Automatic coercion

Examples

See also

Sql-Reference: Date/time operators

Examples

Sql-Reference: Mathematical operators

Factorial operator support

Sql-Reference: NULL operators

Note

Sql-Reference: String concatenation operators

Syntax

Parameters

Notes

Examples