문자열 함수

이 문자열 함수는 STRINGBYTES 데이터 유형이라는 두 가지 값에 작동합니다. STRING 값은 올바르게 구성된 UTF-8이어야 합니다.

STRPOS와 같은 위치 값을 반환하는 함수는 이러한 위치를 INT64로 인코딩합니다. 값 1은 첫 번째 문자(또는 바이트)를 나타내고 2는 두 번째 문자를 나타냅니다. 값 0은 잘못된 색인을 나타냅니다. STRING 유형에서 작동하는 경우 반환되는 위치는 문자 위치를 나타냅니다.

모든 문자열 비교는 유니코드 규범적 등가와 관계없이 바이트 단위로 수행됩니다.

BYTE_LENGTH

BYTE_LENGTH(value)

설명

값 유형이 STRING이나 BYTES에 관계없이 STRING 또는 BYTES 값의 길이를 BYTES 단위로 반환합니다.

반환 유형

INT64

예시

WITH example AS
  (SELECT "абвгд" AS characters, b"абвгд" AS bytes)

SELECT
  characters,
  BYTE_LENGTH(characters) AS string_example,
  bytes,
  BYTE_LENGTH(bytes) AS bytes_example
FROM example;

+------------+----------------+-------+---------------+
| characters | string_example | bytes | bytes_example |
+------------+----------------+-------+---------------+
| абвгд      | 10             | абвгд | 10            |
+------------+----------------+-------+---------------+

CHAR_LENGTH

CHAR_LENGTH(value)

설명

STRING의 길이를 문자 단위로 반환합니다.

반환 유형

INT64

예시

WITH example AS
  (SELECT "абвгд" AS characters)

SELECT
  characters,
  CHAR_LENGTH(characters) AS char_length_example
FROM example;

+------------+---------------------+
| characters | char_length_example |
+------------+---------------------+
| абвгд      |                   5 |
+------------+---------------------+

CHARACTER_LENGTH

CHARACTER_LENGTH(value)

설명

CHAR_LENGTH의 동의어입니다.

반환 유형

INT64

예시

WITH example AS
  (SELECT "абвгд" AS characters)

SELECT
  characters,
  CHARACTER_LENGTH(characters) AS char_length_example
FROM example;

+------------+---------------------+
| characters | char_length_example |
+------------+---------------------+
| абвгд      |                   5 |
+------------+---------------------+

CODE_POINTS_TO_BYTES

CODE_POINTS_TO_BYTES(ascii_values)

설명

확장된 ASCII 코드 포인트의 배열(INT64ARRAY)을 사용하여 BYTES를 반환합니다.

BYTES를 코드 포인트의 배열로 변환하려면 TO_CODE_POINTS를 참조하세요.

반환 유형

BYTES

예시

다음은 CODE_POINTS_TO_BYTES를 사용하는 기본적인 예시입니다.

SELECT CODE_POINTS_TO_BYTES([65, 98, 67, 100]) AS bytes;

-- Note that the result of CODE_POINTS_TO_BYTES is of type BYTES, displayed as a base64-encoded string.
-- In BYTES format, b'AbCd' is the result.
+----------+
| bytes    |
+----------+
| QWJDZA== |
+----------+

다음 예시에서는 ROT13(rotate-by-13 places) 알고리즘을 사용하여 문자열을 인코딩합니다.

SELECT CODE_POINTS_TO_BYTES(ARRAY(
  (SELECT
      CASE
        WHEN chr BETWEEN b'a' AND b'z'
          THEN TO_CODE_POINTS(b'a')[offset(0)] +
            MOD(code + 13 - TO_CODE_POINTS(b'a')[offset(0)],26)
        WHEN chr BETWEEN b'A' AND b'Z'
          THEN TO_CODE_POINTS(b'A')[offset(0)] +
            MOD(code + 13 - TO_CODE_POINTS(b'A')[offset(0)],26)
        ELSE code
      END
   FROM
     (SELECT code, CODE_POINTS_TO_BYTES(ARRAY[code]) AS chr
      FROM UNNEST(TO_CODE_POINTS(input)) AS code WITH OFFSET
      ORDER BY OFFSET)
   ))) AS encoded_string
FROM UNNEST(ARRAY['Test String!']) AS input;

-- Note that the result of CODE_POINTS_TO_BYTES is of type BYTES, displayed as a base64-encoded string.
-- In BYTES format, b'Grfg Fgevat!' is the result.
+------------------+
| encoded_string   |
+------------------+
| R3JmZyBGZ2V2YXQh |
+------------------+

CODE_POINTS_TO_STRING

CODE_POINTS_TO_STRING(value)

설명

유니코드 코드 포인트의 배열(INT64ARRAY)을 사용하여 STRING을 반환합니다. 코드 포인트가 0이면 STRING에 코드 문자를 반환하지 않습니다.

문자열을 코드 포인트의 배열로 변환하려면 TO_CODE_POINTS를 참조하세요.

반환 유형

STRING

예시

다음은 CODE_POINTS_TO_STRING을 사용하는 기본 예시입니다.

SELECT CODE_POINTS_TO_STRING([65, 255, 513, 1024]) AS string;

+--------+
| string |
+--------+
| AÿȁЀ   |
+--------+
SELECT CODE_POINTS_TO_STRING([97, 0, 0xF9B5]) AS string;

+--------+
| string |
+--------+
| a例    |
+--------+
SELECT CODE_POINTS_TO_STRING([65, 255, NULL, 1024]) AS string;

+--------+
| string |
+--------+
| NULL   |
+--------+

다음 예시는 단어 집합에서 문자 빈도 수를 계산합니다.

WITH Words AS (
  SELECT word
  FROM UNNEST(['foo', 'bar', 'baz', 'giraffe', 'llama']) AS word
)
SELECT
  CODE_POINTS_TO_STRING([code_point]) AS letter,
  COUNT(*) AS letter_count
FROM Words,
  UNNEST(TO_CODE_POINTS(word)) AS code_point
GROUP BY 1
ORDER BY 2 DESC;

+--------+--------------+
| letter | letter_count |
+--------+--------------+
| a      | 5            |
| f      | 3            |
| r      | 2            |
| b      | 2            |
| l      | 2            |
| o      | 2            |
| g      | 1            |
| z      | 1            |
| e      | 1            |
| m      | 1            |
| i      | 1            |
+--------+--------------+

CONCAT

CONCAT(value1[, ...])

설명

하나 이상의 STRING 또는 BYTE 값을 하나의 결과로 연결합니다.

입력 인수가 NULL이면 이 함수는 NULL을 반환합니다.

반환 유형

STRING 또는 BYTES

예시

SELECT CONCAT("T.P.", " ", "Bar") as author;

+---------------------+
| author              |
+---------------------+
| T.P. Bar            |
+---------------------+

With Employees AS
  (SELECT
    "John" AS first_name,
    "Doe" AS last_name
  UNION ALL
  SELECT
    "Jane" AS first_name,
    "Smith" AS last_name
  UNION ALL
  SELECT
    "Joe" AS first_name,
    "Jackson" AS last_name)

