Conversion functions

GoogleSQL supports conversion functions. These data type conversions are explicit, but some conversions can happen implicitly. You can learn more about implicit and explicit conversion here.

Function list

  <a href="https://github.com/google/googlesql/blob/master/docs/json_functions.md#lax_double_array"><code>LAX_DOUBLE_ARRAY</code></a>

  <a href="https://github.com/google/googlesql/blob/master/docs/json_functions.md#lax_float"><code>LAX_FLOAT</code></a>

  <a href="https://github.com/google/googlesql/blob/master/docs/json_functions.md#lax_float_array"><code>LAX_FLOAT_ARRAY</code></a>

BIT_CAST_TO_INT32

BIT_CAST_TO_INT32(value)

Description

GoogleSQL supports bit casting to INT32. A bit cast is a cast in which the order of bits is preserved instead of the value those bytes represent.

The value parameter can represent:

• INT32
• UINT32

Return Data Type

INT32

Examples

SELECT BIT_CAST_TO_UINT32(-1) as UINT32_value, BIT_CAST_TO_INT32(BIT_CAST_TO_UINT32(-1)) as bit_cast_value;

/*---------------+----------------------+
 | UINT32_value  | bit_cast_value       |
 +---------------+----------------------+
 | 4294967295    | -1                   |
 +---------------+----------------------*/

BIT_CAST_TO_INT64

BIT_CAST_TO_INT64(value)

Description

GoogleSQL supports bit casting to INT64. A bit cast is a cast in which the order of bits is preserved instead of the value those bytes represent.

The value parameter can represent:

• INT64
• UINT64

Return Data Type

INT64

Example

SELECT BIT_CAST_TO_UINT64(-1) as UINT64_value, BIT_CAST_TO_INT64(BIT_CAST_TO_UINT64(-1)) as bit_cast_value;

/*-----------------------+----------------------+
 | UINT64_value          | bit_cast_value       |
 +-----------------------+----------------------+
 | 18446744073709551615  | -1                   |
 +-----------------------+----------------------*/

BIT_CAST_TO_UINT32

BIT_CAST_TO_UINT32(value)

Description

GoogleSQL supports bit casting to UINT32. A bit cast is a cast in which the order of bits is preserved instead of the value those bytes represent.

The value parameter can represent:

• INT32
• UINT32

Return Data Type

UINT32

Examples

SELECT -1 as UINT32_value, BIT_CAST_TO_UINT32(-1) as bit_cast_value;

/*--------------+----------------------+
 | UINT32_value | bit_cast_value       |
 +--------------+----------------------+
 | -1           | 4294967295           |
 +--------------+----------------------*/

BIT_CAST_TO_UINT64

BIT_CAST_TO_UINT64(value)

Description

GoogleSQL supports bit casting to UINT64. A bit cast is a cast in which the order of bits is preserved instead of the value those bytes represent.

The value parameter can represent:

• INT64
• UINT64

Return Data Type

UINT64

Example

SELECT -1 as INT64_value, BIT_CAST_TO_UINT64(-1) as bit_cast_value;

/*--------------+----------------------+
 | INT64_value  | bit_cast_value       |
 +--------------+----------------------+
 | -1           | 18446744073709551615 |
 +--------------+----------------------*/

CAST

CAST(expression AS typename [format_clause])

Description

Cast syntax is used in a query to indicate that the result type of an expression should be converted to some other type.

When using CAST, a query can fail if GoogleSQL is unable to perform the cast. If you want to protect your queries from these types of errors, you can use SAFE_CAST.

Casts between supported types that don't successfully map from the original value to the target domain produce runtime errors. For example, casting BYTES to STRING where the byte sequence isn't valid UTF-8 results in a runtime error.

Other examples include:

• Casting INT64 to INT32 where the value overflows INT32.
• Casting STRING to INT32 where the STRING contains non-digit characters.

Some casts can include a format clause, which provides instructions for how to conduct the cast. For example, you could instruct a cast to convert a sequence of bytes to a BASE64-encoded string instead of a UTF-8-encoded string.

The structure of the format clause is unique to each type of cast and more information is available in the section for that cast.

Examples

The following query results in "true" if x is 1, "false" for any other non-NULL value, and NULL if x is NULL.

CAST(x=1 AS STRING)

CAST AS ARRAY

CAST(expression AS ARRAY<element_type>)

Description

GoogleSQL supports casting to ARRAY. The expression parameter can represent an expression for these data types:

