Amazon Redshift는 패치 198부터 새 Python UDF 생성을 더 이상 지원하지 않습니다. 기존 Python UDF는 2026년 6월 30일까지 계속 작동합니다. 자세한 내용은 블로그 게시물을 참조하세요.

연산자 및 함수

Amazon Redshift를 사용하면 연산자와 함수를 사용하여 SUPER 데이터로 대규모 데이터세트에 대한 고급 분석을 수행할 수 있습니다. SUPER 데이터의 연산자 및 함수는 Amazon Redshift 테이블에 저장된 반정형 데이터의 복잡한 분석 및 조작을 지원하는 SQL 구문입니다.

다음 섹션에서는 Amazon Redshift의 SUPER 데이터에 연산자와 함수를 사용하여 반정형 데이터의 잠재력을 최대한 활용하기 위한 구문, 예제 및 모범 사례를 다룹니다.

산술 연산자

SUPER 값은 동적 형식 지정을 사용하여 모든 기본 산술 연산자 +, -, *, /, %를 지원합니다. 작업의 결과 형식은 SUPER로 유지됩니다. 이항 연산자 +를 제외한 모든 연산자의 경우 입력 피연산자는 숫자여야 합니다. 그렇지 않으면 Amazon Redshift가 null을 반환합니다. 소수 자릿수와 부동 소수점 값의 차이는 Amazon Redshift에서 이러한 연산자를 실행하고 동적 형식이 변경되지 않는 경우에도 유지됩니다. 그러나 곱셈과 나눗셈을 사용하면 소수 자릿수가 변경됩니다. 산술 오버플로는 여전히 쿼리 오류를 발생시키며 null로 변경되지 않습니다. 이항 연산자 +는 입력이 숫자이면 덧셈을 수행하고 입력이 문자열이면 연결을 수행합니다. 한 피연산자가 문자열이고 다른 피연산자가 숫자이면 결과는 null입니다. 단항 접두사 연산자 + 및 -는 다음 예와 같이 SUPER 값이 숫자가 아닌 경우 null을 반환합니다.

SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0]. o_orderkey / 10 AS math FROM customer_orders_lineitem;
            math
----------------------------
 1757958232200.1500
(1 row)

동적 형식 지정을 사용하면 SUPER의 소수 값이 다른 소수 자릿수를 가질 수 있습니다. Amazon Redshift는 소수 값을 서로 다른 정적 형식인 것처럼 취급하고 모든 수학 연산을 허용합니다. Amazon Redshift는 피연산자의 소수 자릿수를 기준으로 결과 소수 자릿수를 동적으로 계산합니다. 피연산자 중 하나가 부동 소수점 숫자인 경우 Amazon Redshift는 다른 피연산자를 부동 소수점 숫자로 승격시키고 결과를 부동 소수점 숫자로 생성합니다.

산술 함수

Amazon Redshift는 SUPER 열에 대해 다음과 같은 산술 함수를 지원합니다. 입력이 숫자가 아닌 경우 null이 반환됩니다.

다음 예에서는 산술 함수를 사용하여 데이터를 쿼리합니다.

SELECT x, FLOOR(x), CEIL(x), ROUND(x)
FROM (
    SELECT (c_orders[0]. o_orderkey + 0.5) * c_orders[0].o_orderkey / 10 AS x
    FROM customer_orders_lineitem
    );

         x          |     floor     |     ceil      |     round
--------------------+---------------+---------------+---------------
 1389636795898.0500  | 1389636795898  | 1389636795899  | 1389636795898

ABS 함수는 FLOOR, CEIL 동안 입력 소수의 소수 자릿수를 유지합니다. ROUND는 입력 소수의 소수 자릿수를 제거합니다.

배열 함수

Amazon Redshift는 다음과 같은 배열 구성 및 유틸리티 함수를 지원합니다.

ARRAY 함수로 다른 SUPER 값을 포함한 Amazon Redshift 데이터 형식의 값에서 SUPER 배열을 구성할 수 있습니다. 다음 예에서는 가변 함수 ARRAY를 사용합니다.

SELECT ARRAY(1, c.c_custkey, NULL, c.c_name, 'abc') FROM customer_orders_lineitem c; 
                               array
 -------------------------------------------------------
