SnowConvert AI - Redshift - CREATE PROCEDURE¶

설명¶

새 저장 프로시저를 만들거나 현재 데이터베이스에 대한 기존 프로시저를 바꿉니다. (Redshift SQL Language Reference 생성 절차).

프로시저 절에 대한 자세한 내용은 다음 정의를 참조하십시오.

ARGUMENTS MODE
POSITIONAL ARGUMENTS
NONATOMIC
PROCEDURE BODY
SECURITY (DEFINER | INVOKER)

문법 구문¶

The following is the SQL syntax to create a Procedure in Amazon Redshift. See the Redshift CREATE PROCEDURE specification for this syntax.

 CREATE [ OR REPLACE ] PROCEDURE sp_procedure_name  
  ( [ [ argname ] [ argmode ] argtype [, ...] ] )
[ NONATOMIC ]
AS $$
  procedure_body
$$ LANGUAGE plpgsql
[ { SECURITY INVOKER | SECURITY DEFINER } ]
[ SET configuration_parameter { TO value | = value } ]       

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE PROCEDURE TEST_PROCEDURE()
LANGUAGE PLPGSQL
AS
$$
BEGIN
    NULL;
END;
$$;

출력 코드:¶

Snowflake¶

 CREATE PROCEDURE TEST_PROCEDURE ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/07/2025",  "domain": "test" }}'
AS
$$
    BEGIN
        NULL;
    END;
$$;

ALIAS DECLARATION¶

설명¶

저장 프로시저의 서명에 인자 이름이 생략된 경우 해당 인자에 대한 별칭을 선언할 수 있습니다.

Snowflake에서는 이에 대한 지원이 없습니다.

기능적 동등성을 확보하기 위해 별칭이 제거되고 모든 용도의 이름이 변경됩니다.

이름이 없는 매개 변수에 대해 별칭을 선언하면 해당 매개 변수와 사용법에 대해 생성된 이름이 생성됩니다. 별칭이 이름이 있는 매개 변수의 이름인 경우 별칭은 실제 매개 변수 이름으로 대체됩니다.

문법 구문¶

 name ALIAS FOR $n;

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE test_procedure (integer)
LANGUAGE plpgsql
AS
$$
DECLARE
    first_alias ALIAS  FOR $1;
    second_alias ALIAS  FOR $1;
BEGIN
   INSERT INTO t1
   VALUES (first_alias + 1);
   INSERT INTO t1
   VALUES (second_alias + 2);
END;
$$;

--Notice the parameter already has a name
--and we are defining two alias to the same parameter
CREATE OR REPLACE PROCEDURE test_procedure (PARAMETER1 integer)
LANGUAGE plpgsql
AS
$$
DECLARE
    first_alias ALIAS  FOR $1;
    second_alias ALIAS  FOR $1;
BEGIN
   INSERT INTO t1
   VALUES (first_alias + 1);
   INSERT INTO t1
   VALUES (second_alias + 2);
