Google 표준 SQL의 연산자

연산자는 특수문자나 키워드로 표현되며 함수 호출 구문을 사용하지 않습니다. 연산자는 피연산자라고도 불리는 임의 수의 데이터 입력을 조작하여 결과를 반환합니다.

일반 규칙:

  • 달리 명시되지 않는 한, 피연산자 중 하나가 NULL이면 모든 연산자가 NULL을 반환합니다.
  • 계산 결과가 오버플로인 경우 모든 연산자가 오류를 생성합니다.
  • 모든 부동 소수점 연산에서 +/-infNaN은 피연산자 중 하나가 +/-inf 또는 NaN일 때만 반환될 수 있습니다. 그 이외의 경우에는 오류가 반환됩니다.

연산자 우선순위

다음 표는 모든 Cloud 표준 SQL 연산자를 우선순위(즉, 문 내에서 평가되는 순서)대로 나열한 것입니다.

우선순위 연산자 입력 데이터 유형 이름 연산자 항
1 필드 액세스 연산자 JSON
STRUCT
필드 액세스 연산자 이항
  배열 아래 첨자 연산자 ARRAY 배열 위치. OFFSET 또는 ORDINAL과 함께 사용해야 함. ARRAY 함수 참조. 이항
  JSON 아래 첨자 연산자 JSON JSON의 필드 이름 또는 배열 위치 이항
2 + 모든 숫자 유형 단항 덧셈 단항
  - 모든 숫자 유형 단항 뺄셈 단항
  ~ 정수 또는 BYTES 비트 NOT 단항
3 * 모든 숫자 유형 곱셈 이항
  / 모든 숫자 유형 나눗셈 이항
  || STRING, BYTES, ARRAY<T> 연결 연산자 이항
4 + 모든 숫자 유형 덧셈 이항
  - 모든 숫자 유형 뺄셈 이항
5 << 정수 또는 BYTES 비트 왼쪽 시프트 이항
  >> 정수 또는 BYTES 비트 오른쪽 시프트 이항
6 & 정수 또는 BYTES 비트 AND 이항
7 ^ 정수 또는 BYTES 비트 XOR 이항
8 | 정수 또는 BYTES 비트 OR 이항
9(비교 연산자) = 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. 같음 이항
  < 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. 미만 이항
  > 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. 초과 이항
  <= 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. 이하 이항
  >= 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. 이상 이항
  !=, <> 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. 같지 않음 이항
  [NOT] LIKE STRING 및 바이트 지정한 패턴과 일치하지 [않는] 값 이항
  [NOT] BETWEEN 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. 지정한 범위 내에 있지 [않은] 값 이항
  [NOT] IN 비교 가능한 모든 유형. 전체 목록은 데이터 유형을 참조하세요. 지정한 값의 집합에 있지 [않은] 값 이항
  IS [NOT] NULL 전체 값이 NULL이 [아님] 단항
  IS [NOT] TRUE BOOL 값이 TRUE가 [아님]. 단항
  IS [NOT] FALSE BOOL 값이 FALSE가 [아님]. 단항
10 NOT BOOL 논리 부정 단항
11 AND BOOL 논리곱 이항
12 OR BOOL 논리합 이항

우선순위가 같은 연산자는 결합된 상태로 유지됩니다. 즉, 이러한 연산자는 그룹화되어 왼쪽에서 시작해서 오른쪽으로 이동합니다. 예를 들어 표현식은 다음과 같습니다.

x AND y AND z

위 표현식의 해석 결과는 다음과 같습니다.

( ( x AND y ) AND z )

표현식:

x * y / z

위 표현식의 해석 결과는 다음과 같습니다.

( ( x * y ) / z )

모든 비교 연산자는 우선순위가 동일하지만 서로 연결되지 않습니다. 따라서 모호해지지 않도록 괄호를 사용해야 합니다. 예를 들면 다음과 같습니다.

(x < y) IS FALSE

필드 액세스 연산자

expression.fieldname[. ...]

설명

필드 값을 가져옵니다. 점 연산자라고도 합니다. 중첩 필드에 액세스하는 데 사용할 수 있습니다. 예를 들면 expression.fieldname1.fieldname2입니다.

입력 유형

  • STRUCT
  • JSON

반환 유형

  • STRUCT의 경우: fieldname의 SQL 데이터 유형입니다. 구조체에서 필드를 찾을 수 없으면 오류가 발생합니다.
  • JSON의 경우: JSON입니다. JSON 값에서 필드를 찾을 수 없으면 SQL NULL이 반환됩니다.