• ARRAY

Conversion rules

  The element types of the input
  array must be castable to the
  element types of the target array.
  For example, casting from type
  <code>ARRAY&lt;INT64&gt;</code> to
  <code>ARRAY&lt;DOUBLE&gt;</code> or
  <code>ARRAY&lt;STRING&gt;</code> is valid;
  casting from type <code>ARRAY&lt;INT64&gt;</code>
  to <code>ARRAY&lt;BYTES&gt;</code> isn't valid.
  
</td>

CAST AS BIGNUMERIC

CAST(expression AS BIGNUMERIC)

Description

GoogleSQL supports casting to BIGNUMERIC. The expression parameter can represent an expression for these data types:

• INT32
• UINT32
• INT64
• UINT64
• FLOAT
• DOUBLE
• NUMERIC
• BIGNUMERIC
• STRING

Conversion rules

  Casting a <code>NaN</code>, <code>+inf</code> or
  <code>-inf</code> will return an error. Casting a value outside the range
  of <code>BIGNUMERIC</code> returns an overflow error.
</td>

  to have 38 digits after the decimal point.
</td>

CAST AS BOOL

CAST(expression AS BOOL)

Description

GoogleSQL supports casting to BOOL. The expression parameter can represent an expression for these data types:

• INT32
• UINT32
• INT64
• UINT64
• BOOL
• STRING

Conversion rules

CAST AS BYTES

CAST(expression AS BYTES [format_clause])

Description

GoogleSQL supports casting to BYTES. The expression parameter can represent an expression for these data types:

• BYTES
• STRING
• PROTO

Format clause

When an expression of one type is cast to another type, you can use the format clause to provide instructions for how to conduct the cast. You can use the format clause in this section if expression is a STRING.

• Format string as bytes

Conversion rules

CAST AS DATE

CAST(expression AS DATE [format_clause])

Description

GoogleSQL supports casting to DATE. The expression parameter can represent an expression for these data types:

• STRING
• DATETIME
• TIMESTAMP

Format clause

When an expression of one type is cast to another type, you can use the format clause to provide instructions for how to conduct the cast. You can use the format clause in this section if expression is a STRING.

• Format string as date and time

Conversion rules

CAST AS DATETIME

CAST(expression AS DATETIME [format_clause])

Description

GoogleSQL supports casting to DATETIME. The expression parameter can represent an expression for these data types:

• STRING
• DATETIME
• TIMESTAMP

Format clause

When an expression of one type is cast to another type, you can use the format clause to provide instructions for how to conduct the cast. You can use the format clause in this section if expression is a STRING.

• Format string as date and time

Conversion rules

CAST AS ENUM

CAST(expression AS ENUM)

Description

GoogleSQL supports casting to ENUM. The expression parameter can represent an expression for these data types:

• INT32
• UINT32
• INT64
• UINT64
• STRING
• ENUM

Conversion rules

CAST AS Floating Point

CAST(expression AS DOUBLE)

CAST(expression AS FLOAT)

Description

GoogleSQL supports casting to floating point types. The expression parameter can represent an expression for these data types:

• INT32
• UINT32
• INT64
• UINT64
• FLOAT
• DOUBLE
• NUMERIC
• BIGNUMERIC
• STRING

Conversion rules

CAST AS Integer

CAST(expression AS INT32)

CAST(expression AS UINT32)

CAST(expression AS INT64)

CAST(expression AS UINT64)

Description

GoogleSQL supports casting to integer types. The expression parameter can represent an expression for these data types:

• INT32
• UINT32
• INT64
• UINT64
• FLOAT
• DOUBLE
• NUMERIC
• BIGNUMERIC
• ENUM
• BOOL
• STRING

Conversion rules

Examples

If you are working with hex strings (0x123), you can cast those strings as integers:

SELECT '0x123' as hex_value, CAST('0x123' as INT64) as hex_to_int;

/*-----------+------------+
 | hex_value | hex_to_int |
 +-----------+------------+
 | 0x123     | 291        |
 +-----------+------------*/

SELECT '-0x123' as hex_value, CAST('-0x123' as INT64) as hex_to_int;

/*-----------+------------+
 | hex_value | hex_to_int |
 +-----------+------------+
 | -0x123    | -291       |
 +-----------+------------*/

CAST AS INTERVAL

CAST(expression AS INTERVAL)

Description

GoogleSQL supports casting to INTERVAL. The expression parameter can represent an expression for these data types:

• STRING

Conversion rules

  standard or to interval literal
  format 'Y-M D H:M:S.F'. Partial interval literal formats are also accepted
  when they aren't ambiguous, for example 'H:M:S'.
  If the string expression is invalid or represents an interval that is
  outside of the supported min/max range, then an error is produced.
</td>

Examples

SELECT input, CAST(input AS INTERVAL) AS output
FROM UNNEST([
  '1-2 3 10:20:30.456',
  '1-2',
  '10:20:30',
  'P1Y2M3D',
  'PT10H20M30,456S'
]) input

/*--------------------+--------------------+
 | input              | output             |
 +--------------------+--------------------+
 | 1-2 3 10:20:30.456 | 1-2 3 10:20:30.456 |
 | 1-2                | 1-2 0 0:0:0        |
 | 10:20:30           | 0-0 0 10:20:30     |
 | P1Y2M3D            | 1-2 3 0:0:0        |
 | PT10H20M30,456S    | 0-0 0 10:20:30.456 |
 +--------------------+--------------------*/

CAST AS NUMERIC

CAST(expression AS NUMERIC)

Description

GoogleSQL supports casting to NUMERIC. The expression parameter can represent an expression for these data types:

• INT32
• UINT32
• INT64
• UINT64
• FLOAT
• DOUBLE
• NUMERIC
• BIGNUMERIC
• STRING

Conversion rules

  Casting a <code>NaN</code>, <code>+inf</code> or
  <code>-inf</code> will return an error. Casting a value outside the range
  of <code>NUMERIC</code> returns an overflow error.
</td>

  to have nine digits after the decimal point.
</td>

CAST AS PROTO

CAST(expression AS PROTO)

Description

GoogleSQL supports casting to PROTO. The expression parameter can represent an expression for these data types:

• STRING
• BYTES
• PROTO

Conversion rules

Example

This example references a protocol buffer called Award.

message Award {
  required int32 year = 1;
  optional int32 month = 2;
  repeated Type type = 3;

  message Type {
    optional string award_name = 1;
    optional string category = 2;
  }
}

SELECT
  CAST(
    '''
    year: 2001
    month: 9
    type { award_name: 'Best Artist' category: 'Artist' }
    type { award_name: 'Best Album' category: 'Album' }
    '''
    AS googlesql.examples.music.Award)
  AS award_col

/*---------------------------------------------------------+
 | award_col                                               |
 +---------------------------------------------------------+
 | {                                                       |
 |   year: 2001                                            |
 |   month: 9                                              |
 |   type { award_name: "Best Artist" category: "Artist" } |
 |   type { award_name: "Best Album" category: "Album" }   |
 | }                                                       |
 +---------------------------------------------------------*/

CAST AS RANGE

CAST(expression AS RANGE)

Description

GoogleSQL supports casting to RANGE. The expression parameter can represent an expression for these data types:

• STRING

Conversion rules

Examples

SELECT CAST(
  '[2020-01-01, 2020-01-02)'
  AS RANGE<DATE>) AS string_to_range

/*----------------------------------------+
 | string_to_range                        |
 +----------------------------------------+
 | [DATE '2020-01-01', DATE '2020-01-02') |
 +----------------------------------------*/

SELECT CAST(
  '[2014-09-27 12:30:00.45, 2016-10-17 11:15:00.33)'
  AS RANGE<DATETIME>) AS string_to_range

/*------------------------------------------------------------------------+
 | string_to_range                                                        |
 +------------------------------------------------------------------------+
 | [DATETIME '2014-09-27 12:30:00.45', DATETIME '2016-10-17 11:15:00.33') |
 +------------------------------------------------------------------------*/

SELECT CAST(
  '[2014-09-27 12:30:00+08, 2016-10-17 11:15:00+08)'
  AS RANGE<TIMESTAMP>) AS string_to_range

-- Results depend upon where this query was executed.
/*--------------------------------------------------------------------------+
 | string_to_range                                                          |
 +--------------------------------------------------------------------------+
 | [TIMESTAMP '2014-09-27 12:30:00+08', TIMESTAMP '2016-10-17 11:15:00+08') |
 +--------------------------------------------------------------------------*/

SELECT CAST(
  '[UNBOUNDED, 2020-01-02)'
  AS RANGE<DATE>) AS string_to_range

/*--------------------------------+
 | string_to_range                |
 +--------------------------------+
 | [UNBOUNDED, DATE '2020-01-02') |
 +--------------------------------*/