END;
$$;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE test_procedure (SC_ARG1 integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
BEGIN
   INSERT INTO t1
   VALUES (:SC_ARG1 + 1);
   INSERT INTO t1
   VALUES (:SC_ARG1 + 2);
END;
$$;

--Notice the parameter already has a name
--and we are defining two alias to the same parameter
--** SSC-FDM-0007 - MISSING DEPENDENT OBJECT "t1" **
CREATE OR REPLACE PROCEDURE test_procedure (PARAMETER1 integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
BEGIN
   INSERT INTO t1
   VALUES (:PARAMETER1 + 1);
   INSERT INTO t1
   VALUES (:PARAMETER1 + 2);
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

ARGUMENTS MODE¶

설명¶

Amazon Redshift 저장 프로시저는 프로시저 호출 중에 전달할 수 있는 매개 변수를 지원합니다. 이러한 매개 변수를 사용하면 입력 값을 제공하거나, 출력 값을 검색하거나, 입력 및 출력 작업에 사용할 수 있습니다. 다음은 매개 변수의 유형, 모드 및 사용 예시에 대한 자세한 설명입니다. Snowflake는 입력 값만 지원합니다.

IN (입력 매개 변수)¶

목적: 프로시저에 값을 전달하는 데 사용됩니다.

기본 모드: 모드를 지정하지 않으면 매개 변수는 IN 으로 간주됩니다.

동작: 프로시저에 전달된 값은 프로시저 내부에서 수정할 수 없습니다.

OUT (출력 매개 변수)¶

목적: 프로시저에서 반환 값을 반환하는 데 사용됩니다.

동작: 프로시저 내에서 매개 변수를 수정할 수 있으며 호출자에게 반환됩니다. 초기값은 보낼 수 없습니다.

INOUT (입력/출력 매개 변수)¶

목적: 프로시저에 값을 전달하고 업데이트된 값을 반환하도록 수정하는 데 사용됩니다.

동작: 동작: IN 및 OUT 의 동작을 결합합니다. 출력에 관계없이 초기값을 보내야 합니다.

문법 구문¶

 [ argname ] [ argmode ] argtype

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

CREATE OR REPLACE PROCEDURE SP_PARAMS(
IN PARAM1 INTEGER,
OUT PARAM2 INTEGER,
INOUT PARAM3 INTEGER)
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE SP_PARAMS (PARAM1 INTEGER, PARAM2 OUT INTEGER, PARAM3 OUT INTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/10/2025",  "domain": "no-domain-provided" }}'
AS
$$
    BEGIN
        NULL;
    END;
$$;

Known Issues¶

알려진 문제는 없습니다.

PROCEDURE BODY¶

힌트

SnowConvert does not support translation for PostgreSQL string constant definition in procedures. Use arrange option

설명¶

Redshift와 마찬가지로 Snowflake는 $$ procedure_logic $$을 본문으로 사용하여 CREATE PROCEDURE를 지원합니다. Redshift 구문에서는 $word$처럼 $$ 안에 단어를 넣어 $word$ procedure_logic $word$와 같이 구분자 본문으로 사용할 수 있다는 차이점이 있습니다. SnowConvert AI는 $$를 남겨두고 단어를 제거하여 변환합니다.

문법 구문¶

 AS
$Alias$
  procedure_body
$Alias$ 

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE SP()
AS 
$somename$
BEGIN
   NULL;
END;
$somename$ 
LANGUAGE plpgsql;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE SP ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/07/2025",  "domain": "test" }}'
AS
$$
   BEGIN
      NULL;
   END;
$$;

Known Issues¶

알려진 문제는 없습니다.

BLOCK STATEMENT¶

설명¶

PL/pgSQL 은 블록 구조의 언어입니다. 프로시저의 전체 본문은 변수 선언과 PL/pgSQL 문을 포함하는 블록에 정의됩니다. 문은 중첩된 블록 또는 하위 블록일 수도 있습니다.

문법 구문¶

 [ <<label>> ]
[ DECLARE
  declarations ]
BEGIN
  statements
EXCEPTION
  WHEN OTHERS THEN
    statements
END [ label ];

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE MY_PROCEDURE() 
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE MY_PROCEDURE ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/10/2025",  "domain": "test" }}'
AS
$$
    BEGIN
        NULL;
    END;
$$;

Known Issues¶

알려진 문제는 없습니다.

DECLARE¶

설명¶

루프 변수를 제외한 모든 프로시저 변수를 선언하는 섹션입니다.\ Redshift는 블록 문당 여러 개의 DECLARE 섹션을 지원하지만, Snowflake는 이 동작을 지원하지 않으므로 블록당 1개의 선언 문으로 병합해야 합니다.

문법 구문¶

 [ DECLARE declarations ]

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE first_procedure (first_parameter integer)
LANGUAGE plpgsql
    AS
$$
DECLARE
    i int := first_parameter;
BEGIN
   select i;
END;
$$;

CREATE OR REPLACE PROCEDURE second_procedure (first_parameter integer)
LANGUAGE plpgsql
    AS
$$
DECLARE
    i int := first_parameter;
DECLARE
    j int := first_parameter;
BEGIN
   select i;
END;
$$;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE first_procedure (first_parameter integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/11/2025",  "domain": "test" }}'
    AS
$$
   DECLARE
      i int := first_parameter;
BEGIN
   select i;
END;
$$;

CREATE OR REPLACE PROCEDURE second_procedure (first_parameter integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/11/2025",  "domain": "test" }}'
    AS
$$
   DECLARE
      i int := first_parameter;
      j int := first_parameter;
BEGIN
   select i;
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

EXCEPTION¶

설명¶

예외가 발생하여 예외 처리 블록을 추가하면 RAISE 문과 대부분의 다른 PL/pgSQL 문을 작성할 수 있습니다. 예를 들어, 사용자 지정 메시지로 예외를 발생시키거나 로깅 테이블에 레코드를 삽입할 수 있습니다.

문법 구문¶

 EXCEPTION
  WHEN OTHERS THEN
    statements

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE update_employee_sp() AS
$$
BEGIN
    select var;
EXCEPTION WHEN OTHERS THEN
    RAISE INFO 'An exception occurred.';
END;
$$
LANGUAGE plpgsql;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE update_employee_sp ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
BEGIN
    select var;
EXCEPTION WHEN OTHER THEN
        CALL RAISE_MESSAGE_UDF('INFO', 'An exception occurred.');
        RAISE;
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

LABEL¶

설명¶

Redshift에서 레이블은 블록의 자격을 부여하거나 EXIT 또는 END 문을 사용하는 데 사용됩니다. Snowflake는 레이블을 지원하지 않습니다.

경고

Snowflake에서는 레이블이 지원되지 않으므로 EWI 이 인쇄됩니다.

문법 구문¶

 [<<label>>]
BEGIN
    ...
END [label]

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE test_procedure (first_parameter integer)
LANGUAGE plpgsql
AS
$$
    <<Begin_block_label>>
BEGIN
   INSERT INTO my_test_table
   VALUES (first_parameter);
END;
$$;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE test_procedure (first_parameter integer)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
   !!!RESOLVE EWI!!! /*** SSC-EWI-0094 - LABEL DECLARATION FOR A STATEMENT IS NOT SUPPORTED BY SNOWFLAKE SCRIPTING <<Begin_block_label>> ***/!!!
BEGIN
   INSERT INTO my_test_table
   VALUES (:first_parameter);
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

NONATOMIC¶

설명¶

NONATOMIC 은 저장 프로시저의 각 문 뒤에 커밋됩니다. Snowflake는 AUTOCOMMIT 매개 변수를 지원합니다. AUTOCOMMIT의 기본 설정은 TRUE(활성화됨)입니다.

AUTOCOMMIT 이 활성화되어 있는 동안 명시적 트랜잭션 외부의 각 문은 암시적 단일 문 트랜잭션 내부의 문으로 취급됩니다. 다시 말해, 해당 문이 성공하면 자동으로 커밋되고 실패하면 자동으로 롤백됩니다. 즉, “기본적으로” Snowflake는 NONATOMIC 으로 작동합니다.

문법 구문¶

 NONATOMIC

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE SP_NONATOMIC()
NONATOMIC 
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE SP_NONATOMIC ()
RETURNS VARCHAR
----** SSC-FDM-RS0008 - SNOWFLAKE USES AUTOCOMMIT BY DEFAULT. **
--NONATOMIC
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/10/2025",  "domain": "test" }}'
AS
$$
    BEGIN
        NULL;
    END;
$$;

Known Issues¶

알려진 문제는 없습니다.

POSITIONAL ARGUMENTS¶

설명¶

Redshift는 $를 사용하여 위치별로 매개 변수를 참조하여 이름 없는 매개 변수를 지원합니다. Snowflake는 이 동작을 지원하지 않습니다. 기능적 동등성을 보장하기 위해, SnowConvert AI는 정의에 이름이 있는 경우 매개 변수의 이름으로 해당 참조를 변환할 수 있습니다. 그렇지 않은 경우, SnowConvert AI는 매개 변수의 이름을 생성하고, 사용된 이름은 새 이름으로 바뀝니다.

문법 구문¶

$n

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE SP_POSITIONAL_REFERENCES(
INTEGER,
param2 INTEGER,
INTEGER)
AS 
$$
    DECLARE
        localVariable INTEGER := 0;
    BEGIN
        localVariable := $2 + $3 + $1;
    END;
$$ 
LANGUAGE plpgsql;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE SP_POSITIONAL_REFERENCES (SC_ARG1
INTEGER,
param2 INTEGER, SC_ARG3 INTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS
$$
    DECLARE
        localVariable INTEGER := 0;
    BEGIN
        localVariable := param2 + SC_ARG3 + SC_ARG1;
    END;
$$;

Known Issues¶

알려진 문제는 없습니다.

RAISE¶

설명¶

RAISE level 문을 사용하여 메시지를 보고하고 오류를 발생시킵니다.

(Redshift SQL 언어 참조 RAISE)

참고

RAISE는 Snowflake에서 완벽하게 지원됩니다.

문법 구문¶

 RAISE level 'format' [, variable [, ...]];

Amazon Redshift에서 RAISE 문은 콘솔에서 메시지를 생성하거나 사용자 지정 예외를 throw하는 데 사용됩니다. Redshift를 사용하면 다양한 _레벨_을 지정하여 메시지의 심각도를 나타낼 수 있습니다. Snowflake에서는 지정된 레벨에 따라 콘솔을 호출하는 사용자 정의 함수(UDF)를 사용하여 이 기능을 에뮬레이션할 수 있습니다.

예외:\ 레벨이 “EXCEPTION”인 경우, 일반 메시지 _”To view the EXCEPTION MESSAGE, you need to check the log.”_와 함께 사용자 정의 예외가 발생합니다. 예외 코드는 -20002 이며, 사용자에게 사용자 정의 메시지가 로그에 있다는 것을 알려줍니다. 이는 Snowflake에서 사용자 지정 예외를 보낼 때 제한이 있기 때문입니다.
경고:\ 수준이 “WARNING”인 경우 SYSTEM$LOG_WARN 는 실행 플로우를 중단하지 않고 잠재적인 문제를 강조하는 데 도움이 되는 경고 메시지를 Snowflake의 로그에 인쇄하는 데 사용됩니다.
정보:\ 다른 수준(예: “INFO”)의 경우 SYSTEM$LOG_INFO 를 사용하여 메시지를 콘솔 로그에 인쇄하여 심각한 중단 없이 시스템 상태에 대한 자세한 피드백을 제공합니다.

이 접근법을 사용하면 Redshift의 심각도 수준 기능을 에뮬레이션하여 Snowflake의 구문과 기능에 맞게 조정하는 동시에 실행 중에 생성되는 메시지와 예외에 대한 유연성과 제어를 유지할 수 있습니다.

제한 사항

Snowflake에서 로그를 보려면 ACCOUNTADMIN 또는 SECURITYADMIN 역할과 같은 특정 권한이 있어야 합니다.
Snowflake의 로그는 즉시 사용 가능하지 않으며 정보가 표시되기까지 약간의 지연이 있을 수 있습니다.
예외적으로 개인 설정 오류 메시지는 Redshift에서와 같이 표시되지 않습니다. 사용자 지정 메시지를 보려면 로그에 직접 액세스해야 합니다.

자세한 내용은 다음 페이지를 참조하세요.

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE raise_example(IN user_id INT)
LANGUAGE plpgsql
AS $$
BEGIN
	RAISE EXCEPTION 'User % not exists.', user_id;
END;
$$;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE raise_example (user_id INT)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/11/2025",  "domain": "test" }}'
AS $$
BEGIN
	CALL RAISE_MESSAGE_UDF('EXCEPTION', 'User % not exists.', array_construct(:user_id));
END;
$$;

UDFs ¶

RAISE_MESSAGE_UDF¶

 CREATE OR REPLACE PROCEDURE RAISE_MESSAGE_UDF(LEVEL VARCHAR, MESSAGE VARCHAR, ARGS VARIANT)
RETURNS VARCHAR
LANGUAGE SQL
AS
$$
    DECLARE
        MY_EXCEPTION EXCEPTION (-20002, 'To view the EXCEPTION MESSAGE, you need to check the log.');
        SC_RAISE_MESSAGE VARCHAR;
    BEGIN
        SC_RAISE_MESSAGE := STRING_FORMAT_UDF(MESSAGE, ARGS);
        IF (LEVEL = 'EXCEPTION') THEN
            SYSTEM$LOG_ERROR(SC_RAISE_MESSAGE);
            RAISE MY_EXCEPTION;
        ELSEIF (LEVEL = 'WARNING') THEN
            SYSTEM$LOG_WARN(SC_RAISE_MESSAGE);
            RETURN 'Warning printed successfully';
        ELSE
            SYSTEM$LOG_INFO(SC_RAISE_MESSAGE);
            RETURN 'Message printed successfully';
        END IF;
    END;
$$;

STRING_FORMAT_UDF¶

 CREATE OR REPLACE FUNCTION PUBLIC.STRING_FORMAT_UDF(PATTERN VARCHAR, ARGS VARIANT)
RETURNS VARCHAR
LANGUAGE JAVASCRIPT
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "udf",  "convertedOn": "02/11/2025",  "domain": "test" }}'
AS
$$
	var placeholder_str = "{%}";
	var result = PATTERN.replace(/(?<!%)%(?!%)/g, placeholder_str).replace("%%","%");
	for (var i = 0; i < ARGS.length; i++)
	{
		result = result.replace(placeholder_str, ARGS[i]);
	}
	return result;
$$;

Known Issues¶

알려진 문제는 없습니다.

RETURN¶

설명¶

RETURN 문은 저장 프로시저에서 호출자에게 다시 반환합니다. (Redshift SQL Language Reference 반환).

반환 문을 Amazon Redshift에서 Snowflake로 변환하는 것은 간단하며, Snowflake의 반환 문에 NULL 을 추가하기만 하면 됩니다.

문법 구문¶

 RETURN;

샘플 소스 패턴¶

단순 케이스¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE procedure1 ()
AS
$$
BEGIN
   RETURN;
END
$$ LANGUAGE plpgsql;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE procedure1 ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/12/2025",  "domain": "test" }}'
AS
$$
BEGIN
  RETURN NULL;
END
$$;

프로시저에 매개 변수가 없는 경우¶

SnowConvert AI는 매개 변수가 출력 매개 변수로 설정된 베리언트를 반환합니다. 따라서 각 반환에 대해 SnowConvert AI는 베리언트를 반환 값으로 추가합니다.

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE procedure1 (OUT output_value VARCHAR)
AS
$$
BEGIN
   RETURN;
END
$$ LANGUAGE plpgsql;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE procedure1 (output_value OUT VARCHAR)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/16/2025",  "domain": "no-domain-provided" }}'
AS
$$
BEGIN
   RETURN NULL;
END
$$;

Known Issues¶

알려진 문제는 없습니다.

SECURITY (DEFINER | INVOKER)¶

설명¶

Amazon Redshift 저장 프로시저의 SECURITY 절은 프로시저가 실행되는 액세스 제어 및 권한 컨텍스트를 정의합니다. 프로시저가 소유자(작성기)의 권한을 사용할지, 아니면 호출자(프로시저를 호출하는 사용자)의 권한을 사용할지 결정합니다.

문법 구문¶

 [ { SECURITY INVOKER | SECURITY DEFINER } ]  

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE SP_SECURITY_INVOKER( )
AS 
$$
    BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql
SECURITY INVOKER
;

CREATE OR REPLACE PROCEDURE SP_SECURITY_DEFINER( )
AS 
$$
     BEGIN
        NULL;
    END;
$$ 
LANGUAGE plpgsql
SECURITY DEFINER;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE SP_SECURITY_INVOKER ( )
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/07/2025",  "domain": "test" }}'
EXECUTE AS CALLER
AS
$$
    BEGIN
        NULL;
    END;
$$
;

CREATE OR REPLACE PROCEDURE SP_SECURITY_DEFINER ( )
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/07/2025",  "domain": "test" }}'
EXECUTE AS OWNER
AS
$$
    BEGIN
        NULL;
    END;
$$;

Known Issues¶

알려진 문제는 없습니다.

VARIABLE DECLARATION¶

설명¶

블록의 DECLARE 섹션에서 루프 변수를 제외한 블록의 모든 변수를 선언합니다.

(Redshift SQL 언어 참조 변수 선언)

참고

변수 선언은 Snowflake 에서 완벽하게 지원됩니다.

문법 구문¶

 DECLARE
name [ CONSTANT ] type [ NOT NULL ] [ { DEFAULT | := } expression ];

Redshift에서 CONSTANT 키워드는 실행 중 변수 재할당을 방지합니다. Snowflake는 이 키워드를 지원하지 않으므로 변환 중에 제거됩니다. 로직이 상수 변수를 재할당하려고 시도해서는 안 되므로 기능에는 영향을 미치지 않습니다.

Redshift의 NOT NULL 제약 조건은 변수에 null 값을 할당할 수 없으며 기본값이 null이 아닌 값을 요구합니다. Snowflake는 이 제약 조건을 지원하지 않으므로 변환 중에 제거됩니다. 그러나 기능 유지를 위해 기본값은 유지됩니다.

레퍼런스를 사용한 변수 선언은 결과 집합 유형으로 변환됩니다. 자세한 내용은 정보를 참조하십시오.

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE VARIABLE_DECLARATION()
LANGUAGE plpgsql
AS $$
DECLARE
    v_simple_int INT;	
    v_default_char CHAR(4) DEFAULT 'ABCD';
    v_default_float FLOAT := 10.00;
    v_constant_char CONSTANT CHAR(4) := 'ABCD';
    v_notnull VARCHAR NOT NULL DEFAULT 'Test default';
    v_refcursor REFCURSOR;
BEGIN
-- Procedure logic
END;
$$;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE VARIABLE_DECLARATION ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
        DECLARE
            v_simple_int INT;
            v_default_char CHAR(4) DEFAULT 'ABCD';
            v_default_float FLOAT := 10.00;
            v_constant_char CHAR(4) := 'ABCD';
            --** SSC-FDM-PG0012 - NOT NULL CONSTRAINT HAS BEEN REMOVED. ASSIGNING NULL TO THIS VARIABLE WILL NO LONGER CAUSE A FAILURE. **
            v_notnull VARCHAR DEFAULT 'Test default';
            v_refcursor RESULTSET;
BEGIN
            NULL;
-- Procedure logic
END;
$$;

알려진 문제 ¶

문제가 발견되지 않았습니다.

TRANSACTIONS¶

COMMIT¶

설명¶

현재 트랜잭션을 데이터베이스에 커밋합니다. 이 명령은 트랜잭션에서 데이터베이스 업데이트를 영구적으로 생성합니다. (Redshift SQL Language Reference COMMIT)

문법 구문

COMMIT [WORK | TRANSACTION]

샘플 소스 패턴¶

설정 데이터¶

Redshift¶

쿼리¶

 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);

Snowflake¶

쿼리¶

 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);

TRANSACTION 키워드가 포함된 COMMIT¶

TRANSACTION 키워드는 Snowflake에서 지원되지 않습니다. 그러나 기능에는 영향을 미치지 않으므로 제거될 것입니다.

Redshift¶

쿼리¶

 COMMIT TRANSACTION;

Snowflake¶

쿼리¶

 COMMIT;

기본 트랜잭션 동작 프로시저의 COMMIT (NONATOMIC 절 미포함)¶

To avoid out of scope transaction exceptions in Snowflake, the usages of COMMIT will be matched with BEGIN TRANSACTION.

프로시저에 여러 개의 COMMIT 문이 있는 경우, Redshift 트랜잭션 동작을 에뮬레이션하기 위해 매 COMMIT 뒤에 여러 개의 BEGIN TRANSACTION 문이 생성됩니다.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test VALUES (a);
    COMMIT;
    INSERT INTO transaction_values_test VALUES (a + 1);
    COMMIT;
END
$$;

CALL transaction_test(120);

SELECT * FROM transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 120  |
| 121  |
+------+

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a);
    COMMIT;
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a + 1);
    COMMIT;