예시

다음 예시에서 표현식은 t.customer이고 필드 액세스 작업은 .address.country입니다. 작업은 연산자(.)를 특정 피연산자(이 경우 addresscountry, 더 구체적으로 말해 첫 번째 작업의 경우 t.customeraddress이고 두 번째 작업의 경우 t.customer.addresscountry)에 적용하는 것입니다.

WITH orders AS (
  SELECT STRUCT(STRUCT('Yonge Street' AS street, 'Canada' AS country) AS address) AS customer
)
SELECT t.customer.address.country FROM orders AS t;

+---------+
| country |
+---------+
| Canada  |
+---------+

배열 아래 첨자 연산자

array_expression[array_subscript_specifier]

array_subscript_specifier:
  position_keyword(index)

position_keyword:
  { OFFSET | SAFE_OFFSET | ORDINAL | SAFE_ORDINAL }

설명

특정 위치의 배열에서 값을 가져옵니다.

입력 유형

  • array_expression: 입력 배열입니다.
  • position_keyword: 배열의 색인을 시작해야 하는 위치와 범위를 벗어난 색인이 처리되는 방법입니다. 선택 가능한 옵션은 다음과 같습니다.
    • OFFSET: 색인은 0에서 시작됩니다. 색인이 범위를 벗어날 경우 오류가 발생합니다.
    • SAFE_OFFSET: 색인은 0에서 시작됩니다. 색인이 범위를 벗어날 경우 NULL를 반환합니다.
    • ORDINAL: 색인은 1부터 시작됩니다. 색인이 범위를 벗어날 경우 오류가 발생합니다.
    • SAFE_ORDINAL: 색인은 1부터 시작됩니다. 색인이 범위를 벗어날 경우 NULL를 반환합니다.
  • index: 배열의 특정 위치를 나타내는 정수입니다.

반환 유형

array_expressionARRAY<T>인 경우, T

예시

이 예시에서는 배열 하위 스크립트 연산자를 사용하여 item_array의 특정 위치에 값을 반환합니다. 이 예시에서는 범위를 벗어난 배열에서 색인(6)을 참조할 때 발생하는 일도 보여줍니다. SAFE 프리픽스가 포함되면 NULL이 반환되고 그렇지 않으면 오류가 발생합니다.

WITH Items AS (SELECT ["coffee", "tea", "milk"] AS item_array)
SELECT
  item_array,
  item_array[OFFSET(1)] AS item_offset,
  item_array[ORDINAL(1)] AS item_ordinal,
  item_array[SAFE_OFFSET(6)] AS item_safe_offset,
FROM Items

+----------------------------------+--------------+--------------+------------------+
| item_array                       | item_offset  | item_ordinal | item_safe_offset |
+----------------------------------+--------------+--------------+------------------+
| [coffee, tea, milk]              | tea          | coffee       | NULL             |
+----------------------------------+--------------+--------------+------------------+

다음 예시에서 범위를 벗어나고 SAFE 프리픽스가 포함되지 않은 배열에서 색인을 참조하면 오류가 발생합니다.

WITH Items AS (SELECT ["coffee", "tea", "milk"] AS item_array)
SELECT
  item_array[OFFSET(6)] AS item_offset
FROM Items

-- Error. OFFSET(6) is out of range.

JSON 아래 첨자 연산자

json_expression[array_element_id]
json_expression[field_name]

설명

JSON 표현식의 배열 요소 값 또는 필드 값을 가져옵니다. 중첩 데이터에 액세스하는 데 사용할 수 있습니다.

입력 유형

  • JSON expression: 반환할 배열 요소 또는 필드를 포함하는 JSON 표현식입니다.
  • [array_element_id]: 배열에서 0부터 시작하는 색인을 나타내는 INT64 표현식입니다. 음수 값을 입력하거나, 값이 배열의 크기 이상이거나, JSON 표현식이 JSON 배열을 나타내지 않으면 SQL NULL이 반환됩니다.
  • [field_name]: JSON에서 필드 이름을 나타내는 STRING 표현식입니다. 필드 이름을 찾을 수 없거나 JSON 표현식이 JSON 객체가 아니면 SQL NULL이 반환됩니다.

반환 유형

JSON

예시