SELECT CAST(
  '[2020-01-01, NULL)'
  AS RANGE<DATE>) AS string_to_range

/*--------------------------------+
 | string_to_range                |
 +--------------------------------+
 | [DATE '2020-01-01', UNBOUNDED) |
 +--------------------------------*/

CAST AS STRING

CAST(expression AS STRING [format_clause [AT TIME ZONE timezone_expr]])

Description

GoogleSQL supports casting to STRING. The expression parameter can represent an expression for these data types:

• INT32
• UINT32
• INT64
• UINT64
• FLOAT
• DOUBLE
• NUMERIC
• BIGNUMERIC
• ENUM
• BOOL
• BYTES
• PROTO
• TIME
• DATE
• DATETIME
• TIMESTAMP
• RANGE
• INTERVAL
• STRING

Format clause

When an expression of one type is cast to another type, you can use the format clause to provide instructions for how to conduct the cast. You can use the format clause in this section if expression is one of these data types:

• INT32
• UINT32
• INT64
• UINT64
• FLOAT
• DOUBLE
• NUMERIC
• BIGNUMERIC
• BYTES
• TIME
• DATE
• DATETIME
• TIMESTAMP

The format clause for STRING has an additional optional clause called AT TIME ZONE timezone_expr, which you can use to specify a specific time zone to use during formatting of a TIMESTAMP. If this optional clause isn't included when formatting a TIMESTAMP, the default time zone, which is implementation defined, is used.

For more information, see the following topics:

• Format bytes as string
• Format date and time as string
• Format numeric type as string

Conversion rules

Examples

SELECT CAST(CURRENT_DATE() AS STRING) AS current_date

/*---------------+
 | current_date  |
 +---------------+
 | 2021-03-09    |
 +---------------*/

SELECT CAST(CURRENT_DATE() AS STRING FORMAT 'DAY') AS current_day

/*-------------+
 | current_day |
 +-------------+
 | MONDAY      |
 +-------------*/

SELECT CAST(
  TIMESTAMP '2008-12-25 00:00:00+00:00'
  AS STRING FORMAT 'YYYY-MM-DD HH24:MI:SS TZH:TZM') AS date_time_to_string

-- Results depend upon where this query was executed.
/*------------------------------+
 | date_time_to_string          |
 +------------------------------+
 | 2008-12-24 16:00:00 -08:00   |
 +------------------------------*/

SELECT CAST(
  TIMESTAMP '2008-12-25 00:00:00+00:00'
  AS STRING FORMAT 'YYYY-MM-DD HH24:MI:SS TZH:TZM'
  AT TIME ZONE 'Asia/Kolkata') AS date_time_to_string

-- Because the time zone is specified, the result is always the same.
/*------------------------------+
 | date_time_to_string          |
 +------------------------------+
 | 2008-12-25 05:30:00 +05:30   |
 +------------------------------*/

SELECT CAST(INTERVAL 3 DAY AS STRING) AS interval_to_string

/*--------------------+
 | interval_to_string |
 +--------------------+
 | 0-0 3 0:0:0        |
 +--------------------*/

SELECT CAST(
  INTERVAL "1-2 3 4:5:6.789" YEAR TO SECOND
  AS STRING) AS interval_to_string

/*--------------------+
 | interval_to_string |
 +--------------------+
 | 1-2 3 4:5:6.789    |
 +--------------------*/

CAST AS STRUCT

CAST(expression AS STRUCT)

Description

GoogleSQL supports casting to STRUCT. The expression parameter can represent an expression for these data types:

• STRUCT

Conversion rules

CAST AS TIME

CAST(expression AS TIME [format_clause])

Description

GoogleSQL supports casting to TIME. The expression parameter can represent an expression for these data types:

• STRING
• TIME
• DATETIME
• TIMESTAMP

Format clause

When an expression of one type is cast to another type, you can use the format clause to provide instructions for how to conduct the cast. You can use the format clause in this section if expression is a STRING.

• Format string as date and time

Conversion rules

CAST AS TIMESTAMP

CAST(expression AS TIMESTAMP [format_clause [AT TIME ZONE timezone_expr]])

Description

GoogleSQL supports casting to TIMESTAMP. The expression parameter can represent an expression for these data types:

• STRING
• DATETIME
• TIMESTAMP

Format clause

When an expression of one type is cast to another type, you can use the format clause to provide instructions for how to conduct the cast. You can use the format clause in this section if expression is a STRING.