END
$$;

CALL transaction_test(120);

SELECT * FROM
    transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 120  |
| 121  |
+------+

COMMIT 동작이 있는 프로시저의 NONATOMIC¶

Redshift의 NONATOMIC 동작은 true으로 설정된 세션 매개 변수 AUTOCOMMIT 를 사용하여 Snowflake에서 에뮬레이션됩니다.

AUTOCOMMIT 세션 매개 변수는 SnowConvert AI에서 true로 간주되므로 NONATOMIC 프로시저 내부의 COMMIT 문은 있는 그대로 유지됩니다.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE nonatomic_procedure(a int)
    NONATOMIC
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a + 2);
    INSERT INTO transaction_values_test values (a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 12   |
| 13   |
+------+

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE nonatomic_procedure (a int)
RETURNS VARCHAR
--    --** SSC-FDM-RS0008 - SNOWFLAKE USES AUTOCOMMIT BY DEFAULT. **
--    NONATOMIC
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    INSERT INTO transaction_values_test
    values (:a + 2);
    INSERT INTO transaction_values_test
    values (:a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM
transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 12   |
| 13   |
+------+

Known Issues¶

1. 중첩 프로시저 호출 내의 COMMIT

Redshift에서 중첩 프로시저 호출에 COMMIT 문이 지정되면 이 명령은 현재 및 상위 항목 범위에 있는 이전 문에서 보류 중인 모든 작업을 커밋합니다. 상위 범위 작업을 커밋하는 것은 Snowflake에서 지원되지 않으며, 이 경우가 감지되면 FDM 이 생성됩니다.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test VALUES (a);
    COMMIT;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    INSERT INTO transaction_values_test values (a + 1);
    INSERT INTO transaction_values_test values (a + 2);
    CALL transaction_test(a + 3);
END
$$;

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a);
    COMMIT;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    INSERT INTO transaction_values_test
    values (:a);
    INSERT INTO transaction_values_test
    values (:a + 1);
    INSERT INTO transaction_values_test
    values (:a + 2);
    --** SSC-FDM-RS0006 - CALLED PROCEDURE CONTAINS USAGES OF COMMIT/ROLLBACK, MODIFYING THE CURRENT TRANSACTION IN CHILD SCOPES IS NOT SUPPORTED IN SNOWFLAKE **
    CALL transaction_test(:a + 3);
END
$$;

Known Issues¶

알려진 문제는 없습니다.

ROLLBACK¶

설명¶

현재 트랜잭션을 중지하고 해당 트랜잭션에서 수행한 모든 업데이트를 삭제합니다. (Redshift SQL Language Reference ROLLBACK)

문법 구문

ROLLBACK [WORK | TRANSACTION]

샘플 소스 패턴¶

설정 데이터¶

Redshift¶

쿼리¶

 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);