SELECT
  CONCAT(first_name, " ", last_name)
  AS full_name
FROM Employees;

+---------------------+
| full_name           |
+---------------------+
| John Doe            |
| Jane Smith          |
| Joe Jackson         |
+---------------------+

ENDS_WITH

ENDS_WITH(value1, value2)

설명

STRING 또는 BYTES 값 두 개를 사용합니다. 두 번째 값이 첫 번째 값의 서픽스이면 TRUE를 반환합니다.

반환 유형

BOOL

예시

WITH items AS
  (SELECT "apple" as item
  UNION ALL
  SELECT "banana" as item
  UNION ALL
  SELECT "orange" as item)

SELECT
  ENDS_WITH(item, "e") as example
FROM items;

+---------+
| example |
+---------+
|    True |
|   False |
|    True |
+---------+

FORMAT

Cloud Spanner SQL은 문자열 형식 지정을 위한 FORMAT() 함수를 지원합니다. 이 함수는 C printf 함수와 비슷합니다. 이 함수는 형식 지정자가 0개 이상 포함된 형식 문자열에서 형식 지정자와 일치하는 추가 인수의 가변 길이 목록과 함께 STRING을 생성합니다. 예를 들면 다음과 같습니다.

설명 결과
단순 정수 FORMAT('%d', 10) 10
왼쪽 공백 패딩이 있는 정수 FORMAT('|%10d|', 11) |           11|
왼쪽 0 패딩이 있는 정수 FORMAT('+%010d+', 12) +0000000012+
쉼표가 있는 정수 FORMAT('%'d', 123456789) 123,456,789
STRING FORMAT('-%s-', 'abcd efg') -abcd efg-
FLOAT64 FORMAT('%f %E', 1.1, 2.2) 1.100000 2.200000E+00
DATE FORMAT('%t', date '2015-09-01') 2015-09-01
TIMESTAMP FORMAT('%t', timestamp '2015-09-01 12:34:56 America/Los_Angeles') 2015‑09‑01 19:34:56+00

FORMAT() 함수는 모든 유형과 값의 완전한 커스텀 설정이 가능한 형식 지정을 제공하지 않을 뿐 아니라 언어를 구분하는 형식 지정도 제공하지 않습니다.

유형에 커스텀 형식 지정이 필요하면 먼저 FORMAT_DATE() 또는 FORMAT_TIMESTAMP() 같은 유형별 형식 함수를 사용하여 형식을 지정해야 합니다. 예를 들면 다음과 같습니다.

SELECT FORMAT("date: %s!", FORMAT_DATE("%B %d, %Y", date '2015-01-02'));

반환

date: January 02, 2015!

구문

FORMAT() 구문은 형식 문자열과 인수의 가변 길이 목록을 사용하여 STRING 결과를 생성합니다.

FORMAT(format_string, ...)

format_string 표현식에는 형식 지정자가 0개 이상 포함될 수 있습니다. 각 형식 지정자는 % 기호로 도입되며 하나 이상의 나머지 인수에 매핑되어야 합니다. 대부분의 경우, * 지정자가 있는 경우를 제외하고 일대일 매핑입니다. 예를 들어 %.*i는 2개의 인수, 즉 길이 인수와 부호가 있는 정수 인수에 매핑됩니다. 형식 지정자와 관련된 인수의 수가 인수의 수와 다르면 오류가 발생합니다.

지원되는 형식 지정자

FORMAT() 함수 형식 지정자는 다음 프로토타입 다음에 옵니다.

%[flags][width][.precision]specifier

지원되는 형식 지정자는 아래 표에 나와 있습니다. printf()의 편차는 기울임꼴로 되어 있습니다.

지정자 설명 예시 유형
d 또는 i 10진수 392 INT64
o 8진수 610
INT64*
x 16진수 7fa
INT64*
X 16진수(대문자) 7FA
INT64*
f 10진수 표기법, 유한한 값의 경우 [-](정수 부분).(소수 부분), 유한하지 않은 값의 경우 소문자 392.650000
inf
nan
NUMERIC
FLOAT64
F 10진수 표기법, 유한한 값의 경우 [-](정수 부분).(소수 부분), 유한하지 않은 값의 경우 대문자 392.650000
INF
NAN
NUMERIC
FLOAT64
e 과학적 표기법(가수/지수), 소문자 3.926500e+02
inf
nan
NUMERIC
FLOAT64
E 과학적 표기법(가수/지수), 대문자 3.926500E+02
INF
NAN
NUMERIC
FLOAT64
g 입력 값의 지수와 지정된 정밀도에 따라 소수점 표기법 또는 과학적 표기법을 선택합니다. 소문자입니다. 자세한 내용은 %g 및 %G 동작을 참조하세요. 392.65
3.9265e+07
inf
nan
NUMERIC
FLOAT64
G 입력 값 지수와 지정된 정밀도에 따라 소수점 표기법이나 과학적 표기법을 선택합니다. 대문자입니다. 자세한 내용은 %g 및 %G 동작을 참조하세요. 392.65
3.9265E+07
INF
NAN
NUMERIC
FLOAT64
s 문자의 문자열 sample STRING
t 값을 나타내는 출력 가능한 문자열을 반환합니다. 인수를 STRING으로 Cast 변환과 유사하게 보이는 경우가 많습니다. %t 및 %T 동작을 참조하세요. 샘플
2014‑01‑01
<any>
T 값의 유형과 비슷한 유형의 유효한 Cloud Spanner SQL 상수인 문자열을 생성합니다(더 넓거나 문자열일 수 있음). %t 및 %T 동작을 참조하세요. 'sample'
b'bytes sample'
1234
2.3
date '2014‑01‑01'
<any>
% '%%'는 단일 '%'를 생성합니다. % 해당 사항 없음

*음수 값이 사용되면 %o, %x, %X 지정자에서 오류가 발생합니다.

형식 지정자는 위 지정자 프로토타입에서 식별된 하위 지정자를 선택적으로 포함할 수 있습니다.

이러한 하위 지정자는 다음 사양을 준수해야 합니다.

플래그
플래그 설명
- 지정된 필드 너비 내에서 왼쪽 정렬. 오른쪽 정렬이 기본값입니다(너비 하위 지정자 참조).
+ 양수이더라도 결과 앞에 플러스 또는 마이너스 부호(+ 또는 -)를 강제로 배치합니다. 기본적으로 음수 앞에만 - 부호가 있습니다.
<space> 부호를 쓰지 않으려면 값 앞에 빈 공백을 삽입합니다.
#
  • `%o`, `%x`,`%X`의 경우, 이 플래그는 0이 아닌 값에 대해 값 앞에 각각 0, 0x 또는 0X가 온다는 것을 의미합니다.
  • `%f`, `%F`, `%e`,`%E`의 경우, 이 플래그는 유한하지 않은 값이 아니면 소수 부분이 없을 때도 소수점을 추가한다는 것을 의미합니다.
  • `%g`, `%G`의 경우 이 플래그는 유한하지 않은 값이 아니면 소수 부분이 없더라도 소수점을 추가하고 소수점 이하 후행 0을 삭제하지 않음을 의미합니다.
0 패딩이 지정되면 공백 대신 0으로 숫자를 왼쪽으로 패딩합니다(너비 하위 지정자 참조).
'

적절한 그룹화 문자를 사용하여 정수 형식을 지정합니다. 예를 들면 다음과 같습니다.

  • FORMAT("%'d", 12345678)12,345,678을 반환합니다.
  • FORMAT("%'x", 12345678)bc:614e을 반환합니다.
  • FORMAT("%'o", 55555)15,4403을 반환합니다.
  • 이 플래그는 10진수, 16진수, 8진수 값에만 관련됩니다.

플래그는 순서에 상관없이 지정할 수 있습니다. 중복 플래그는 오류가 아닙니다. 일부 요소 유형과 관련이 없는 플래그는 무시됩니다.

너비
너비 설명
<number> 출력할 최소 문자 수입니다. 출력할 값이 이 숫자보다 짧으면 결과가 빈 공백으로 패딩됩니다. 결과가 더 크더라도 값은 잘리지 않습니다.
* 너비가 형식 문자열에서 지정되지 않고 형식을 지정해야 하는 인수 앞에 오는 추가 정수 값 인수로 지정됩니다.
정밀도
정밀도 설명
.<number>
  • 정수 지정자 `%d`, `%i`, `%o`, `%u`, `%x`, `%X`의 경우: 정밀도는 작성할 최소 자릿수를 지정합니다. 작성할 할 값이 이 숫자보다 짧으면 결과는 후행 0으로 패딩됩니다. 결과가 더 길더라도 값은 잘리지 않습니다. 정밀도가 0이면 0 값에 작성되는 문자가 없음을 의미합니다.
  • 지정자 `%a`, `%A`, `%e`, `%E`, `%f`, `%F`의 경우: 소수점 뒤에 표시되는 자릿수입니다. 기본값은 6입니다.
  • 지정자 `%g` 및 `%G`의 경우: 소수점 이하 후행 0을 삭제하기 전에 표시되는 유효 자릿수입니다. 기본값은 6입니다.
.* 정밀도는 형식 문자열에서 지정되지 않고 형식을 지정해야 하는 인수 앞에 오는 추가 정수 값 인수로 지정됩니다.

%g 및 %G 동작

%g%G 형식 지정자는 입력 값의 지수와 지정된 정밀도에 따라 10진수 표기법(예: %f%F 지정자) 또는 과학적 표기법(예: %e%E 지정자)을 선택합니다.

p는 지정된 정밀도를 의미합니다(기본값은 6, 지정된 정밀도가 1보다 작으면 1). 입력 값은 먼저 정밀도가 (p - 1)인 과학적 표기법으로 변환됩니다. 결과 지수 부분 x가 -4보다 작거나 p보다 작지 않으면 정밀도가 (p - 1)인 과학적 표기법이 사용됩니다. 그렇지 않은 경우 정밀도가 (p - 1 - x)인 10진수 표기법이 사용됩니다.

# 플래그가 없으면 소수점 이하 후행 0은 삭제되고 그 뒤에 남은 자릿수가 없는 경우 소수점도 삭제됩니다.

%t 및 %T 동작

%t%T 형식 지정자는 모든 유형에 정의됩니다. 너비, 정밀도, 플래그%s에 동작하는 것처럼 동작합니다. 너비는 최소 너비이고 STRING은 이 크기로 패딩됩니다. 정밀도는 표시할 콘텐츠의 최대 너비이고 STRING은 너비로 패딩되기 전에 이 크기로 잘립니다.

%t 지정자는 항상 읽을 수 있는 값 형식이어야 합니다.

%T 지정자는 항상 더 넓은 숫자 유형과 같은 비슷한 유형의 유효한 SQL 리터럴입니다. 유한하지 않은 부동 소수점 값의 특수한 경우를 제외하고 리터럴에는 변환 또는 유형 이름이 포함되지 않습니다.

STRING 형식은 다음과 같습니다.

유형 %t %T
모든 유형의 NULL NULL NULL
INT64
123 123
NUMERIC 123.0(항상 .0 포함)NUMERIC "123.0"
FLOAT64 123.0 (항상 .0 포함)
123e+10
inf
-inf
NaN
123.0 (항상 .0 포함)
123e+10
CAST("inf" AS <type>)
CAST("-inf" AS <type>)
CAST("nan" AS <type>)
STRING 따옴표 없는 문자열 값 따옴표 붙은 문자열 리터럴
BYTES 따옴표가 없는 이스케이프 처리된 바이트
예: abc\x01\x02
따옴표가 있는 바이트 리터럴
예: b"abc\x01\x02"
DATE 2011-02-03 DATE "2011-02-03"
TIMESTAMP 2011-02-03 04:05:06+00 TIMESTAMP "2011-02-03 04:05:06+00"
ARRAY [value, value, ...]
여기서 값은 %t로 형식 지정됩니다.
[value, value, ...]
여기서 값은 %T로 형식 지정됩니다.

오류 조건

형식 지정자가 유효하지 않거나 관련 인수 유형과 호환되지 않거나 잘못된 숫자 또는 인수가 제공되는 경우 오류가 생성됩니다. 예를 들어 다음 <format_string> 표현식은 유효하지 않습니다.

FORMAT('%s', 1)
FORMAT('%')

NULL 인수 처리

NULL 형식 문자열에서 NULL 출력 STRING이 생성됩니다. 이 경우 다른 모든 인수는 무시됩니다.

함수는 NULL 인수가 있으면 일반적으로 NULL 값을 생성합니다. 예를 들어 FORMAT('%i', NULL_expression)NULL STRING을 출력으로 생성합니다.

하지만 몇 가지 예외가 있습니다. 형식 지정자가 %t 또는 %T(둘 다 CAST와 리터럴 값 시맨틱스를 효과적으로 일치시키는 STRING 생성)이면 NULL 값은 결과 STRING에서 'NULL'(따옴표 없음)을 생성합니다. 다음 함수를 예로 들겠습니다.

FORMAT('00-%t-00', NULL_expression);

반환

00-NULL-00

추가 시맨틱 규칙

FLOAT64 값은 +/-inf이거나 NaN일 수 있습니다. 인수에 이 값 중 하나가 있으면 형식 지정자 %f, %F, %e, %E, %g, %G, %t의 결과는 적절한 inf, -inf 또는 nan(또는 대문자로 된 동일한 결과)입니다. 이는 Cloud Spanner SQL이 이러한 값을 STRING으로 변환하는 방법에 부합합니다. %T의 경우 Cloud Spanner SQL은 문자열이 아닌 리터럴 표현이 없는 FLOAT64 값에 대해 따옴표 붙은 문자열을 반환합니다.

FROM_BASE32

FROM_BASE32(string_expr)

설명

base32로 인코딩된 입력 string_exprBYTES 형식으로 변환합니다. BYTES를 base32로 인코딩된 STRING으로 변환하려면 TO_BASE32를 사용합니다.

반환 유형

BYTES

예시

SELECT FROM_BASE32('MFRGGZDF74======') AS byte_data;

-- Note that the result of FROM_BASE32 is of type BYTES, displayed as a base64-encoded string.
+-----------+
| byte_data |
+-----------+
| YWJjZGX/  |
+-----------+

FROM_BASE64

FROM_BASE64(string_expr)

설명

base64로 인코딩된 입력 string_exprBYTES 형식으로 변환합니다. BYTES를 base64로 인코딩된 STRING으로 변환하려면 TO_BASE64를 사용합니다.

64자리와 패딩을 인코딩하는 데 사용되는 ASCII 알파벳 65자와 완전히 다른 일반적으로 사용되는 base64 인코딩이 여러 개 있습니다. 자세한 내용은 RFC 4648을 참조하세요. 이 함수는 알파벳 [A-Za-z0-9+/=]을 예상합니다.

반환 유형

BYTES

예시

SELECT FROM_BASE64('/+A=') AS byte_data;

-- Note that the result of FROM_BASE64 is of type BYTES, displayed as a base64-encoded string.
+-----------+
| byte_data |
+-----------+
| /+A=      |
+-----------+

다른 base64 알파벳을 사용하여 인코딩하려면 REPLACE 함수를 사용하여 FROM_BASE64를 구성해야 할 수 있습니다. 예를 들어 웹 프로그래밍에서 일반적으로 사용되는 base64url url-safe 및 filename-safe 인코딩은 마지막 문자로 +/=이 아닌 -_=를 사용합니다. base64url로 인코딩된 문자열을 디코딩하려면 +/를 각각 -_로 바꿉니다.

SELECT FROM_BASE64(REPLACE(REPLACE("_-A=", "-", "+"), "_", "/")) AS binary;

-- Note that the result of FROM_BASE64 is of type BYTES, displayed as a base64-encoded string.
+--------+
| binary |
+--------+
| /+A=   |
+--------+

FROM_HEX

FROM_HEX(string)

설명

16진수로 인코딩된 STRINGBYTES 형식으로 변환합니다. 입력 STRING(0..9, A..F, a..f) 범위를 벗어난 문자가 있으면 오류를 반환합니다. 문자는 대소문자를 구분하지 않습니다. 입력 STRING의 문자 수가 홀수이면 함수는 입력 앞부분에 0이 추가된 것처럼 작동합니다. BYTES를 16진수로 인코딩된 STRING으로 변환하려면 TO_HEX를 사용합니다.

반환 유형

BYTES

예시

WITH Input AS (
  SELECT '00010203aaeeefff' AS hex_str UNION ALL
  SELECT '0AF' UNION ALL
  SELECT '666f6f626172'
)
SELECT hex_str, FROM_HEX(hex_str) AS bytes_str
FROM Input;

-- Note that the result of FROM_HEX is of type BYTES, displayed as a base64-encoded string.
+------------------+--------------+
| hex_str          | bytes_str    |
+------------------+--------------+
| 0AF              | AAECA6ru7/8= |
| 00010203aaeeefff | AK8=         |
| 666f6f626172     | Zm9vYmFy     |
+------------------+--------------+

LENGTH

LENGTH(value)

설명

STRING 또는 BYTES 값의 길이를 반환합니다. 반환되는 값은 STRING 인수의 경우 문자이고, BYTES 인수의 경우에는 바이트입니다.

반환 유형

INT64

예시


WITH example AS
  (SELECT "абвгд" AS characters)

SELECT
  characters,
  LENGTH(characters) AS string_example,
  LENGTH(CAST(characters AS BYTES)) AS bytes_example
FROM example;

+------------+----------------+---------------+
| characters | string_example | bytes_example |
+------------+----------------+---------------+
| абвгд      |              5 |            10 |
+------------+----------------+---------------+

LPAD

LPAD(original_value, return_length[, pattern])

설명

original_value로 구성되고 앞에 pattern이 추가된 STRING 또는 BYTES 값을 반환합니다. return_length는 반환된 값의 길이를 지정하는 INT64입니다. original_valueBYTES 유형이면 return_length는 바이트 수입니다. original_valueSTRING 유형이면 return_length는 문자 수입니다.

pattern의 기본값은 빈 공백입니다.

original_valuepattern은 같은 데이터 유형이어야 합니다.

return_lengthoriginal_value 길이 이하이면 이 함수는 return_length 값으로 잘린 original_value 값을 반환합니다. 예를 들어 LPAD("hello world", 7);"hello w"를 반환합니다.

original_value, return_length 또는 patternNULL이면 이 함수는 NULL을 반환합니다.

이 함수는 다음과 같은 경우에 오류를 반환합니다.

  • return_length가 음수인 경우
  • pattern이 비어 있는 경우

반환 유형

STRING 또는 BYTES

예시

SELECT t, len, FORMAT("%T", LPAD(t, len)) AS LPAD FROM UNNEST([
  STRUCT('abc' AS t, 5 AS len),
  ('abc', 2),
  ('例子', 4)
]);

+------+-----+----------+
| t    | len | LPAD     |
|------|-----|----------|
| abc  | 5   | "  abc"  |
| abc  | 2   | "ab"     |
| 例子  | 4   | "  例子" |
+------+-----+----------+
SELECT t, len, pattern, FORMAT("%T", LPAD(t, len, pattern)) AS LPAD FROM UNNEST([
  STRUCT('abc' AS t, 8 AS len, 'def' AS pattern),
  ('abc', 5, '-'),
  ('例子', 5, '中文')
]);

+------+-----+---------+--------------+
| t    | len | pattern | LPAD         |
|------|-----|---------|--------------|
| abc  | 8   | def     | "defdeabc"   |
| abc  | 5   | -       | "--abc"      |
| 例子  | 5   | 中文    | "中文中例子"   |
+------+-----+---------+--------------+
SELECT FORMAT("%T", t) AS t, len, FORMAT("%T", LPAD(t, len)) AS LPAD FROM UNNEST([
  STRUCT(b'abc' AS t, 5 AS len),
  (b'abc', 2),
  (b'\xab\xcd\xef', 4)
]);

+-----------------+-----+------------------+
| t               | len | LPAD             |
|-----------------|-----|------------------|
| b"abc"          | 5   | b"  abc"         |
| b"abc"          | 2   | b"ab"            |
| b"\xab\xcd\xef" | 4   | b" \xab\xcd\xef" |
+-----------------+-----+------------------+
SELECT
  FORMAT("%T", t) AS t,
  len,
  FORMAT("%T", pattern) AS pattern,
  FORMAT("%T", LPAD(t, len, pattern)) AS LPAD
FROM UNNEST([
  STRUCT(b'abc' AS t, 8 AS len, b'def' AS pattern),
  (b'abc', 5, b'-'),
  (b'\xab\xcd\xef', 5, b'\x00')
]);

+-----------------+-----+---------+-------------------------+
| t               | len | pattern | LPAD                    |
|-----------------|-----|---------|-------------------------|
| b"abc"          | 8   | b"def"  | b"defdeabc"             |
| b"abc"          | 5   | b"-"    | b"--abc"                |
| b"\xab\xcd\xef" | 5   | b"\x00" | b"\x00\x00\xab\xcd\xef" |
+-----------------+-----+---------+-------------------------+

LOWER

LOWER(value)

설명

STRING 인수의 경우 모든 알파벳 문자가 소문자인 원본 문자열을 반환합니다. 소문자와 대문자 간의 매핑은 계정 언어별 매핑을 고려하지 않고 유니코드 문자 데이터베이스에 따라 수행됩니다.

BYTES 인수에서 인수는 ASCII 텍스트로 취급되며 127보다 큰 모든 바이트는 그대로 유지됩니다.

반환 유형

STRING 또는 BYTES

예시


WITH items AS
  (SELECT
    "FOO" as item
  UNION ALL
  SELECT
    "BAR" as item
  UNION ALL
  SELECT
    "BAZ" as item)

SELECT
  LOWER(item) AS example
FROM items;

+---------+
| example |
+---------+
| foo     |
| bar     |
| baz     |
+---------+

LTRIM

LTRIM(value1[, value2])

설명

TRIM과 동일하지만 선행 문자만 제거합니다.

반환 유형

STRING 또는 BYTES

예시

WITH items AS
  (SELECT "   apple   " as item
  UNION ALL
  SELECT "   banana   " as item
  UNION ALL
  SELECT "   orange   " as item)

SELECT
  CONCAT("#", LTRIM(item), "#") as example
FROM items;

+-------------+
| example     |
+-------------+
| #apple   #  |
| #banana   # |
| #orange   # |
+-------------+
WITH items AS
  (SELECT "***apple***" as item
  UNION ALL
  SELECT "***banana***" as item
  UNION ALL
  SELECT "***orange***" as item)

SELECT
  LTRIM(item, "*") as example
FROM items;

+-----------+
| example   |
+-----------+
| apple***  |
| banana*** |
| orange*** |
+-----------+
WITH items AS
  (SELECT "xxxapplexxx" as item
  UNION ALL
  SELECT "yyybananayyy" as item
  UNION ALL
  SELECT "zzzorangezzz" as item
  UNION ALL
  SELECT "xyzpearxyz" as item)
SELECT
  LTRIM(item, "xyz") as example
FROM items;

+-----------+
| example   |
+-----------+
| applexxx  |
| bananayyy |
| orangezzz |
| pearxyz   |
+-----------+

REGEXP_CONTAINS

REGEXP_CONTAINS(value, regexp)

설명

value가 정규 표현식 regexp와 부분적으로 일치하면 TRUE를 반환합니다.

regexp 인수가 잘못되면 이 함수는 오류를 반환합니다.

^(텍스트 시작) 및 $(텍스트 종료)를 사용하여 완전 일치를 검색할 수 있습니다. 정규 표현식 연산자의 우선순위로 인해 ^$ 사이의 모든 문자를 괄호로 묶는 것이 좋습니다.

반환 유형

BOOL

예시

SELECT
  email,
  REGEXP_CONTAINS(email, r"@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+") AS is_valid
FROM
  (SELECT
    ["foo@example.com", "bar@example.org", "www.example.net"]
    AS addresses),
  UNNEST(addresses) AS email;

+-----------------+----------+
| email           | is_valid |
+-----------------+----------+
| foo@example.com | true     |
| bar@example.org | true     |
| www.example.net | false    |
+-----------------+----------+

# Performs a full match, using ^ and $. Due to regular expression operator
# precedence, it is good practice to use parentheses around everything between ^
# and $.
SELECT
  email,
  REGEXP_CONTAINS(email, r"^([\w.+-]+@foo\.com|[\w.+-]+@bar\.org)$")
    AS valid_email_address,
  REGEXP_CONTAINS(email, r"^[\w.+-]+@foo\.com|[\w.+-]+@bar\.org$")
    AS without_parentheses
FROM
  (SELECT
    ["a@foo.com", "a@foo.computer", "b@bar.org", "!b@bar.org", "c@buz.net"]
    AS addresses),
  UNNEST(addresses) AS email;

+----------------+---------------------+---------------------+
| email          | valid_email_address | without_parentheses |
+----------------+---------------------+---------------------+
| a@foo.com      | true                | true                |
| a@foo.computer | false               | true                |
| b@bar.org      | true                | true                |
| !b@bar.org     | false               | true                |
| c@buz.net      | false               | false               |
+----------------+---------------------+---------------------+

REGEXP_EXTRACT

REGEXP_EXTRACT(value, regexp)

설명

value에서 정규 표현식 regexp와 일치하는 첫 번째 하위 문자열을 반환합니다. 일치하는 항목이 없으면 NULL을 반환합니다.

정규 표현식에 캡처 그룹이 포함되어 있는 경우, 이 함수는 그 캡처 그룹으로 일치되는 하위 문자열을 반환합니다. 정규 표현식에 캡처 그룹이 포함되어 있지 않은 경우, 이 함수는 일치하는 전체 하위 문자열을 반환합니다.

다음의 경우 오류를 반환합니다.

  • 정규 표현식이 유효하지 않은 경우
  • 정규 표현식에 캡처 그룹이 둘 이상 있는 경우

반환 유형

STRING 또는 BYTES

예시

WITH email_addresses AS
  (SELECT "foo@example.com" as email
  UNION ALL
  SELECT "bar@example.org" as email
  UNION ALL
  SELECT "baz@example.net" as email)

SELECT
  REGEXP_EXTRACT(email, r"^[a-zA-Z0-9_.+-]+")
  AS user_name
FROM email_addresses;

+-----------+
| user_name |
+-----------+
| foo       |
| bar       |
| baz       |
+-----------+
WITH email_addresses AS
  (SELECT "foo@example.com" as email
  UNION ALL
  SELECT "bar@example.org" as email
  UNION ALL
  SELECT "baz@example.net" as email)

SELECT
  REGEXP_EXTRACT(email, r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.([a-zA-Z0-9-.]+$)")
  AS top_level_domain
FROM email_addresses;

+------------------+
| top_level_domain |
+------------------+
| com              |
| org              |
| net              |
+------------------+

REGEXP_EXTRACT_ALL

REGEXP_EXTRACT_ALL(value, regexp)

설명

정규 표현식 regexp와 일치하는 value의 모든 하위 문자열 배열을 반환합니다.

REGEXP_EXTRACT_ALL 함수는 중첩되지 않는 일치 항목만 반환합니다. 예를 들어 이 함수를 사용하여 banana에서 ana를 추출하면 하위 문자열이 2개가 아닌 1개만 반환됩니다.

반환 유형

STRING 또는 BYTESARRAY입니다.

예시

WITH code_markdown AS
  (SELECT "Try `function(x)` or `function(y)`" as code)

SELECT
  REGEXP_EXTRACT_ALL(code, "`(.+?)`") AS example
FROM code_markdown;

+----------------------------+
| example                    |
+----------------------------+
| [function(x), function(y)] |
+----------------------------+

REGEXP_REPLACE

REGEXP_REPLACE(value, regexp, replacement)

설명

정규 표현식 regexp와 일치하는 모든 value 하위 문자열이 replacement로 바뀐 STRING을 반환합니다.

replacement 인수 내에 백슬래시로 이스케이프 처리된 숫자(\1~\9)를 사용하여 regexp 패턴에서 괄호로 묶인 해당 그룹과 일치하는 텍스트를 삽입할 수 있습니다. 전체 일치 텍스트를 나타내려면 \0을 사용합니다.

REGEXP_REPLACE 함수는 중첩되지 않는 일치 항목만 바꿉니다. 예를 들어 banana 내의 ana를 바꿀 때는 2개가 아니라 1개만 바뀝니다.

regexp 인수가 유효한 정규 표현식이 아니면 이 함수는 오류를 반환합니다.

반환 유형

STRING 또는 BYTES

예시

WITH markdown AS
  (SELECT "# Heading" as heading
  UNION ALL
  SELECT "# Another heading" as heading)

SELECT
  REGEXP_REPLACE(heading, r"^# ([a-zA-Z0-9\s]+$)", "<h1>\\1</h1>")
  AS html
FROM markdown;

+--------------------------+
| html                     |
+--------------------------+
| <h1>Heading</h1>         |
| <h1>Another heading</h1> |
+--------------------------+

REPLACE

REPLACE(original_value, from_value, to_value)

설명

original_value에서 일치하는 모든 from_value 항목을 to_value로 바꿉니다. from_value가 비어 있으면 값이 바뀌지 않습니다.

반환 유형

STRING 또는 BYTES

예시

WITH desserts AS
  (SELECT "apple pie" as dessert
  UNION ALL
  SELECT "blackberry pie" as dessert
  UNION ALL
  SELECT "cherry pie" as dessert)

SELECT
  REPLACE (dessert, "pie", "cobbler") as example
FROM desserts;

+--------------------+
| example            |
+--------------------+
| apple cobbler      |
| blackberry cobbler |
| cherry cobbler     |
+--------------------+

반복

REPEAT(original_value, repetitions)

설명

반복되는 original_value로 구성된 STRING 또는 BYTES 값을 반환합니다. repetitions 매개변수는 original_value 반복 횟수를 지정합니다. original_value 또는 repetitionsNULL이면 NULL을 반환합니다.

repetitions 값이 음수이면 이 함수는 오류를 반환합니다.

반환 유형

STRING 또는 BYTES

예시

SELECT t, n, REPEAT(t, n) AS REPEAT FROM UNNEST([
  STRUCT('abc' AS t, 3 AS n),
  ('例子', 2),
  ('abc', null),
  (null, 3)
]);

+------+------+-----------+
| t    | n    | REPEAT    |
|------|------|-----------|
| abc  | 3    | abcabcabc |
| 例子 | 2    | 例子例子  |
| abc  | NULL | NULL      |
| NULL | 3    | NULL      |
+------+------+-----------+

REVERSE

REVERSE(value)

설명

입력 STRING 또는 BYTES를 역으로 반환합니다.

반환 유형

STRING 또는 BYTES

예시

WITH example AS (
  SELECT "foo" AS sample_string, b"bar" AS sample_bytes UNION ALL
  SELECT "абвгд" AS sample_string, b"123" AS sample_bytes
)
SELECT
  sample_string,
  REVERSE(sample_string) AS reverse_string,
  sample_bytes,
  REVERSE(sample_bytes) AS reverse_bytes
FROM example;

+---------------+----------------+--------------+---------------+
| sample_string | reverse_string | sample_bytes | reverse_bytes |
+---------------+----------------+--------------+---------------+
| foo           | oof            | bar          | rab           |
| абвгд         | дгвба          | 123          | 321           |
+---------------+----------------+--------------+---------------+

RPAD

RPAD(original_value, return_length[, pattern])

설명

original_value로 구성되고 pattern이 추가된 STRING 또는 BYTES 값을 반환합니다. return_length 매개변수는 반환되는 값의 길이를 지정하는 INT64입니다. original_valueBYTES이면 return_length는 바이트 수입니다. original_valueSTRING이면 return_length는 문자 수입니다.

pattern의 기본값은 빈 공백입니다.

original_valuepattern은 같은 데이터 유형이어야 합니다.

return_lengthoriginal_value 길이 이하이면 이 함수는 return_length 값으로 잘린 original_value 값을 반환합니다. 예를 들어 RPAD("hello world", 7);"hello w"를 반환합니다.

original_value, return_length 또는 patternNULL이면 이 함수는 NULL을 반환합니다.

이 함수는 다음과 같은 경우에 오류를 반환합니다.

  • return_length가 음수인 경우
  • pattern이 비어 있는 경우

반환 유형

STRING 또는 BYTES

예시

SELECT t, len, FORMAT("%T", RPAD(t, len)) AS RPAD FROM UNNEST([
  STRUCT('abc' AS t, 5 AS len),
  ('abc', 2),
  ('例子', 4)
]);

+------+-----+----------+
| t    | len | RPAD     |
|------|-----|----------|
| abc  | 5   | "abc  "  |
| abc  | 2   | "ab"     |
| 例子  | 4   | "例子  " |
+------+-----+----------+
SELECT t, len, pattern, FORMAT("%T", RPAD(t, len, pattern)) AS RPAD FROM UNNEST([
  STRUCT('abc' AS t, 8 AS len, 'def' AS pattern),
  ('abc', 5, '-'),
  ('例子', 5, '中文')
]);

+------+-----+---------+--------------+
| t    | len | pattern | RPAD         |
|------|-----|---------|--------------|
| abc  | 8   | def     | "abcdefde"   |
| abc  | 5   | -       | "abc--"      |
| 例子  | 5   | 中文     | "例子中文中"  |
+------+-----+---------+--------------+
SELECT FORMAT("%T", t) AS t, len, FORMAT("%T", RPAD(t, len)) AS RPAD FROM UNNEST([
  STRUCT(b'abc' AS t, 5 AS len),
  (b'abc', 2),
  (b'\xab\xcd\xef', 4)
]);

+-----------------+-----+------------------+
| t               | len | RPAD             |
|-----------------|-----|------------------|
| b"abc"          | 5   | b"abc  "         |
| b"abc"          | 2   | b"ab"            |
| b"\xab\xcd\xef" | 4   | b"\xab\xcd\xef " |
+-----------------+-----+------------------+
SELECT
  FORMAT("%T", t) AS t,
  len,
  FORMAT("%T", pattern) AS pattern,
  FORMAT("%T", RPAD(t, len, pattern)) AS RPAD
FROM UNNEST([
  STRUCT(b'abc' AS t, 8 AS len, b'def' AS pattern),
  (b'abc', 5, b'-'),
  (b'\xab\xcd\xef', 5, b'\x00')
]);

+-----------------+-----+---------+-------------------------+
| t               | len | pattern | RPAD                    |
|-----------------|-----|---------|-------------------------|
| b"abc"          | 8   | b"def"  | b"abcdefde"             |
| b"abc"          | 5   | b"-"    | b"abc--"                |
| b"\xab\xcd\xef" | 5   | b"\x00" | b"\xab\xcd\xef\x00\x00" |
+-----------------+-----+---------+-------------------------+

RTRIM

RTRIM(value1[, value2])

설명

TRIM과 동일하지만 후행 문자만 제거합니다.

반환 유형

STRING 또는 BYTES

예시

WITH items AS
  (SELECT "***apple***" as item
  UNION ALL
  SELECT "***banana***" as item
  UNION ALL
  SELECT "***orange***" as item)

SELECT
  RTRIM(item, "*") as example
FROM items;

+-----------+
| example   |
+-----------+
| ***apple  |
| ***banana |
| ***orange |
+-----------+
WITH items AS
  (SELECT "applexxx" as item
  UNION ALL
  SELECT "bananayyy" as item
  UNION ALL
  SELECT "orangezzz" as item
  UNION ALL
  SELECT "pearxyz" as item)

SELECT
  RTRIM(item, "xyz") as example
FROM items;

+---------+
| example |
+---------+
| apple   |
| banana  |
| orange  |
| pear    |
+---------+

SAFE_CONVERT_BYTES_TO_STRING

SAFE_CONVERT_BYTES_TO_STRING(value)

설명

BYTES의 시퀀스를 STRING으로 변환합니다. 잘못된 UTF-8 문자는 유니코드 대체 문자인 U+FFFD로 대체됩니다.

반환 유형

STRING

예시

다음 문은 유니코드 대체 문자 �를 반환합니다.

SELECT SAFE_CONVERT_BYTES_TO_STRING(b'\xc2') as safe_convert;

분할

SPLIT(value[, delimiter])

설명

delimiter 인수를 사용하여 value를 분할합니다.

STRING에서 기본 구분 기호는 쉼표(,)입니다.

BYTES에서는 구분 기호를 지정해야 합니다.

비어 있는 구분 기호로 분할하면 STRING 값의 경우에는 UTF-8 문자 배열이, BYTES 값의 경우에는 BYTES의 배열이 생성됩니다.

비어 있는 STRING을 분할하면 비어 있는 STRING이 하나 있는 ARRAY가 반환됩니다.

반환 유형

STRING 유형의 ARRAY 또는 BYTES 유형의 ARRAY

예시

WITH letters AS
  (SELECT "" as letter_group
  UNION ALL
  SELECT "a" as letter_group
  UNION ALL
  SELECT "b c d" as letter_group)

SELECT SPLIT(letter_group, " ") as example
FROM letters;

+----------------------+
| example              |
+----------------------+
| []                   |
| [a]                  |
| [b, c, d]            |
+----------------------+

STARTS_WITH

STARTS_WITH(value1, value2)

설명

STRING 또는 BYTES 값 두 개를 사용합니다. 두 번째 값이 첫 번째 값의 프리픽스이면 TRUE를 반환합니다.

반환 유형

BOOL

예시

WITH items AS
  (SELECT "foo" as item
  UNION ALL
  SELECT "bar" as item
  UNION ALL
  SELECT "baz" as item)

SELECT
  STARTS_WITH(item, "b") as example
FROM items;

+---------+
| example |
+---------+
|   False |
|    True |
|    True |
+---------+

STRPOS

STRPOS(value1, value2)

설명

STRING 또는 BYTES 값 두 개를 사용합니다. value1 내부의 value2에서 첫 번째 어커런스의 1로 시작하는 색인을 반환합니다. value2를 찾을 수 없으면 0을 반환합니다.

반환 유형

INT64

예시

WITH email_addresses AS
  (SELECT
    "foo@example.com" AS email_address
  UNION ALL
  SELECT
    "foobar@example.com" AS email_address
  UNION ALL
  SELECT
    "foobarbaz@example.com" AS email_address
  UNION ALL
  SELECT
    "quxexample.com" AS email_address)

SELECT
  STRPOS(email_address, "@") AS example
FROM email_addresses;

+---------+
| example |
+---------+
|       4 |
|       7 |
|      10 |
|       0 |
+---------+

SUBSTR

SUBSTR(value, position[, length])

설명

제공된 STRING 또는 BYTES 값의 하위 문자열을 반환합니다. position 인수는 하위 문자열의 시작 위치를 지정하는 정수이며 position = 1은 첫 번째 문자나 바이트를 나타냅니다. length 인수는 STRING 인수의 경우에는 최대 문자 수, BYTES 인수의 경우에는 최대 바이트 수입니다.

position이 음수이면 함수는 value의 끝에서부터 계산하며 -1은 마지막 문자를 나타냅니다.

positionSTRING의 왼쪽 끝이면(position = 0 또는 position < -LENGTH(value)) 함수는 position = 1부터 시작합니다. lengthvalue의 길이를 초과하면 함수는 length 문자보다 작은 값을 반환합니다.

length가 0보다 작으면 함수는 오류를 반환합니다.

반환 유형

STRING 또는 BYTES

예시

WITH items AS
  (SELECT "apple" as item
  UNION ALL
  SELECT "banana" as item
  UNION ALL
  SELECT "orange" as item)

SELECT
  SUBSTR(item, 2) as example
FROM items;

+---------+
| example |
+---------+
| pple    |
| anana   |
| range   |
+---------+
WITH items AS
  (SELECT "apple" as item
  UNION ALL
  SELECT "banana" as item
  UNION ALL
  SELECT "orange" as item)

SELECT
  SUBSTR(item, 2, 2) as example
FROM items;

+---------+
| example |
+---------+
| pp      |
| an      |
| ra      |
+---------+
WITH items AS
  (SELECT "apple" as item
  UNION ALL
  SELECT "banana" as item
  UNION ALL
  SELECT "orange" as item)

SELECT
  SUBSTR(item, -2) as example
FROM items;

+---------+
| example |
+---------+
| le      |
| na      |
| ge      |
+---------+

TO_BASE32

TO_BASE32(bytes_expr)

설명

BYTES의 시퀀스를 base32로 인코딩된 STRING으로 변환합니다. base32로 인코딩된 STRINGBYTES로 변환하려면 FROM_BASE32를 사용합니다.

반환 유형

STRING

예시

SELECT TO_BASE32(b'abcde\xFF') AS base32_string;

+------------------+
| base32_string    |
+------------------+
| MFRGGZDF74====== |
+------------------+

TO_BASE64

TO_BASE64(bytes_expr)

설명

BYTES의 시퀀스를 base64로 인코딩된 STRING으로 변환합니다. base64로 인코딩된 STRINGBYTES로 변환하려면 FROM_BASE64를 사용합니다.

64자리와 패딩을 인코딩하는 데 사용되는 ASCII 알파벳 65자와 완전히 다른 일반적으로 사용되는 base64 인코딩이 여러 개 있습니다. 자세한 내용은 RFC 4648을 참조하세요. 이 함수는 패딩을 추가하고 알파벳([A-Za-z0-9+/=])을 사용합니다.

반환 유형

STRING

예시

SELECT TO_BASE64(b'\377\340') AS base64_string;

+---------------+
| base64_string |
+---------------+
| /+A=          |
+---------------+

다른 base64 알파벳을 사용하여 인코딩하려면 REPLACE 함수를 사용하여 TO_BASE64를 구성해야 할 수 있습니다. 예를 들어 웹 프로그래밍에서 일반적으로 사용되는 base64url url-safe 및 filename-safe 인코딩은 마지막 문자로 +/=이 아닌 -_=를 사용합니다. base64url로 인코딩된 문자열을 인코딩하려면 -_를 각각 +/로 바꿉니다.

SELECT REPLACE(REPLACE(TO_BASE64(b"\377\340"), "+", "-"), "/", "_") as websafe_base64;

+----------------+
| websafe_base64 |
+----------------+
| _-A=           |
+----------------+

TO_CODE_POINTS

TO_CODE_POINTS(value)

설명

을 사용하여 INT64 배열을 반환합니다.

  • valueSTRING이면 반환되는 배열의 각 요소는 코드 포인트를 나타냅니다. 각 코드 포인트는 [0, 0xD7FF] 및 [0xE000, 0x10FFFF] 범위에 속합니다.
  • valueBYTES이면 배열의 각 요소는 [0, 255] 범위의 확장된 ASCII 문자 값입니다.

코드 포인트 배열을 STRING 또는 BYTES로 변환하려면 CODE_POINTS_TO_STRING 또는 CODE_POINTS_TO_BYTES를 참조하세요.

반환 유형

ARRAY/INT64

예시

다음 예시에서는 단어 배열에 있는 각 요소의 코드 포인트를 가져옵니다.

SELECT word, TO_CODE_POINTS(word) AS code_points
FROM UNNEST(['foo', 'bar', 'baz', 'giraffe', 'llama']) AS word;

+---------+------------------------------------+
| word    | code_points                        |
+---------+------------------------------------+
| foo     | [102, 111, 111]                    |
| bar     | [98, 97, 114]                      |
| baz     | [98, 97, 122]                      |
| giraffe | [103, 105, 114, 97, 102, 102, 101] |
| llama   | [108, 108, 97, 109, 97]            |
+---------+------------------------------------+

다음 예시에서는 BYTES의 정수 표현을 해당 ASCII 문자 값으로 변환합니다.

SELECT word, TO_CODE_POINTS(word) AS bytes_value_as_integer
FROM UNNEST([b'\x00\x01\x10\xff', b'\x66\x6f\x6f']) AS word;

+------------------+------------------------+
| word             | bytes_value_as_integer |
+------------------+------------------------+
| \x00\x01\x10\xff | [0, 1, 16, 255]        |
| foo              | [102, 111, 111]        |
+------------------+------------------------+

다음 예시에서는 BYTES 결과와 STRING 결과 간의 차이를 보여줍니다.

SELECT TO_CODE_POINTS(b'Ā') AS b_result, TO_CODE_POINTS('Ā') AS s_result;

+------------+----------+
| b_result   | s_result |
+------------+----------+
| [196, 128] | [256]    |
+------------+----------+

문자 Ā는 2바이트 유니코드 시퀀스로 표현됩니다. 따라서 TO_CODE_POINTSBYTES 버전은 요소가 두 개 있는 배열을 반환하며 STRING 버전은 요소가 한 개 있는 배열을 반환합니다.

TO_HEX

TO_HEX(bytes)

설명

BYTES의 시퀀스를 16진수 STRING으로 변환합니다. STRING의 각 바이트를 (0..9, a..f) 범위 내 16진수 문자 두 개로 변환합니다. 16진수로 인코딩된 STRINGBYTES로 변환하려면 FROM_HEX를 사용합니다.

반환 유형

STRING

예시

WITH Input AS (
  SELECT b'\x00\x01\x02\x03\xAA\xEE\xEF\xFF' AS byte_str UNION ALL
  SELECT b'foobar'
)
SELECT byte_str, TO_HEX(byte_str) AS hex_str
FROM Input;

+----------------------------------+------------------+
| byte_string                      | hex_string       |
+----------------------------------+------------------+
| \x00\x01\x02\x03\xaa\xee\xef\xff | 00010203aaeeefff |
| foobar                           | 666f6f626172     |
+----------------------------------+------------------+

TRIM

TRIM(value1[, value2])

설명

value2와 일치하는 모든 선행 및 후행 문자를 제거합니다. value2가 지정되지 않으면 모든 선행 및 후행 공백 문자(유니코드 표준의 정의에 따름)가 삭제됩니다. 첫 번째 인수의 유형이 BYTES이면 두 번째 인수가 필요합니다.

value2에 문자나 바이트가 두 개 이상 포함되어 있으면 함수는 value2에 포함된 모든 선행 또는 후행 문자나 바이트를 삭제합니다.

반환 유형

STRING 또는 BYTES

예시

WITH items AS
  (SELECT "   apple   " as item
  UNION ALL
  SELECT "   banana   " as item
  UNION ALL
  SELECT "   orange   " as item)

SELECT
  CONCAT("#", TRIM(item), "#") as example
FROM items;

+----------+
| example  |
+----------+
| #apple#  |
| #banana# |
| #orange# |
+----------+
WITH items AS
  (SELECT "***apple***" as item
  UNION ALL
  SELECT "***banana***" as item
  UNION ALL
  SELECT "***orange***" as item)

SELECT
  TRIM(item, "*") as example
FROM items;

+---------+
| example |
+---------+
| apple   |
| banana  |
| orange  |
+---------+
WITH items AS
  (SELECT "xxxapplexxx" as item
  UNION ALL
  SELECT "yyybananayyy" as item
  UNION ALL
  SELECT "zzzorangezzz" as item
  UNION ALL
  SELECT "xyzpearxyz" as item)

SELECT
  TRIM(item, "xyz") as example
FROM items;

+---------+
| example |
+---------+
| apple   |
| banana  |
| orange  |
| pear    |
+---------+

UPPER

UPPER(value)

설명

STRING 인수의 경우 모든 알파벳 문자가 대문자인 원본 문자열을 반환합니다. 소문자와 대문자 간의 매핑은 계정 언어별 매핑을 고려하지 않고 유니코드 문자 데이터베이스에 따라 수행됩니다.

BYTES 인수에서 인수는 ASCII 텍스트로 취급되며 127보다 큰 모든 바이트는 그대로 유지됩니다.

반환 유형

STRING 또는 BYTES

예시

WITH items AS
  (SELECT
    "foo" as item
  UNION ALL
  SELECT
    "bar" as item
  UNION ALL
  SELECT
    "baz" as item)

SELECT
  UPPER(item) AS example
FROM items;

+---------+
| example |
+---------+
| FOO     |
| BAR     |
| BAZ     |
+---------+