• Format string as date and time

The format clause for TIMESTAMP has an additional optional clause called AT TIME ZONE timezone_expr, which you can use to specify a specific time zone to use during formatting. If this optional clause isn't included, the default time zone, which is implementation defined, is used.

Conversion rules

Examples

The following example casts a string-formatted timestamp as a timestamp:

SELECT CAST("2020-06-02 17:00:53.110+00:00" AS TIMESTAMP) AS as_timestamp

-- Results depend upon where this query was executed.
/*----------------------------+
 | as_timestamp               |
 +----------------------------+
 | 2020-06-03 00:00:53.110+00 |
 +----------------------------*/

The following examples cast a string-formatted date and time as a timestamp. These examples return the same output as the previous example.

SELECT CAST('06/02/2020 17:00:53.110' AS TIMESTAMP FORMAT 'MM/DD/YYYY HH24:MI:SS.FF3' AT TIME ZONE 'UTC') AS as_timestamp

SELECT CAST('06/02/2020 17:00:53.110' AS TIMESTAMP FORMAT 'MM/DD/YYYY HH24:MI:SS.FF3' AT TIME ZONE '+00') AS as_timestamp

SELECT CAST('06/02/2020 17:00:53.110 +00' AS TIMESTAMP FORMAT 'MM/DD/YYYY HH24:MI:SS.FF3 TZH') AS as_timestamp

PARSE_BIGNUMERIC

PARSE_BIGNUMERIC(string_expression)

Description

Converts a STRING to a BIGNUMERIC value.

The numeric literal contained in the string must not exceed the maximum precision or range of the BIGNUMERIC type, or an error occurs. If the number of digits after the decimal point exceeds 38, then the resulting BIGNUMERIC value rounds half away from zero to have 38 digits after the decimal point.

-- This example shows how a string with a decimal point is parsed.
SELECT PARSE_BIGNUMERIC("123.45") AS parsed;

/*--------+
 | parsed |
 +--------+
 | 123.45 |
 +--------*/

-- This example shows how a string with an exponent is parsed.
SELECT PARSE_BIGNUMERIC("123.456E37") AS parsed;

/*-----------------------------------------+
 | parsed                                  |
 +-----------------------------------------+
 | 123400000000000000000000000000000000000 |
 +-----------------------------------------*/

-- This example shows the rounding when digits after the decimal point exceeds 38.
SELECT PARSE_BIGNUMERIC("1.123456789012345678901234567890123456789") as parsed;

/*------------------------------------------+
 | parsed                                   |
 +------------------------------------------+
 | 1.12345678901234567890123456789012345679 |
 +------------------------------------------*/

This function is similar to using the CAST AS BIGNUMERIC function except that the PARSE_BIGNUMERIC function only accepts string inputs and allows the following in the string:

• Spaces between the sign (+/-) and the number
• Signs (+/-) after the number

Rules for valid input strings:

Return Data Type

BIGNUMERIC

Examples

This example shows an input with spaces before, after, and between the sign and the number:

SELECT PARSE_BIGNUMERIC("  -  12.34 ") as parsed;

/*--------+
 | parsed |
 +--------+
 | -12.34 |
 +--------*/

This example shows an input with an exponent as well as the sign after the number:

SELECT PARSE_BIGNUMERIC("12.34e-1-") as parsed;

/*--------+
 | parsed |
 +--------+
 | -1.234 |
 +--------*/

This example shows an input with multiple commas in the integer part of the number:

SELECT PARSE_BIGNUMERIC("  1,2,,3,.45 + ") as parsed;

/*--------+
 | parsed |
 +--------+
 | 123.45 |
 +--------*/

This example shows an input with a decimal point and no digits in the whole number part:

SELECT PARSE_BIGNUMERIC(".1234  ") as parsed;

/*--------+
 | parsed |
 +--------+
 | 0.1234 |
 +--------*/

Examples of invalid inputs

This example is invalid because the whole number part contains no digits:

SELECT PARSE_BIGNUMERIC(",,,.1234  ") as parsed;

This example is invalid because there are whitespaces between digits:

SELECT PARSE_BIGNUMERIC("1  23.4 5  ") as parsed;

This example is invalid because the number is empty except for an exponent:

SELECT PARSE_BIGNUMERIC("  e1 ") as parsed;

This example is invalid because the string contains multiple signs:

SELECT PARSE_BIGNUMERIC("  - 12.3 - ") as parsed;