Snowflake¶

쿼리¶

 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);

TRANSACTION 키워드가 포함된 ROLLBACK¶

TRANSACTION 키워드는 Snowflake에서 지원되지 않습니다. 그러나 기능에는 영향을 미치지 않으므로 제거될 것입니다.

Redshift¶

쿼리¶

 ROLLBACK TRANSACTION;

Snowflake¶

쿼리¶

 ROLLBACK;

기본 트랜잭션 동작 프로시저의 ROLLBACK (NONATOMIC 절 미포함)¶

To avoid out of scope transaction exceptions in Snowflake, the usages of ROLLBACK will be matched with BEGIN TRANSACTION.

프로시저에 트랜잭션 제어 문이 여러 개 있는 경우, 각 문 뒤에 여러 개의 BEGIN TRANSACTION 문이 생성되어 Redshift 트랜잭션 동작을 에뮬레이션합니다.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    COMMIT;
    insert into transaction_values_test values (80);
    insert into transaction_values_test values (55);
    ROLLBACK;
END
$$;

CALL transaction_test(120);

SELECT * FROM transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 120  |
+------+

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test values (:a);
    COMMIT;
    BEGIN TRANSACTION;
    insert into transaction_values_test values (80);
    insert into transaction_values_test values (55);
    ROLLBACK;
END
$$;

CALL transaction_test(120);

SELECT * FROM
    transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 120  |
+------+

ROLLBACK 동작이 있는 프로시저의 NONATOMIC¶

Redshift의 NONATOMIC 동작은 true으로 설정된 세션 매개 변수 AUTOCOMMIT 를 사용하여 Snowflake에서 에뮬레이션됩니다.

AUTOCOMMIT 세션 매개 변수는 SnowConvert AI에서 true로 간주되므로 NONATOMIC 프로시저 내부의 ROLLBACK 문은 있는 그대로 유지됩니다.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE nonatomic_procedure(a int)
    NONATOMIC
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    INSERT INTO transaction_values_test values (a + 1);
    ROLLBACK;
    INSERT INTO transaction_values_test values (a + 2);
    INSERT INTO transaction_values_test values (a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 10   |
| 11   |
| 12   |
| 13   |
+------+

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE nonatomic_procedure (a int)
RETURNS VARCHAR
--    --** SSC-FDM-RS0008 - SNOWFLAKE USES AUTOCOMMIT BY DEFAULT. **
--    NONATOMIC
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    INSERT INTO transaction_values_test
    values (:a);
    INSERT INTO transaction_values_test
    values (:a + 1);
    ROLLBACK;
    INSERT INTO transaction_values_test
    values (:a + 2);
    INSERT INTO transaction_values_test
    values (:a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM
transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 10   |
| 11   |
| 12   |
| 13   |
+------+

Known Issues¶

1. 중첩 프로시저 호출 내의 ROLLBACK

Redshift에서 중첩 프로시저 호출에 ROLLBACK 문이 지정되면 이 명령은 현재 및 상위 항목 범위에 있는 이전 문에서 보류 중인 모든 작업을 커밋합니다. 상위 범위 작업을 커밋하는 것은 Snowflake에서 지원되지 않으며, 이 경우가 감지되면 FDM 이 생성됩니다.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test(a int)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    ROLLBACK;
    INSERT INTO transaction_values_test values (a + 1);
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test(a int)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    CALL transaction_test(a + 3);
    COMMIT;
END
$$;

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test (a int)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    values (:a);
    ROLLBACK;
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    values (:a + 1);
    COMMIT;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test (a int)
RETURNS VARCHAR
    LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    values (:a);
    --** SSC-FDM-RS0006 - CALLED PROCEDURE CONTAINS USAGES OF COMMIT/ROLLBACK, MODIFYING THE CURRENT TRANSACTION IN CHILD SCOPES IS NOT SUPPORTED IN SNOWFLAKE **
    CALL transaction_test(:a + 3);
    COMMIT;
END
$$;

2. DDL 문의 ROLLBACK

In Snowflake, DDL statements perform an implicit commit whenever they are executed inside a procedure, making effective all the work before executing the DDL as well as the DDL itself. This causes the ROLLBACK statement to not be able to discard any changes before that point, this issue will be informed using an FDM.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE rollback_ddl(a int)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    CREATE TABLE someRollbackTable
    (
        col1 INTEGER
    );

    INSERT INTO someRollbackTable values (a);
    ROLLBACK;
END
$$;

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE rollback_ddl (a int)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    values (:a);
    CREATE TABLE someRollbackTable
    (
        col1 INTEGER
    );
    BEGIN TRANSACTION;
    INSERT INTO someRollbackTable
    values (:a);
    --** SSC-FDM-RS0007 - DDL STATEMENTS PERFORM AN AUTOMATIC COMMIT IN SNOWFLAKE. ROLLBACK WILL NOT UNDO DDL-COMMITTED CHANGES. **
    ROLLBACK;
END
$$;

Known Issues¶

알려진 문제는 없습니다.

TRUNCATE¶

설명¶

테이블 스캔을 수행하지 않고 테이블에서 모든 행을 삭제합니다. (Redshift SQL Language Reference TRUNCATE)

문법 구문

TRUNCATE [TABLE] table_name

샘플 소스 패턴¶

설정 데이터¶

Redshift¶

쿼리¶

 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);

Snowflake¶

쿼리¶

 CREATE TABLE transaction_values_test
(
    col1 INTEGER
);

기본 트랜잭션 동작 프로시저의 TRUNCATE (NONATOMIC 절 미포함)¶

TRUNCATE 문은 실행되는 트랜잭션을 자동으로 커밋하므로, 이 문을 사용하면 이 동작을 에뮬레이션하기 위해 Snowflake가 COMMIT 문을 생성합니다.

COMMIT 문이 생성되었으므로 TRUNCATE 에도 동일한 BEGIN TRANSACTION 문 생성이 적용됩니다. 자세한 내용은 COMMIT 변환 사양을 참조하십시오.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE truncate_in_procedure(a int)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test VALUES (a);
    TRUNCATE TABLE transaction_values_test;
    INSERT INTO transaction_values_test VALUES (a + 12);
    COMMIT;
END
$$;

CALL truncate_in_procedure(10);

SELECT * FROM transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 22   |
+------+

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE truncate_in_procedure (a int)
RETURNS VARCHAR
    LANGUAGE SQL
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a);
    TRUNCATE TABLE transaction_values_test;
    COMMIT;
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a + 12);
    COMMIT;
