Impala supports the following conditional functions for testing equality, comparison operators, and nullity:

CASE a WHEN b THEN c [WHEN d THEN e]... [ELSE f] END

CASE expression Purpose: Compares an expression to one or more possible values, and returns a corresponding result when a match is found.

In this form of the CASE expression, the initial value A being evaluated for each row it typically a column reference, or an expression involving a column. This form can only compare against a set of specified values, not ranges, multi-value comparisons such as BETWEEN or IN, regular expressions, or NULL.

Although this example is split across multiple lines, you can put any or all parts of a CASE expression on a single line, with no punctuation or other separators between the WHEN, ELSE, and END clauses.

select case x when 1 then 'one' when 2 then 'two' when 0 then 'zero' else 'out of range' end from t1;

CASE WHEN a THEN b [WHEN c THEN d]... [ELSE e] END

CASE expression Purpose: Tests whether any of a sequence of expressions is true, and returns a corresponding result for the first true expression.

CASE expressions without an initial test value have more flexibility. For example, they can test different columns in different WHEN clauses, or use comparison operators such as BETWEEN, IN and IS NULL rather than comparing against discrete values.

CASE expressions are often the foundation of long queries that summarize and format results for easy-to-read reports. For example, you might use a CASE function call to turn values from a numeric column into category strings corresponding to integer values, or labels such as Small, Medium and Large based on ranges. Then subsequent parts of the query might aggregate based on the transformed values, such as how many values are classified as small, medium, or large. You can also use CASE to signal problems with out-of-bounds values, NULL values, and so on.

By using operators such as OR, IN, REGEXP, and so on in CASE expressions, you can build extensive tests and transformations into a single query. Therefore, applications that construct SQL statements often rely heavily on CASE calls in the generated SQL code.

Because this flexible form of the CASE expressions allows you to perform many comparisons and call multiple functions when evaluating each row, be careful applying elaborate CASE expressions to queries that process large amounts of data. For example, when practical, evaluate and transform values through CASE after applying operations such as aggregations that reduce the size of the result set; transform numbers to strings after performing joins with the original numeric values.

Although this example is split across multiple lines, you can put any or all parts of a CASE expression on a single line, with no punctuation or other separators between the WHEN, ELSE, and END clauses.

select case when dayname(now()) in ('Saturday','Sunday') then 'result undefined on weekends' when x > y then 'x greater than y' when x = y then 'x and y are equal' when x is null or y is null then 'one of the columns is null' else null end from t1;

coalesce(type v1, type v2, ...)

coalesce() function Purpose: Returns the first specified argument that is not NULL, or NULL if all arguments are NULL.

decode(type expression, type search1, type result1 [, type search2, type result2 ...] [, type default] )

decode() function Purpose: Compares an expression to one or more possible values, and returns a corresponding result when a match is found.

Can be used as shorthand for a CASE expression.

The original expression and the search expressions must of the same type or convertible types. The result expression can be a different type, but all result expressions must be of the same type.

Returns a successful match If the original expression is NULL and a search expression is also NULL. the

Returns NULL if the final default value is omitted and none of the search expressions match the original expression.

The following example translates numeric day values into descriptive names:

SELECT event, decode(day_of_week, 1, "Monday", 2, "Tuesday", 3, "Wednesday", 4, "Thursday", 5, "Friday", 6, "Saturday", 7, "Sunday", "Unknown day") FROM calendar;

if(boolean condition, type ifTrue, type ifFalseOrNull)

if() function Purpose: Tests an expression and returns a corresponding result depending on whether the result is true, false, or NULL.

Return type: Same as the ifTrue argument value

ifnull(type a, type ifNull)

isnull() function Purpose: Alias for the isnull() function, with the same behavior. To simplify porting SQL with vendor extensions to Impala.

isfalse(boolean)

isfalse() function Purpose: Tests if a Boolean expression is false or not. Returns true if so. If the argument is NULL, returns false. Identical to isnottrue(), except it returns the opposite value for a NULL argument.

isnotfalse(boolean)