This example is invalid because the value of the number falls outside the range of BIGNUMERIC:

SELECT PARSE_BIGNUMERIC("12.34E100 ") as parsed;

This example is invalid because the string contains invalid characters:

SELECT PARSE_BIGNUMERIC("\$12.34") as parsed;

PARSE_NUMERIC

PARSE_NUMERIC(string_expression)

Description

Converts a STRING to a NUMERIC value.

The numeric literal contained in the string must not exceed the maximum precision or range of the NUMERIC type, or an error occurs. If the number of digits after the decimal point exceeds nine, then the resulting NUMERIC value rounds half away from zero to have nine digits after the decimal point.

-- This example shows how a string with a decimal point is parsed.
SELECT PARSE_NUMERIC("123.45") AS parsed;

/*--------+
 | parsed |
 +--------+
 | 123.45 |
 +--------*/

-- This example shows how a string with an exponent is parsed.
SELECT PARSE_NUMERIC("12.34E27") as parsed;

/*-------------------------------+
 | parsed                        |
 +-------------------------------+
 | 12340000000000000000000000000 |
 +-------------------------------*/

-- This example shows the rounding when digits after the decimal point exceeds 9.
SELECT PARSE_NUMERIC("1.0123456789") as parsed;

/*-------------+
 | parsed      |
 +-------------+
 | 1.012345679 |
 +-------------*/

This function is similar to using the CAST AS NUMERIC function except that the PARSE_NUMERIC function only accepts string inputs and allows the following in the string:

• Spaces between the sign (+/-) and the number
• Signs (+/-) after the number

Rules for valid input strings:

Return Data Type

NUMERIC

Examples

This example shows an input with spaces before, after, and between the sign and the number:

SELECT PARSE_NUMERIC("  -  12.34 ") as parsed;

/*--------+
 | parsed |
 +--------+
 | -12.34 |
 +--------*/

This example shows an input with an exponent as well as the sign after the number:

SELECT PARSE_NUMERIC("12.34e-1-") as parsed;

/*--------+
 | parsed |
 +--------+
 | -1.234 |
 +--------*/

This example shows an input with multiple commas in the integer part of the number:

SELECT PARSE_NUMERIC("  1,2,,3,.45 + ") as parsed;

/*--------+
 | parsed |
 +--------+
 | 123.45 |
 +--------*/

This example shows an input with a decimal point and no digits in the whole number part:

SELECT PARSE_NUMERIC(".1234  ") as parsed;

/*--------+
 | parsed |
 +--------+
 | 0.1234 |
 +--------*/

Examples of invalid inputs

This example is invalid because the whole number part contains no digits:

SELECT PARSE_NUMERIC(",,,.1234  ") as parsed;

This example is invalid because there are whitespaces between digits:

SELECT PARSE_NUMERIC("1  23.4 5  ") as parsed;

This example is invalid because the number is empty except for an exponent:

SELECT PARSE_NUMERIC("  e1 ") as parsed;

This example is invalid because the string contains multiple signs:

SELECT PARSE_NUMERIC("  - 12.3 - ") as parsed;

This example is invalid because the value of the number falls outside the range of BIGNUMERIC:

SELECT PARSE_NUMERIC("12.34E100 ") as parsed;

This example is invalid because the string contains invalid characters:

SELECT PARSE_NUMERIC("\$12.34") as parsed;

SAFE_CAST

SAFE_CAST(expression AS typename [format_clause])

Description

When using CAST, a query can fail if GoogleSQL is unable to perform the cast. For example, the following query generates an error:

SELECT CAST("apple" AS INT64) AS not_a_number;

If you want to protect your queries from these types of errors, you can use SAFE_CAST. SAFE_CAST replaces runtime errors with NULLs. However, during static analysis, impossible casts between two non-castable types still produce an error because the query is invalid.

SELECT SAFE_CAST("apple" AS INT64) AS not_a_number;

/*--------------+
 | not_a_number |
 +--------------+
 | NULL         |
 +--------------*/

Some casts can include a format clause, which provides instructions for how to conduct the cast. For example, you could instruct a cast to convert a sequence of bytes to a BASE64-encoded string instead of a UTF-8-encoded string.

The structure of the format clause is unique to each type of cast and more information is available in the section for that cast.

If you are casting from bytes to strings, you can also use the function, SAFE_CONVERT_BYTES_TO_STRING. Any invalid UTF-8 characters are replaced with the unicode replacement character, U+FFFD.