END
$$;

CALL truncate_in_procedure(10);

SELECT * FROM
    transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 22   |
+------+

TRUNCATE 동작이 있는 프로시저의 NONATOMIC¶

Redshift의 NONATOMIC 동작은 true으로 설정된 세션 매개 변수 AUTOCOMMIT 를 사용하여 Snowflake에서 에뮬레이션됩니다.

Since the AUTOCOMMIT session parameter is assumed to be true by SnowConvert AI, the TRUNCATE statement inside NONATOMIC procedures is left as is, there is no need to generate a COMMIT statement because every statement is automatically committed when executed.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE nonatomic_procedure(a int)
    NONATOMIC
    LANGUAGE plpgsql
    AS $$
BEGIN
    TRUNCATE TABLE transaction_values_test;
    INSERT INTO transaction_values_test values (a);
    INSERT INTO transaction_values_test values (a + 1);
    ROLLBACK;
    INSERT INTO transaction_values_test values (a + 2);
    INSERT INTO transaction_values_test values (a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 10   |
| 11   |
| 12   |
| 13   |
+------+

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE nonatomic_procedure (a int)
RETURNS VARCHAR
--    --** SSC-FDM-RS0008 - SNOWFLAKE USES AUTOCOMMIT BY DEFAULT. **
--    NONATOMIC
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    TRUNCATE TABLE transaction_values_test;
    INSERT INTO transaction_values_test
    values (:a);
    INSERT INTO transaction_values_test
    values (:a + 1);
    ROLLBACK;
    INSERT INTO transaction_values_test
    values (:a + 2);
    INSERT INTO transaction_values_test
    values (:a + 3);
    COMMIT;
END
$$;

CALL nonatomic_procedure(10);

SELECT * FROM
transaction_values_test;

결과¶

+------+
| col1 |
+------+
| 10   |
| 11   |
| 12   |
| 13   |
+------+

Known Issues¶

1. 중첩 프로시저 호출 내의 TRUNCATE

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test VALUES (a);
    TRUNCATE TABLE transaction_values_test;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test(a INT)
    LANGUAGE plpgsql
    AS $$
BEGIN
    INSERT INTO transaction_values_test values (a);
    INSERT INTO transaction_values_test values (a + 1);
    INSERT INTO transaction_values_test values (a + 2);
    CALL transaction_test(a + 3);
END
$$;

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    BEGIN TRANSACTION;
    INSERT INTO transaction_values_test
    VALUES (:a);
    TRUNCATE TABLE transaction_values_test;
    COMMIT;
END
$$;

CREATE OR REPLACE PROCEDURE nested_transaction_test (a INT)
RETURNS VARCHAR
    LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
    AS $$
BEGIN
    INSERT INTO transaction_values_test
    values (:a);
    INSERT INTO transaction_values_test
    values (:a + 1);
    INSERT INTO transaction_values_test
    values (:a + 2);
    --** SSC-FDM-RS0006 - CALLED PROCEDURE CONTAINS USAGES OF COMMIT/ROLLBACK, MODIFYING THE CURRENT TRANSACTION IN CHILD SCOPES IS NOT SUPPORTED IN SNOWFLAKE **
    CALL transaction_test(:a + 3);
END
$$;

Known Issues¶

알려진 문제는 없습니다.

CONDITIONS¶

CASE¶

설명¶

Redshift의 CASE 문을 사용하면 조건에 따라 값을 반환할 수 있으므로 쿼리에서 조건부 논리를 사용할 수 있습니다. 단순과 검색의 두 가지 형태가 있습니다. (Redshift SQL Language Reference 조건부: 대/소문자).

단순 케이스¶

간단한 CASE 문은 피연산자의 동등성에 따라 조건부 실행을 제공합니다.

참고

Simple Case는 Snowflake 에서 완벽하게 지원됩니다.

문법 구문¶

 CASE search-expression
WHEN expression [, expression [ ... ]] THEN
  statements
[ WHEN expression [, expression [ ... ]] THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE proc1(x INT)
LANGUAGE plpgsql
AS $$
BEGIN
  CASE x
WHEN 1, 2 THEN
  NULL;
ELSE
  NULL;
END CASE;                  
END;
$$;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE proc1 (x INT)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/14/2025",  "domain": "test" }}'
AS $$
BEGIN
  CASE x
    WHEN 1 THEN
      NULL;
    WHEN 2 THEN
      NULL;
   ELSE
     NULL;
  END CASE;
END;
$$;

검색된 케이스¶

참고

Searched Case는 Snowflake 에서 완벽하게 지원됩니다.

문법 구문¶

 CASE
WHEN boolean-expression THEN
  statements
[ WHEN boolean-expression THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE PROCEDURE PROC1 (paramNumber int)
LANGUAGE plpgsql
AS $$
DECLARE
    result VARCHAR(100);	
BEGIN
CASE
  WHEN paramNumber BETWEEN 0 AND 10 THEN
    result := 'value is between zero and ten';
  WHEN paramNumber BETWEEN 11 AND 20 THEN
    result := 'value is between eleven and twenty';
  END CASE;  
END;
$$;

출력 코드:¶

Redshift¶

 CREATE PROCEDURE PROC1 (paramNumber int)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
    DECLARE
      result VARCHAR(100);
      case_not_found EXCEPTION (-20002, 'Case not found.');
BEGIN
CASE
  WHEN paramNumber BETWEEN 0 AND 10 THEN
    result := 'value is between zero and ten';
  WHEN paramNumber BETWEEN 11 AND 20 THEN
    result := 'value is between eleven and twenty';
  ELSE
    RAISE case_not_found;
  END CASE;
END;
$$;

ELSE을 제외한 CASE¶

Redshift에서 CASE 식이 실행되고 유효성 검사된 조건이 충족되지 않고 ELSE 가 정의되지 않은 경우 예외 ‘CASENOTFOUND’가 트리거됩니다. Snowflake에서는 코드가 실행되지만 결과가 반환되지 않습니다. 이 시나리오에서 Snowflake에서 동일한 기능을 유지하기 위해 CASE 조건이 충족되지 않으면 같은 이름의 예외가 선언되고 실행됩니다.

참고

Case Without Else는 Snowflake 에서 완벽하게 지원됩니다.

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE procedure1 (input_value INT)
AS $$
BEGIN
  CASE input_value
  WHEN 1 THEN
   NULL;
  END CASE;
END;
$$ LANGUAGE plpgsql;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE procedure1 (input_value INT)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
    DECLARE
      case_not_found EXCEPTION (-20002, 'Case not found.');
BEGIN
  CASE input_value
  WHEN 1 THEN
   NULL;
  ELSE
   RAISE case_not_found;
  END CASE;
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

IF¶

설명¶

이 문을 사용하면 특정 조건에 따라 결정을 내릴 수 있습니다. (Redshift SQL Language Reference 조건문: IF).

Redshift는 조건에 괄호가 필요하지 않고 ELSIF가 키워드이므로 SnowConvert AI는 조건에 괄호를 추가하고 키워드 ELSIF를 ELSEIF로 변경합니다.

문법 구문¶

 IF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
    ...] ]
[ ELSE
  statements ]
END IF;

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE PROCEDURE PROC1 (paramNumber int)
LANGUAGE plpgsql
AS $$
DECLARE
    result VARCHAR(100);	
BEGIN
    IF paramNumber = 0 THEN
      result := 'zero';
    ELSIF paramNumber > 0 THEN
      result := 'positive';
    ELSIF paramNumber < 0 THEN
      result := 'negative';
    ELSE
      result := 'NULL';
    END IF;
END;
$$;

출력 코드:¶

Redshift¶

 CREATE PROCEDURE PROC1 (paramNumber int)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
        DECLARE
            result VARCHAR(100);
BEGIN
            IF (:paramNumber = 0) THEN
                result := 'zero';
            ELSEIF (:paramNumber > 0) THEN
                result := 'positive';
            ELSEIF (:paramNumber < 0) THEN
                result := 'negative';
              ELSE
                result := 'NULL';
            END IF;
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

LOOPS¶

설명¶

이러한 문은 지정된 조건이 될 때까지 코드 블록을 반복하는 데 사용됩니다. (Redshift SQL Language Reference 루프).

CONTINUE FOR LOOP WHILE EXIT

CONTINUE¶

설명¶

CONTINUE 조건이 true이면 루프가 실행을 계속할 수 있고, false이면 루프가 중지됩니다. (Redshift SQL Language Reference 조건문: CONTINUE).

경고

CONTINUE 는 Snowflake 에서 부분적으로 지원됩니다.

문법 구문¶

 CONTINUE [ label ] [ WHEN expression ];

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE procedure1 (x INT)
    LANGUAGE plpgsql
AS $$
DECLARE
    i INTEGER := 0;
BEGIN
    <<simple_loop_when>>
    LOOP
        i := i + 1;
        CONTINUE WHEN i = 5;
        RAISE INFO 'i %', i;
        EXIT simple_loop_when WHEN (i >= x);
    END LOOP;
END;
$$;

CREATE OR REPLACE PROCEDURE procedure11 (x INT)
    LANGUAGE plpgsql
AS $$
DECLARE
    i INTEGER := 0;
BEGIN
    LOOP
        i := i + 1;
		IF (I = 5) THEN 
        	CONTINUE;
		END IF;
        RAISE INFO 'i %', i;
        EXIT WHEN (i >= x);
    END LOOP;
END;
$$;

결과¶


콘솔 출력
1
2
3
4
6
7

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE procedure1 (x INT)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
    		DECLARE
    			i INTEGER := 0;
BEGIN
    			--** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
    LOOP
        i := i + 1;
        IF (:i = 5) THEN
        	CONTINUE;
        END IF;
        CALL RAISE_MESSAGE_UDF('INFO', 'i %', array_construct(:i));
        IF ((:i >= : x)) THEN
        	EXIT simple_loop_when;
        END IF;
    END LOOP simple_loop_when;
END;
$$;

CREATE OR REPLACE PROCEDURE procedure11 (x INT)
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
    		DECLARE
    			i INTEGER := 0;
BEGIN
    			--** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
    LOOP
        i := i + 1;
		IF (:I = 5) THEN
        	CONTINUE;
		END IF;
        CALL RAISE_MESSAGE_UDF('INFO', 'i %', array_construct(:i));
        IF ((:i >= : x)) THEN
        	EXIT;
        END IF;
    END LOOP;
END;
$$;

결과¶


콘솔 출력
1
2
3
4
6
7

Known Issues¶

알려진 문제는 없습니다.

EXIT¶

설명¶

WHEN 문에 정의된 조건이 true이면 루프 실행을 중지합니다. (Redshift SQL Language Reference 조건문: EXIT).

경고

EXIT 는 Snowflake 에서 부분적으로 지원됩니다.

문법 구문¶

 EXIT [ label ] [ WHEN expression ];

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE simple_loop_when(x int)
LANGUAGE plpgsql
AS $$
DECLARE i INTEGER := 0;
BEGIN
  <<simple_loop_when>>
  LOOP
    RAISE INFO 'i %', i;
    i := i + 1;
    EXIT simple_loop_when WHEN (i >= x);
  END LOOP;
END;
$$;   

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE simple_loop_when (x int)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
    DECLARE
      i INTEGER := 0;
BEGIN
      --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
  LOOP
        CALL RAISE_MESSAGE_UDF('INFO', 'i %', array_construct(:i));
    i := i + 1;
        IF ((:i >= : x)) THEN
          EXIT simple_loop_when;
        END IF;
  END LOOP simple_loop_when;
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

FOR¶

문법 구문¶

정수 베리언트

 [<<label>>]
FOR name IN [ REVERSE ] expression .. expression LOOP
  statements
END LOOP [ label ];

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE procedure1 ()
AS $$
BEGIN
  FOR i IN 1..10 LOOP
    NULL;
  END LOOP;

  FOR i IN REVERSE 10..1 LOOP
    NULL;
  END LOOP;
END;
$$ LANGUAGE plpgsql;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE procedure1 ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
BEGIN
  FOR i IN 1 TO 10
                   --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
                   LOOP
    NULL;
  END LOOP;

  FOR i IN REVERSE 10 TO 1
                           --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
                           LOOP
    NULL;
  END LOOP;
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

LOOP¶

설명¶

단순 루프는 EXIT 또는 RETURN 문으로 종료될 때까지 무한히 반복되는 무조건 루프를 정의합니다. (Redshift SQL Language Reference 조건문: Simple Loop).

경고

Simple Loop는 Snowflake 에서 부분적으로 지원됩니다.

문법 구문¶

 [<<label>>]
LOOP
  statements
END LOOP [ label ];

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE simple_loop()
LANGUAGE plpgsql
AS $$
BEGIN
  <<simple_while>>
  LOOP
    RAISE INFO 'I am raised once';  
    EXIT simple_while;
    RAISE INFO 'I am not raised';
  END LOOP;
  RAISE INFO 'I am raised once as well';
END;
$$;   

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE simple_loop ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
BEGIN
  --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
  LOOP
    CALL RAISE_MESSAGE_UDF('INFO', 'I am raised once');
    EXIT simple_while;
    CALL RAISE_MESSAGE_UDF('INFO', 'I am not raised');
  END LOOP simple_while;
  CALL RAISE_MESSAGE_UDF('INFO', 'I am raised once as well');
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

WHILE¶

문법 구문¶

 [<<label>>]
WHILE expression LOOP
  statements
END LOOP [ label ];

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE simple_loop_when()
    LANGUAGE plpgsql
AS $$
DECLARE
    i INTEGER := 0;
BEGIN
    WHILE I > 5 AND I > 10 LOOP
        NULL;
    END LOOP;   
END;
$$;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE simple_loop_when ()
RETURNS VARCHAR
    LANGUAGE SQL
    COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
            DECLARE
                i INTEGER := 0;
BEGIN
                WHILE (:I > 5 AND : I > 10)
                                            --** SSC-PRF-0008 - PERFORMANCE REVIEW - LOOP USAGE **
                                            LOOP
        NULL;
    END LOOP;
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

CURSORS¶

CLOSE CURSOR¶

설명¶

열린 커서와 연결된 모든 무료 리소스를 닫습니다. (Redshift SQL Language Reference 커서 닫기).

참고

이 구문은 Snowflake에서 완벽하게 지원됩니다.

문법 구문¶

 CLOSE cursor

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
   CLOSE cursor1;
END;
$$;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE cursor_test ()
RETURNS VARCHAR
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/05/2025",  "domain": "test" }}'
AS $$
BEGIN
   CLOSE cursor1;
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

FETCH CURSOR¶

설명¶

커서를 사용하여 행을 검색합니다. (Redshift SQL Language reference 가져오기)

변환 정보

 FETCH [ NEXT | ALL | {FORWARD [ count | ALL ] } ] FROM cursor

FETCH cursor INTO target [, target ...];

샘플 소스 패턴¶

설정 데이터¶

Redshift¶

쿼리¶

 CREATE TABLE cursor_example
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

INSERT INTO cursor_example VALUES (10, 'hello');

Snowflake¶

쿼리¶

 CREATE TABLE cursor_example
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

INSERT INTO cursor_example VALUES (10, 'hello');

Fetch into¶

Redshift에서 문의 FETCH 는 Snowflake에서와 완전히 동일합니다

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE fetch_into_example()
LANGUAGE plpgsql
AS $$
DECLARE my_cursor CURSOR FOR
        SELECT col1, col2
        FROM cursor_example;
        some_id INT;
        message VARCHAR(20);
BEGIN
    OPEN my_cursor;
    FETCH my_cursor INTO some_id, message;
    CLOSE my_cursor;
    INSERT INTO cursor_example VALUES (some_id * 10, message || ' world!');
END;
$$;

CALL fetch_into_example();

SELECT * FROM cursor_example;

결과¶

+------+-------------+
| col1 | col2        |
+------+-------------+
| 10   | hello       |
| 100  | hello world!|
+------+-------------+

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE fetch_into_example ()
RETURNS VARCHAR
LANGUAGE SQL
AS $$
DECLARE
    my_cursor CURSOR FOR
    SELECT col1, col2
    FROM
    cursor_example;
    some_id INT;
    message VARCHAR(20);
BEGIN
    OPEN my_cursor;
    FETCH my_cursor INTO some_id, message;
    CLOSE my_cursor;
    INSERT INTO cursor_example
			VALUES (:some_id * 10, :message || ' world!');
END;
$$;

CALL fetch_into_example();

SELECT * FROM
	cursor_example;

결과¶

+------+-------------+
| col1 | col2        |
+------+-------------+
| 10   | hello       |
| 100  | hello world!|
+------+-------------+

Known Issues¶

1. 대상 변수가 없는 가져오기는 지원되지 않습니다

Snowflake는 FETCH 문에 INTO 절을 가져온 행 값을 저장할 변수와 함께 지정해야 합니다. 코드에 INTO 절이 없는 FETCH 문이 발견되면 EWI 가 생성됩니다.

입력 코드:

 FETCH FORWARD FROM cursor1;

출력 코드:

 !!!RESOLVE EWI!!! /*** SSC-EWI-PG0015 - FETCH CURSOR WITHOUT TARGET VARIABLES IS NOT SUPPORTED IN SNOWFLAKE ***/!!!
FETCH FORWARD FROM cursor1;

Known Issues¶

알려진 문제는 없습니다.

OPEN CURSOR¶

설명¶

커서를 사용하여 행을 검색하려면 먼저 커서를 열어야 합니다. (Redshift SQL Language Reference 커서 열기).

참고

이 구문은 Snowflake에서 완벽하게 지원됩니다.

문법 구문¶

 OPEN bound_cursor_name [ ( argument_values ) ];

샘플 소스 패턴¶

설정 데이터¶

Redshift¶

쿼리¶

 CREATE TABLE cursor_example
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

CREATE TABLE cursor_example_results
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

INSERT INTO cursor_example VALUES (10, 'hello');

Snowflake¶

쿼리¶

 CREATE TABLE cursor_example
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

CREATE TABLE cursor_example_results
(
	col1 INTEGER,
	col2 VARCHAR(20)
);

INSERT INTO cursor_example VALUES (10, 'hello');

인자 없이 커서 열기¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
BEGIN
   OPEN cursor1;
END;
$$;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE cursor_test ()
RETURNS VARCHAR
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "02/05/2025",  "domain": "test" }}'
AS $$
BEGIN
   OPEN cursor1;