다음 예시에서 $.class.students[0][name]에는 JSON 하위 스크립트 작업이 포함되어 있습니다. $.class.students은 JSON 표현식을 나타내고 [0]은 배열 요소 ID를 나타내고 [name]은 JSON의 필드 이름을 나타냅니다.

SELECT JSON_EXTRACT(json_text, '$.class.students[0][name]') AS first_student
FROM UNNEST([
  '{"class" : {"students" : [{"name" : "Jane"}]}}',
  '{"class" : {"students" : []}}',
  '{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'
  ]) AS json_text;

+-----------------+
| first_student   |
+-----------------+
| "Jane"          |
| NULL            |
| "John"          |
+-----------------+

산술 연산자

모든 산술 연산자는 숫자 유형 T의 입력을 허용하며 결과 유형은 아래의 설명에서 달리 명시하지 않는 한 유형 T에 해당합니다.

이름 구문
덧셈 X + Y
뺄셈 X - Y
곱셈 X * Y
나눗셈 X / Y
단항 덧셈 + X
단항 뺄셈 - X

참고: 0으로 나누는 연산은 오류를 반환합니다. 다른 결과를 반환하려면 IEEE_DIVIDE 또는 SAFE_DIVIDE 함수를 사용해 보세요.

덧셈과 곱셈의 결과 유형:

입력INT64NUMERICFLOAT64
INT64INT64NUMERICFLOAT64
NUMERICNUMERICNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64

나눗셈의 결과 유형:

입력INT64NUMERICFLOAT64
INT64FLOAT64NUMERICFLOAT64
NUMERICNUMERICNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64

단항 덧셈의 결과 유형:

입력INT64NUMERICFLOAT64
출력INT64NUMERICFLOAT64

단항 뺄셈의 결과 유형:

입력INT64NUMERICFLOAT64
출력INT64NUMERICFLOAT64

비트 연산자

모든 비트 연산자는 첫 번째 피연산자와 동일한 유형과 동일한 길이를 반환합니다.

이름 구문 입력 데이터 유형 설명
비트 NOT ~ X 정수 또는 BYTES 각 비트에 대해 논리 부정을 수행하며 주어진 2진수 값의 여집합을 형성합니다.
비트 OR X | Y X: 정수 또는 BYTES
Y: X와 동일한 유형
길이가 같은 비트 패턴 두 개를 취하며 해당 비트의 각 쌍에 포괄적 논리합 연산을 수행합니다. 이 연산자는 X와 Y의 BYTES 길이가 다른 경우 오류를 생성합니다.
비트 XOR X ^ Y X: 정수 또는 BYTES
Y: X와 동일한 유형
길이가 같은 비트 패턴 두 개를 취하며 해당 비트의 각 쌍에 배타적 논리합 연산을 수행합니다. 이 연산자는 X와 Y의 BYTES 길이가 다른 경우 오류를 생성합니다.
비트 AND X & Y X: 정수 또는 BYTES
Y: X와 동일한 유형
길이가 같은 비트 패턴 두 개를 취하며 해당 비트의 각 쌍에 논리곱 연산을 수행합니다. 이 연산자는 X와 Y의 BYTES 길이가 다른 경우 오류를 생성합니다.
왼쪽 시프트 X << Y X: 정수 또는 BYTES
Y: INT64
첫 번째 피연산자 X를 왼쪽으로 옮깁니다. 이 연산자는 두 번째 피연산자 Y가 첫 번째 피연산자 X의 비트 길이보다 크거나 같으면 0 또는 바이트 시퀀스 b'\x00'을 반환합니다(예: X에 유형 INT64가 있으면 64). 이 연산자는 Y가 음수이면 오류를 생성합니다.
오른쪽 시프트 X >> Y X: 정수 또는 BYTES
Y: INT64
첫 번째 피연산자 X를 오른쪽으로 옮깁니다. 이 연산자는 부호가 있는 유형으로 부호 비트 확장을 수행하지 않습니다(즉, 왼쪽에 비어 있는 비트를 0으로 채움). 이 연산자는 두 번째 피연산자 Y가 첫 번째 피연산자 X의 비트 길이보다 크거나 같으면 0 또는 바이트 시퀀스 b'\x00'을 반환합니다(예: X에 유형 INT64가 있으면 64). 이 연산자는 Y가 음수이면 오류를 생성합니다.

논리 연산자