[1,8401,null,""Customer#000008401"",""abc""]
[1,9452,null,""Customer#000009452"",""abc""]
[1,9451,null,""Customer#000009451"",""abc""]
[1,8251,null,""Customer#000008251"",""abc""]
[1,5851,null,""Customer#000005851"",""abc""] 
(5 rows)

다음 예에서는 ARRAY_CONCAT 함수와 함께 배열 연결을 사용합니다.

SELECT ARRAY_CONCAT(JSON_PARSE('[10001,10002]'),JSON_PARSE('[10003,10004]'));

             array_concat
------------------------------------
 [10001,10002,10003,10004]
(1 row)

다음 예에서는 입력 배열의 하위 집합을 반환하는 SUBARRAY 함수와 함께 배열 조작을 사용합니다.

SELECT SUBARRAY(ARRAY('a', 'b', 'c', 'd', 'e', 'f'), 2, 3);

   subarray
---------------
 ["c","d","e"]
(1 row))

다음 예에서는 ARRAY_FLATTEN을 사용하여 여러 수준의 배열을 단일 배열로 병합합니다.

SELECT x, ARRAY_FLATTEN(x) FROM (SELECT ARRAY(1, ARRAY(2, ARRAY(3, ARRAY()))) AS x);

     x           | array_flatten
 ----------------+---------------
 [1,[2,[3,[]]]]  | [1,2,3]
(1 row)

배열 함수 ARRAY_CONCAT 및 ARRAY_FLATTEN은 동적 형식 지정 규칙을 사용합니다. 이들은 입력이 배열이 아닌 경우 오류 대신 null을 반환합니다. GET_ARRAY_LENGTH 함수는 객체 또는 배열 경로가 지정된 SUPER 배열의 길이를 반환합니다.

SELECT c_name
FROM customer_orders_lineitem
WHERE GET_ARRAY_LENGTH(c_orders) = (
    SELECT MAX(GET_ARRAY_LENGTH(c_orders))
    FROM customer_orders_lineitem
    );

다음 예에서는 SPLIT_TO_ARRAY를 사용하여 문자열을 문자열 배열로 분할합니다. 이 함수는 구분 기호를 옵션 파라미터로 사용합니다. 구분 기호가 없으면 기본값은 쉼표입니다.

SELECT SPLIT_TO_ARRAY('12|345|6789', '|');

   split_to_array
---------------------
 ["12","345","6789"]
(1 row)

데이터 정렬 동작

SUPER를 사용하면 CREATE TABLE을 사용하여 열의 데이터 정렬을 설정하고, CREATE DATABASE를 사용하여 기본 데이터 정렬을 수행하고, COLLATE 함수를 사용하여 표현식의 데이터 정렬을 설정할 수 있습니다.

데이터 정렬 설정은 문자열 값, SUPER 배열 내 문자열 또는 SUPER 객체의 값 등 SUPER에 저장된 모든 비교 연산자와 문자열 값에 적용됩니다. SUPER 객체의 경우 데이터 정렬 동작은 속성이 아닌 값에만 적용됩니다. 예를 들어 {"attribute": "a"} = {"attribute": "A"}처럼 대소문자를 구분하지 않는 데이터 정렬이 있는 값을 비교하면 true가 반환되고 {"attribute": "a"} = {"ATTRIBUTE": "a"}는 false가 반환됩니다.

정보 함수

SUPER 데이터 열은 SUPER 값에 대한 동적 형식과 기타 형식 정보를 반환하는 내부 검사 함수를 지원합니다. 가장 일반적인 예는 SUPER 값의 동적 형식에 따라 부울, 숫자, 문자열, 객체, 배열 또는 null 값이 있는 VARCHAR를 반환하는 JSON_TYPEOF 스칼라 함수입니다. Amazon Redshift는 SUPER 데이터 열에 대해 다음과 같은 부울 함수를 지원합니다.

SUPER 유형 정보 함수에 대한 자세한 내용은 SUPER 형식 정보 함수 섹션을 참조하세요.

문자열 함수

SUPER 데이터 형식에서 문자열 리터럴과 함께 문자열 함수를 사용하려면 함수를 적용하기 전에 문자열 리터럴을 문자열 형식으로 변환해야 합니다. 입력이 문자열 리터럴이 아닌 경우 함수는 null을 반환합니다.

문자열 함수는 이제 최대 16,000,000바이트를 지원합니다.

다음 예제에서는 SUBSTRING을 사용하여 SUPER JSON 객체에 저장된 크기가 5,000,000바이트인 문자열의 미리 보기를 추출합니다.

CREATE TABLE customer_data (
   customer_id INT,
   profile SUPER
);

INSERT INTO customer_data VALUES (
   1,
   JSON_PARSE('{"name": "John Doe", "description": "' || REPEAT('A', 5000000) || '"}')
);

SELECT 
   customer_id,
   profile.name::VARCHAR AS name,
   SUBSTRING(profile.description::VARCHAR, 1, 50) AS description_preview
FROM customer_data;

 customer_id | name     | description_preview
-------------+----------+----------------------------------------------------
         1 | John Doe | AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
   

다음 예제에서는 SUPER 배열의 문자열 리터럴에 대한 LEFT, RIGHT 및 CONCAT 함수를 보여줍니다.

CREATE TABLE documents (
   doc_id INT,
   chapters SUPER
);

INSERT INTO documents VALUES (
   1,
   JSON_PARSE('["' || REPEAT('hello', 400000) || '", "' || REPEAT('world', 600000) || '"]')
);

SELECT 
   doc_id,
   LEFT(chapters[0]::VARCHAR, 20) AS chapter1_start,
   RIGHT(chapters[1]::VARCHAR, 20) AS chapter2_end,
   LEN(CONCAT(chapters[0]::VARCHAR, chapters[1]::VARCHAR)) AS concat_size
FROM documents;

 doc_id |    chapter1_start    |     chapter2_end     | concat_size 
--------+----------------------+----------------------+-------------
      1 | hellohellohellohello | worldworldworldworld |     5000000
   

다음 예제에서는 독립 실행형 문자열을 SUPER에 저장합니다.

CREATE TABLE text_storage (
   text_id INT,
   content SUPER
);

INSERT INTO text_storage VALUES 
   (1, REPEAT('A', 8000000)),
   (2, REPEAT('B', 16000000));

SELECT 
   text_id,
   LEN(content::VARCHAR) AS content_length
FROM text_storage;

 text_id | content_length
---------+----------------
      1 |        8000000
      2 |       16000000