END;
$$;

인자가 있는 커서 열기¶

Cursor arguments have to be bound per each one of its uses, SnowConvert AI will generate the bindings, as well as reorder and repeat the passed values to the OPEN statement as needed to satisfy the bindings.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE cursor_open_test()
LANGUAGE plpgsql
AS $$
DECLARE
    cursor2 CURSOR (val1 VARCHAR(20), val2 INTEGER) FOR SELECT col1 + val2, col2 FROM cursor_example where val1 = col2 and val2 > col1;
    res1 INTEGER;
    res2 VARCHAR(20);
BEGIN
    OPEN cursor2('hello', 50);
    FETCH cursor2 INTO res1, res2;
    CLOSE cursor2;
    INSERT INTO cursor_example_results VALUES (res1, res2);
END;
$$;

call cursor_open_test();

SELECT * FROM cursor_example_results;

결과¶

+------+-------+
| col1 | col2  |
+------+-------+
| 60   | hello |
+------+-------+

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE cursor_open_test ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
        DECLARE
            cursor2 CURSOR FOR SELECT col1 + ?, col2 FROM
                cursor_example
            where
                ? = col2 and ? > col1;
            res1 INTEGER;
            res2 VARCHAR(20);
BEGIN
    OPEN cursor2 USING (50, 'hello', 50);
    FETCH cursor2 INTO res1, res2;
    CLOSE cursor2;
    INSERT INTO cursor_example_results
            VALUES (:res1, : res2);