Google 표준 SQL은 AND, OR, NOT 논리 연산자를 지원합니다. 논리 연산자는 BOOL 또는 NULL 입력만 허용하고 3가 논리를 사용하여 결과를 생성합니다. 결과는 TRUE, FALSE, 또는 NULL일 수 있습니다.

x y x AND y x OR y
TRUE TRUE TRUE TRUE
TRUE FALSE FALSE TRUE
TRUE NULL NULL TRUE
FALSE TRUE FALSE TRUE
FALSE FALSE FALSE FALSE
FALSE NULL FALSE NULL
NULL TRUE NULL TRUE
NULL FALSE FALSE NULL
NULL NULL NULL NULL
x NOT x
TRUE FALSE
FALSE TRUE
NULL NULL

예시

이 섹션의 예시는 entry_table이라는 테이블을 참조합니다.

+-------+
| entry |
+-------+
| a     |
| b     |
| c     |
| NULL  |
+-------+
SELECT 'a' FROM entry_table WHERE entry = 'a'

-- a => 'a' = 'a' => TRUE
-- b => 'b' = 'a' => FALSE
-- NULL => NULL = 'a' => NULL

+-------+
| entry |
+-------+
| a     |
+-------+
SELECT entry FROM entry_table WHERE NOT (entry = 'a')

-- a => NOT('a' = 'a') => NOT(TRUE) => FALSE
-- b => NOT('b' = 'a') => NOT(FALSE) => TRUE
-- NULL => NOT(NULL = 'a') => NOT(NULL) => NULL

+-------+
| entry |
+-------+
| b     |
| c     |
+-------+
SELECT entry FROM entry_table WHERE entry IS NULL

-- a => 'a' IS NULL => FALSE
-- b => 'b' IS NULL => FALSE
-- NULL => NULL IS NULL => TRUE

+-------+
| entry |
+-------+
| NULL  |
+-------+

비교 연산자

비교는 항상 BOOL을 반환합니다. 비교를 하려면 일반적으로 두 피연산자가 같은 유형이어야 합니다. 피연산자 유형이 다르고 Cloud 표준 SQL이 정밀도를 유지하면서 유형 값을 공통 유형으로 변환할 수 있는 경우 Cloud 표준 SQL은 일반적으로 비교를 위해 값을 공통 유형으로 강제 변환합니다. Cloud 표준 SQL은 일반적으로 리터럴을 비리터럴 유형으로 강제 변환합니다(있는 경우). 비교할 수 있는 데이터 유형은 데이터 유형에 정의되어 있습니다.

STRUCT는 같음(=), 같지 않음(!= 및 <>), IN과 같은 4가지 비교 연산자만 지원합니다.

이러한 데이터 유형을 비교할 때는 다음 규칙이 적용됩니다.

  • FLOAT64: NaN이 포함된 모든 비교는 FALSE를 반환합니다. 단, !=<>은 TRUE를 반환합니다.
  • BOOL: FALSE가 TRUE보다 작습니다.
  • STRING: 코드 포인트별로 문자열을 비교합니다. 즉, 규범적 등가 문자열은 먼저 정규화된 경우에 한해 비교 결과가 같음으로 보장됩니다.
  • NULL: 이 경우에는 입력이 NULL인 모든 연산은 NULL을 반환한다는 규칙이 적용됩니다.
이름 구문 설명
미만 X < Y X가 Y보다 작으면 TRUE를 반환합니다.
이하 X <= Y X가 Y보다 작거나 같으면 TRUE를 반환합니다.
초과 X > Y X가 Y보다 크면 TRUE를 반환합니다.
이상 X >= Y X가 Y보다 크거나 같으면 TRUE를 반환합니다.
같음 X = Y X가 Y와 같으면 TRUE를 반환합니다.
같지 않음 X != Y
X <> Y
X가 Y와 같지 않으면 TRUE를 반환합니다.
BETWEEN X [NOT] BETWEEN Y AND Z

X가 지정한 범위 내에 있지 [않으면] TRUE를 반환합니다. 'X BETWEEN Y AND Z'의 결과는 'Y <= X AND X <= Z'와 같지만 전자의 경우 X가 한 번만 평가됩니다.