isnotfalse() function Purpose: Tests if a Boolean expression is not false (that is, either true or NULL). Returns true if so. If the argument is NULL, returns true. Identical to istrue(), except it returns the opposite value for a NULL argument.

isnottrue(boolean)

isnottrue() function Purpose: Tests if a Boolean expression is not true (that is, either false or NULL). Returns true if so. If the argument is NULL, returns true. Identical to isfalse(), except it returns the opposite value for a NULL argument.

isnull(type a, type ifNull)

isnull() function Purpose: Tests if an expression is NULL, and returns the expression result value if not. If the first argument is NULL, returns the second argument.

Compatibility notes: Equivalent to the nvl() function from Oracle Database or ifnull() from MySQL. The nvl() and ifnull() functions are also available in Impala.

Return type: Same as the first argument value

istrue(boolean)

istrue() function Purpose: Tests if a Boolean expression is true or not. Returns true if so. If the argument is NULL, returns false. Identical to isnotfalse(), except it returns the opposite value for a NULL argument.

nonnullvalue(expression)

function Purpose: Tests if an expression (of any type) is NULL or not. Returns false if so. The converse of nullvalue().

nullif(expr1,expr2)

nullif() function Purpose: Returns NULL if the two specified arguments are equal. If the specified arguments are not equal, returns the value of expr1. The data types of the expressions must be compatible, according to the conversion rules from . You cannot use an expression that evaluates to NULL for expr1; that way, you can distinguish a return value of NULL from an argument value of NULL, which would never match expr2.

Usage notes: This function is effectively shorthand for a CASE expression of the form:

CASE WHEN expr1 = expr2 THEN NULL ELSE expr1 END

It is commonly used in division expressions, to produce a NULL result instead of a divide-by-zero error when the divisor is equal to zero:

select 1.0 / nullif(c1,0) as reciprocal from t1;

You might also use it for compatibility with other database systems that support the same NULLIF() function.

nullifzero(numeric_expr)

nullifzero() function Purpose: Returns NULL if the numeric expression evaluates to 0, otherwise returns the result of the expression.

Usage notes: Used to avoid error conditions such as divide-by-zero in numeric calculations. Serves as shorthand for a more elaborate CASE expression, to simplify porting SQL with vendor extensions to Impala.

nullvalue(expression)

function Purpose: Tests if an expression (of any type) is NULL or not. Returns true if so. The converse of nonnullvalue().

nvl(type a, type ifNull)

nvl() function Purpose: Alias for the isnull() function. Tests if an expression is NULL, and returns the expression result value if not. If the first argument is NULL, returns the second argument. Equivalent to the nvl() function from Oracle Database or ifnull() from MySQL.

Return type: Same as the first argument value

nvl2(type a, type ifNull, type ifNotNull)

nvl2() function Purpose: Enhanced variant of the nvl() function. Tests an expression and returns different result values depending on whether it is NULL or not. If the first argument is NULL, returns the second argument. If the first argument is not NULL, returns the third argument. Equivalent to the nvl2() function from Oracle Database.

Return type: Same as the first argument value

The following examples show how a query can use special indicator values to represent null and not-null expression values. The first example tests an INT column and so uses special integer values. The second example tests a STRING column and so uses special string values.

select x, nvl2(x, 999, 0) from nvl2_demo; +------+---------------------------+ | x | if(x is not null, 999, 0) | +------+---------------------------+ | NULL | 0 | | 1 | 999 | | NULL | 0 | | 2 | 999 | +------+---------------------------+ select s, nvl2(s, 'is not null', 'is null') from nvl2_demo; +------+---------------------------------------------+ | s | if(s is not null, 'is not null', 'is null') | +------+---------------------------------------------+ | NULL | is null | | one | is not null | | NULL | is null | | two | is not null | +------+---------------------------------------------+

zeroifnull(numeric_expr)

zeroifnull() function Purpose: Returns 0 if the numeric expression evaluates to NULL, otherwise returns the result of the expression.

Usage notes: Used to avoid unexpected results due to unexpected propagation of NULL values in numeric calculations. Serves as shorthand for a more elaborate CASE expression, to simplify porting SQL with vendor extensions to Impala.