END;
$$;

call cursor_open_test();
SELECT * FROM
cursor_example_results;

결과¶

+------+-------+
| col1 | col2  |
+------+-------+
| 60   | hello |
+------+-------+

프로시저 매개 변수 또는 로컬 변수가 있는 커서 열기¶

The procedure parameters or local variables have to be bound per each one of its uses in the cursor query, SnowConvert AI will generate the bindings and add the parameter or variable names to the OPEN statement, even if the cursor originally had no parameters.

Redshift¶

쿼리¶

 CREATE OR REPLACE PROCEDURE cursor_open_test(someValue iNTEGER)
LANGUAGE plpgsql
AS $$
DECLARE
    charVariable VARCHAR(20) DEFAULT 'hello';
    cursor2 CURSOR FOR SELECT col1 + someValue, col2 FROM cursor_example where charVariable = col2 and someValue > col1;
    res1 INTEGER;
    res2 VARCHAR(20);
BEGIN
    OPEN cursor2;
    FETCH cursor2 INTO res1, res2;
    CLOSE cursor2;
    INSERT INTO cursor_example_results VALUES (res1, res2);
END;
$$;

call cursor_open_test(30);

결과¶

+------+-------+
| col1 | col2  |
+------+-------+
| 40   | hello |
+------+-------+

Snowflake¶

쿼리¶

 CREATE OR REPLACE PROCEDURE cursor_open_test (someValue iNTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}'