LIKE X [NOT] LIKE Y 첫 번째 피연산자 X의 STRING이 두 번째 피연산자 Y에서 지정한 패턴과 일치하는지 확인합니다. 표현식에 다음과 같은 문자를 포함할 수 있습니다.
  • 퍼센트 기호 '%'는 임의의 수의 문자나 바이트와 일치합니다.
  • 밑줄 '_'은 하나의 문자나 바이트와 일치합니다.
  • 백슬래시 두 개를 사용하여 '\', '_' 또는 '%'를 이스케이프 처리할 수 있습니다. 예를 들면 "\\%"입니다. 원시 문자열을 사용할 경우 백슬래시 한 개만 필요합니다(예: 예를 들면 r"\%"입니다.
IN 다양함 - 아래 참조 오른쪽 피연산자가 비어 있으면 FALSE를 반환합니다. 왼쪽 피연산자가 NULL이면 NULL을 반환합니다. 오른쪽 피연산자에 NULL이 포함되어 있으면 TRUE 또는 NULL을 반환하고 절대 FALSE를 반환하지 않습니다. IN의 양쪽에 있는 인수는 일반적인 표현식입니다. 어느 쪽 피연산자도 리터럴일 필요는 없지만 오른쪽에 리터럴을 사용하는 것이 가장 일반적입니다. X는 한 번만 평가됩니다.

STRUCT 데이터 유형의 값이 서로 같은지 테스트할 때, 하나 이상의 필드가 NULL인 경우가 있습니다. 이 경우,

  • NULL이 아닌 모든 필드 값이 같다면 비교 후 NULL이 반환됩니다.
  • NULL이 아닌 필드 값이 같지 않다면 비교 후 false가 반환됩니다.

아래 표는 NULL 값의 필드를 가진 STRUCT 데이터 유형이 어떻게 비교되는지 보여줍니다.

Struct1 Struct2 Struct1 = Struct2
STRUCT(1, NULL) STRUCT(1, NULL) NULL
STRUCT(1, NULL) STRUCT(2, NULL) FALSE
STRUCT(1,2) STRUCT(1, NULL) NULL

IN 연산자

IN 연산자는 다음 구문을 지원합니다.

search_value [NOT] IN value_set

value_set:
  {
    (expression[, ...])
    | (subquery)
    | UNNEST(array_expression)
  }

설명

값 집합에서 동일 값을 확인합니다. 시맨틱스 규칙이 적용되지만 일반적으로 동일 값이 발견되면 INTRUE를 반환하고, 동일 값이 제외되었으면 FALSE를 반환하고, 그렇지 않으면 NULL을 반환합니다. NOT IN은 동일 값이 발견되면 FALSE를 반환하고, 동일 값이 제외되었으면 TRUE를 반환하고, 그렇지 않으면 NULL을 반환합니다.

  • search_value: 값 집합과 비교되는 표현식입니다.
  • value_set: 검색과 비교할 하나 이상의 값입니다.

    • (expression[, ...]): 표현식 목록입니다.
    • (subquery): 단일 열을 반환하는 서브 쿼리입니다. 해당 열의 값은 값 집합입니다. 행이 생성되지 않으면 값 집합이 비어 있는 것입니다.
    • UNNEST(array_expression): 배열 표현식에서 값 열을 반환하는 UNNEST 연산자입니다. 이는 다음과 동일합니다.

      IN (SELECT element FROM UNNEST(array_expression) AS element)
      

시맨틱스 규칙

IN 연산자를 사용하는 경우 다음 시맨틱스가 이 순서대로 적용됩니다.

  • value_set가 비어 있으면 FALSE를 반환합니다.
  • search_valueNULL인 경우 NULL를 반환합니다.
  • value_setsearch_value와 같은 값이 있으면 TRUE를 반환합니다.
  • value_setNULL이 포함되어 있으면 NULL을 반환합니다.
  • FALSE를 반환합니다.

NOT IN 연산자를 사용하는 경우 다음 시맨틱스가 이 순서대로 적용됩니다.

  • value_set가 비어 있으면 TRUE를 반환합니다.
  • search_valueNULL인 경우 NULL를 반환합니다.
  • value_setsearch_value와 같은 값이 있으면 FALSE를 반환합니다.
  • value_setNULL이 포함되어 있으면 NULL을 반환합니다.
  • TRUE를 반환합니다.

다음 구문의 시맨틱스는

x IN (y, z, ...)

다음과 동일한 것으로 정의되며

(x = y) OR (x = z) OR ...

서브 쿼리와 배열 형식은 유사하게 정의됩니다.

x NOT IN ...

이 값은 다음과 동일합니다.

NOT(x IN ...)

UNNEST 형식은 배열 스캔을 FROM 절의 UNNEST처럼 취급합니다.