AS $$
        DECLARE
            charVariable VARCHAR(20) DEFAULT 'hello';
            cursor2 CURSOR FOR SELECT col1 + ?, col2 FROM
                cursor_example
            where
                ? = col2 and ? > col1;
            res1 INTEGER;
            res2 VARCHAR(20);
BEGIN
    OPEN cursor2 USING (someValue, charVariable, someValue);
    FETCH cursor2 INTO res1, res2;
    CLOSE cursor2;
    INSERT INTO cursor_example_results
            VALUES (:res1, : res2);
END;
$$;

call cursor_open_test(30);

결과¶

+------+-------+
| col1 | col2  |
+------+-------+
| 40   | hello |
+------+-------+

Known Issues¶

알려진 문제는 없습니다.

DECLARE CURSOR¶

설명¶

새 커서를 정의합니다. 커서를 사용하여 더 큰 쿼리 결과 세트에서 한 번에 몇 행씩 검색할 수 있습니다. (Redshift SQL Language Reference 커서 선언).

참고

이 구문은 Snowflake에서 완벽하게 지원됩니다.

문법 구문¶

 name CURSOR [ ( arguments ) ] FOR query 

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE cursor_test()
AS $$
DECLARE
   -- Declare the cursor
   cursor1 CURSOR FOR SELECT 1;
   cursor2 CURSOR (key integer) FOR SELECT 2 where 1 = key;
   
BEGIN
END;
$$;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE cursor_test ()
RETURNS VARCHAR
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
      DECLARE
         -- Declare the cursor
         cursor1 CURSOR FOR SELECT 1;
         cursor2 CURSOR FOR SELECT 2 where 1 = ?;
BEGIN
         NULL;
END;
$$;

Known Issues¶

알려진 문제는 없습니다.

DECLARE REFCURSOR¶

설명¶

refcursor 데이터 타입은 단순히 커서에 대한 참조를 보관합니다. 커서 변수를 refcursor 유형의 변수로 선언하여 생성할 수 있습니다

(Redshift SQL Language Reference Refcursor 선언)

참고

Refcursor 선언은 Snowflake 에서 완벽하게 지원됩니다.

문법 구문¶

 DECLARE
name refcursor;

Snowflake는 REFCURSOR 데이터 타입을 지원하지 않으므로 REFCURSOR 변수를 RESULTSET 타입으로 변환하여 기능을 복제합니다. REFCURSOR 페이지를 여는 데 사용되는 쿼리는 RESULTSET 변수에 할당된 후 새 커서가 생성되어 RESULTSET 변수에 링크됩니다. 또한 커서 로직 내에서 원본 REFCURSOR 에 대한 모든 참조가 새 커서를 사용하도록 업데이트되어 원래 기능을 복제합니다.

샘플 소스 패턴¶

케이스: 1회 사용¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR()
LANGUAGE plpgsql
AS $$
DECLARE
  v_curs1 refcursor;
BEGIN
  OPEN v_curs1 FOR SELECT column1_name, column2_name FROM your_table;
-- Cursor logic
  CLOSE v_curs1;
 END;
$$;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
  DECLARE
   v_curs1 RESULTSET;
BEGIN
   v_curs1 := (
    SELECT column1_name, column2_name FROM your_table
   );
   LET v_curs1_Resultset_1 CURSOR
   FOR
    v_curs1;
   OPEN v_curs1_Resultset_1;
-- Cursor logic
  CLOSE v_curs1_Resultset_1;
 END;
$$;

케이스: 동적 Sql이 있는 커서 ¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR_DYNAMIC(min_salary NUMERIC)
LANGUAGE plpgsql
AS $$
DECLARE
    cur refcursor;
    qry TEXT;
BEGIN
    qry := 'SELECT id, name FROM employees WHERE salary > ' || min_salary;

    OPEN cur FOR EXECUTE qry;
-- Cursor logic
    CLOSE cur;
END;
$$;


CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR_DYNAMIC2(min_salary NUMERIC)
LANGUAGE plpgsql
AS $$
DECLARE
    cur refcursor;
BEGIN
    OPEN cur FOR EXECUTE 'SELECT id, name FROM employees WHERE salary > ' || min_salary;
-- Cursor logic
    CLOSE cur;
END;
$$;

출력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR_DYNAMIC (min_salary NUMERIC)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
        DECLARE
            cur RESULTSET;
    qry TEXT;
BEGIN
    qry := 'SELECT id, name FROM employees WHERE salary > ' || min_salary;
            cur := (
                EXECUTE IMMEDIATE qry
            );
            LET cur_Resultset_1 CURSOR
            FOR
                cur;
            OPEN cur_Resultset_1;
-- Cursor logic
    CLOSE cur_Resultset_1;
END;
$$;


CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR_DYNAMIC2 (min_salary NUMERIC)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
        DECLARE
            cur RESULTSET;
BEGIN
            cur := (
                EXECUTE IMMEDIATE 'SELECT id, name FROM employees WHERE salary > ' || min_salary
            );
            LET cur_Resultset_2 CURSOR
            FOR
                cur;
            OPEN cur_Resultset_2;
-- Cursor logic
    CLOSE cur_Resultset_2;
END;
$$;

케이스: 여러 번 사용: ¶

입력 코드:¶

Redshift¶

 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR()
LANGUAGE plpgsql
AS $$
DECLARE
  v_curs1 refcursor;
BEGIN
  OPEN v_curs1 FOR SELECT column1_name, column2_name FROM your_table;
-- Cursor logic
  CLOSE v_curs1;
  OPEN v_curs1 FOR SELECT column3_name, column4_name FROM your_table2;
-- Cursor logic
  CLOSE v_curs1;
 END;
$$;

출력 코드:¶

Snowflake¶

 CREATE OR REPLACE PROCEDURE VARIABLE_REFCURSOR ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "03/03/2025",  "domain": "test" }}'
AS $$
  DECLARE
   v_curs1 RESULTSET;
BEGIN
   v_curs1 := (
    SELECT column1_name, column2_name FROM your_table
   );
   LET v_curs1_Resultset_1 CURSOR
   FOR
    v_curs1;
   OPEN v_curs1_Resultset_1;
-- Cursor logic
  CLOSE v_curs1_Resultset_1;
   v_curs1 := (
    SELECT column3_name, column4_name FROM your_table2
   );
   LET v_curs1_Resultset_2 CURSOR
   FOR
    v_curs1;
   OPEN v_curs1_Resultset_2;
-- Cursor logic
  CLOSE v_curs1_Resultset_2;
 END;
$$;

Known Issues¶

알려진 문제는 없습니다.

SnowConvert AI - Redshift - CREATE PROCEDURE¶

설명¶

문법 구문¶

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

출력 코드:¶

Snowflake¶

관련 EWIs¶

ALIAS DECLARATION¶

설명¶

문법 구문¶

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

출력 코드:¶

Snowflake¶

Known Issues¶

관련 EWIs.¶

ARGUMENTS MODE¶

설명¶

IN (입력 매개 변수)¶

OUT (출력 매개 변수)¶

INOUT (입력/출력 매개 변수)¶

문법 구문¶

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

출력 코드:¶

Snowflake¶

Known Issues¶

관련 EWIs¶

PROCEDURE BODY¶

설명¶

문법 구문¶

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

출력 코드:¶

Snowflake¶

Known Issues¶

관련 EWIs.¶

BLOCK STATEMENT¶

설명¶

문법 구문¶

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

출력 코드:¶

Snowflake¶

Known Issues¶

관련 EWIs.¶

DECLARE¶

설명¶

문법 구문¶

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

출력 코드:¶

Snowflake¶

Known Issues¶

관련 EWIs.¶

EXCEPTION¶

설명¶

문법 구문¶

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

출력 코드:¶

Snowflake¶

Known Issues¶

관련 EWIs.¶

LABEL¶

설명¶

문법 구문¶

샘플 소스 패턴¶

입력 코드:¶

Redshift¶

출력 코드:¶

Snowflake¶