x [NOT] IN UNNEST(<array expression>)

이 형식은 ARRAY 매개변수와 함께 사용되는 경우가 많습니다. 예를 들면 다음과 같습니다.

x IN UNNEST(@array_parameter)

이 구문을 사용하는 방법에 대한 자세한 내용은 배열 주제를 참조하세요.

구조체 생성자 구문을 사용하여 IN을 멀티 파트 키와 함께 사용할 수 있습니다. 예를 들면 다음과 같습니다.

(Key1, Key2) IN ( (12,34), (56,78) )
(Key1, Key2) IN ( SELECT (table.a, table.b) FROM table )

자세한 내용은 구조체 유형을 참조하세요.

반환 데이터 유형

BOOL

예시

다음 예시에서 이러한 WITH 절을 사용하여 WordsItems에 대해 임시 테이블을 에뮬레이션할 수 있습니다.

WITH Words AS (
  SELECT 'Intend' as value UNION ALL
  SELECT 'Secure' UNION ALL
  SELECT 'Clarity' UNION ALL
  SELECT 'Peace' UNION ALL
  SELECT 'Intend'
 )
SELECT * FROM Words;

+----------+
| value    |
+----------+
| Intend   |
| Secure   |
| Clarity  |
| Peace    |
| Intend   |
+----------+
WITH
  Items AS (
    SELECT STRUCT('blue' AS color, 'round' AS shape) AS info UNION ALL
    SELECT STRUCT('blue', 'square') UNION ALL
    SELECT STRUCT('red', 'round')
  )
SELECT * FROM Items;

+----------------------------+
| info                       |
+----------------------------+
| {blue color, round shape}  |
| {blue color, square shape} |
| {red color, round shape}   |
+----------------------------+

IN 및 표현식 예시:

SELECT * FROM Words WHERE value IN ('Intend', 'Secure');

+----------+
| value    |
+----------+
| Intend   |
| Secure   |
| Intend   |
+----------+

NOT IN 및 표현식 예시:

SELECT * FROM Words WHERE value NOT IN ('Intend');

+----------+
| value    |
+----------+
| Secure   |
| Clarity  |
+----------+

IN, 스칼라 서브 쿼리, 표현식의 예시:

SELECT * FROM Words WHERE value IN ((SELECT 'Intend'), 'Clarity');

+----------+
| value    |
+----------+
| Intend   |
| Clarity  |
| Intend   |
+----------+

INUNNEST 작업의 예시:

SELECT * FROM Words WHERE value IN UNNEST(['Secure', 'Clarity']);

+----------+
| value    |
+----------+
| Secure   |
| Clarity  |
+----------+

INSTRUCT 예시:

SELECT
  (SELECT AS STRUCT Items.info) as item
FROM
  Items
WHERE (info.shape, info.color) IN (('round', 'blue'));

+------------------------------------+
| item                               |
+------------------------------------+
| { {blue color, round shape} info } |
+------------------------------------+

IS 연산자

IS 연산자는 테스트하는 조건에 대해 TRUE 또는 FALSE를 반환합니다. 이 연산자는 수학 함수에서 정의된 IS_INF 및 IS_NAN 함수와 달리 입력이 NULL이어도 절대로 NULL을 반환하지 않습니다. NOT이 있으면 출력 BOOL 값이 반전됩니다.

함수 구문 입력 데이터 유형 결과 데이터 유형 설명

X IS [NOT] NULL
모든 값 유형 BOOL 피연산자 X가 NULL로 평가될 경우 TRUE를 반환하고, 그렇지 않은 경우 FALSE를 반환합니다.

X IS [NOT] TRUE
BOOL BOOL BOOL 피연산자가 TRUE로 평가될 경우 TRUE를 반환하고 그렇지 않은 경우 FALSE를 반환합니다.

X IS [NOT] FALSE
BOOL BOOL BOOL 피연산자가 FALSE로 평가될 경우 TRUE를 반환하고 그렇지 않은 경우 FALSE를 반환합니다.

연결 연산자

연결 연산자는 여러 값을 하나로 연결합니다.

함수 구문 입력 데이터 유형 결과 데이터 유형

STRING || STRING [ || ... ]
STRING STRING

BYTES || BYTES [ || ... ]
BYTES STRING

ARRAY<T> || ARRAY<T> [ || ... ]
ARRAY<T> ARRAY<T>