SnowConvert AI - SQL Server - CREATE FUNCTION¶
Transact-SQL 사용자 정의 함수에 대한 변환 참조
Applies to
SQL 서버
Azure 시냅스 분석
설명¶
SQL 서버는 두 가지 유형의 사용자 정의 함수 만 지원합니다.
이러한 UDFs 타입 사용하여 내부 논리에 따라 단순 및 복합** 으로 세분화할 수 있습니다.
단순 UDFs는 SQL Server 구문을 Snowflake 구문과 일치시킵니다. 이 유형은 논리를 추가하지 않으며 결과로 바로 이동합니다. 이는 일반적으로 Snowflake의 SQL UDFs와 일치합니다. SnowConvert는 특정 기준을 충족하는 경우 SQL Server 스칼라 사용자 정의 함수를 Snowflake Scripting UDFs로 직접 변환하도록 지원합니다.\ \ 복합 UDFs는 특정 문(INSERT, DELETE, UPDATE, SET, DECLARE 등) 또는 control-of-flow 블록(IF…ELSE, WHILE 등)을 포괄적으로 사용하고 일반적으로 Snowflake의 SQL UDFs 정의에 대한 불일치나 위반을 나타냅니다.
제한 사항¶
Transact UDFs 에는 다른 데이터베이스 엔진(Oracle 및 Tera데이터 등)에는 없는 몇 가지 제한 사항이 있습니다. 이러한 제한은 실패 범위를 좁혀 변환에 도움이 됩니다. 즉, 피해야 할 특정 시나리오가 있습니다.
SQL 서버의 UDFs 에 적용되는 몇 가지 제한 사항은 다음과 같습니다
UDFs 는 데이터베이스 상태를 수정하는 작업을 수행하는 데 사용할 수 없습니다
사용자 정의 함수에는 테이블을 대상으로 하는 OUTPUT INTO 절을 포함할 수 없습니다
사용자 정의 함수는 여러 결과 세트를 반환할 수 없습니다. 여러 결과 세트를 반환해야 하는 경우 저장 프로시저를 사용합니다.
전체 목록은 이 링크 사용자 정의 함수 생성(데이터베이스 엔진)에서 확인할 수 있습니다
INLINE TABLE-VALUED¶
TABLE 반환 유형이 있는 Transact-SQL UDF(사용자 정의 함수)를 Snowflake로 변환하기 위한 변환 참조
Applies to
SQL 서버
Azure 시냅스 분석
설명¶
참고
출력 코드의 일부 부분은 명확성을 위해 생략되었습니다.
인라인 테이블-값 함수는 매개 변수를 받고 SELECT 문을 수행하며 TABLE (SQL Server Language Reference 인라인 테이블 값 함수 만들기) 을 반환합니다.
Transact 구문¶
-- Transact-SQL Inline Table-Valued Function Syntax
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name
( [ { @parameter_name [ AS ] [ type_schema_name. ] parameter_data_type
[ = default ] [ READONLY ] }
[ ,...n ]
]
)
RETURNS TABLE
[ WITH <function_option> [ ,...n ] ]
[ AS ]
RETURN [ ( ] select_stmt [ ) ]
[ ; ]
Snowflake SQL 구문¶
CREATE OR REPLACE FUNCTION <name> ( [ <arguments> ] )
RETURNS TABLE ( <output_col_name> <output_col_type> [, <output_col_name> <output_col_type> ... ] )
AS '<sql_expression>'sql
샘플 소스 패턴¶
다음 섹션에서는 이러한 종류의 CREATE FUNCTION 구문에 나타날 수 있는 모든 가능한 소스 코드 패턴에 대해 설명합니다.
인라인 테이블-값 함수의 경우 본문당 1개의 문만 존재할 수 있습니다.
SELECT문WITH일반적인 테이블 식
1개의 테이블에서 직접 선택 및 반환 값 가져오기¶
가장 간단한 시나리오로, 테이블에서 간단한 선택을 수행하고 해당 값을 반환합니다
Transact-SQL¶
인라인 테이블 값¶
CREATE FUNCTION GetDepartmentInfo()
RETURNS TABLE
AS
RETURN
(
SELECT DepartmentID, Name, GroupName
FROM HumanResources.Department
);
GO
SELECT * from GetDepartmentInfo()
결과¶
DepartmentID |
이름 |
GroupName |
|---|---|---|
1 |
Engineering |
연구 및 개발 |
2 |
도구 설계 |
연구 및 개발 |
3 |
Sales |
영업 및 마케팅 |
4 |
마케팅 |
영업 및 마케팅 |
5 |
구매 |
재고 관리 |
6 |
연구 및 개발 |
연구 및 개발 |
7 |
프로덕션 |
Manufacturing |
8 |
생산 관리 |
Manufacturing |
9 |
인적 리소스 |
총괄 관리자 및 관리자 |
10 |
Finance |
총괄 관리자 및 관리자 |
11 |
정보 서비스 |
총괄 관리자 및 관리자 |
12 |
문서 제어 |
품질 보증 |
13 |
품질 보증 |
품질 보증 |
14 |
시설 및 유지 관리 |
총괄 관리자 및 관리자 |
15 |
배송 및 수령 |
재고 관리 |
16 |
실행 |
총괄 관리자 및 관리자 |
Snowflake SQL¶
인라인 테이블 값¶
CREATE OR REPLACE FUNCTION GetDepartmentInfo ()
RETURNS TABLE(
DepartmentID STRING /*** SSC-FDM-TS0012 - INFORMATION FOR THE COLUMN DepartmentID WAS NOT FOUND. STRING DATATYPE USED TO MATCH CAST AS STRING OPERATION ***/,
Name STRING /*** SSC-FDM-TS0012 - INFORMATION FOR THE COLUMN Name WAS NOT FOUND. STRING DATATYPE USED TO MATCH CAST AS STRING OPERATION ***/,
GroupName STRING /*** SSC-FDM-TS0012 - INFORMATION FOR THE COLUMN GroupName WAS NOT FOUND. STRING DATATYPE USED TO MATCH CAST AS STRING OPERATION ***/
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"transact"}}'
AS
$$
SELECT
CAST(DepartmentID AS STRING),
CAST(Name AS STRING),
CAST(GroupName AS STRING)
FROM
HumanResources.Department
$$;
SELECT
*
from
TABLE(GetDepartmentInfo());
결과¶
DepartmentID |
이름 |
GroupName |
|---|---|---|
1 |
Engineering |
연구 및 개발 |
2 |
도구 설계 |
연구 및 개발 |
3 |
Sales |
영업 및 마케팅 |
4 |
마케팅 |
영업 및 마케팅 |
5 |
구매 |
재고 관리 |
6 |
연구 및 개발 |
연구 및 개발 |
7 |
프로덕션 |
Manufacturing |
8 |
생산 관리 |
Manufacturing |
9 |
인적 리소스 |
총괄 관리자 및 관리자 |
10 |
Finance |
총괄 관리자 및 관리자 |
11 |
정보 서비스 |
총괄 관리자 및 관리자 |
12 |
문서 제어 |
품질 보증 |
13 |
품질 보증 |
품질 보증 |
14 |
시설 및 유지 관리 |
총괄 관리자 및 관리자 |
15 |
배송 및 수령 |
재고 관리 |
16 |
실행 |
총괄 관리자 및 관리자 |
여러 테이블에서 열 이름을 바꾸고 기본 제공 함수를 사용하여 선택 및 반환 값 가져오기¶
다음은 여러 테이블에서 데이터를 가져오고, 열 이름을 바꾸고, 테이블을 반환하는 select 문에 기본 제공 함수를 사용하는 쿼리의 예입니다.
Transact-SQL¶
인라인 테이블 값¶
CREATE FUNCTION GetPersonBasicInfo()
RETURNS TABLE
AS
RETURN
(
SELECT TOP (20)
P.PersonType,
P.FirstName,
E.JobTitle,
E.Gender,
YEAR(E.HireDate) as HIREYEAR
FROM
Person.Person P
INNER JOIN
HumanResources.Employee E
ON
P.BusinessEntityID = E.BusinessEntityID
);
GO
SELECT * FROM GetPersonBasicInfo();
결과¶
PersonType |
FirstName |
JobTitle |
성별 |
HIREYEAR |
|---|---|---|---|---|
EM |
Ken |
최고 경영자 |
M |
2009 |
EM |
Terri |
엔지니어링 담당 부사장 |
F |
2008 |
EM |
Roberto |
엔지니어링 관리자 |
M |
2007 |
EM |
Rob |
선임 도구 디자이너 |
M |
2007 |
EM |
Gail |
설계 엔지니어 |
F |
2008 |
EM |
Jossef |
설계 엔지니어 |
M |
2008 |
EM |
Dylan |
연구 개발 관리자 |
M |
2009 |
EM |
Diane |
연구 개발 엔지니어 |
F |
2008 |
EM |
Gigi |
연구 개발 엔지니어 |
F |
2009 |
EM |
Michael |
연구 개발 관리자 |
M |
2009 |
EM |
Ovidiu |
선임 도구 디자이너 |
M |
2010 |
EM |
Thierry |
도구 디자이너 |
M |
2007 |
EM |
Janice |
도구 디자이너 |
F |
2010 |
EM |
Michael |
선임 설계 엔지니어 |
M |
2010 |
EM |
Sharon |
설계 엔지니어 |
F |
2011 |
EM |
David |
마케팅 관리자 |
M |
2007 |
EM |
Kevin |
마케팅 도우미 |
M |
2007 |
EM |
John |
마케팅 전문가 |
M |
2011 |
EM |
Mary |
마케팅 도우미 |
F |
2011 |
EM |
Wanida |
마케팅 도우미 |
F |
2011 |
Snowflake SQL¶
인라인 테이블 값¶
CREATE OR REPLACE FUNCTION GetPersonBasicInfo ()
RETURNS TABLE(
PersonType STRING /*** SSC-FDM-TS0012 - INFORMATION FOR THE COLUMN PersonType WAS NOT FOUND. STRING DATATYPE USED TO MATCH CAST AS STRING OPERATION ***/,
FirstName STRING /*** SSC-FDM-TS0012 - INFORMATION FOR THE COLUMN FirstName WAS NOT FOUND. STRING DATATYPE USED TO MATCH CAST AS STRING OPERATION ***/,
JobTitle STRING /*** SSC-FDM-TS0012 - INFORMATION FOR THE COLUMN JobTitle WAS NOT FOUND. STRING DATATYPE USED TO MATCH CAST AS STRING OPERATION ***/,
Gender STRING /*** SSC-FDM-TS0012 - INFORMATION FOR THE COLUMN Gender WAS NOT FOUND. STRING DATATYPE USED TO MATCH CAST AS STRING OPERATION ***/,
HIREYEAR INTEGER
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"transact"}}'
AS
$$
SELECT
TOP 20
CAST(P.PersonType AS STRING),
CAST(P.FirstName AS STRING),
CAST(E.JobTitle AS STRING),
CAST(E.Gender AS STRING),
YEAR(E.HireDate :: TIMESTAMP) as HIREYEAR
FROM
Person.Person P
INNER JOIN
HumanResources.Employee E
ON P.BusinessEntityID = E.BusinessEntityID
$$;
SELECT
*
FROM
TABLE(GetPersonBasicInfo());
결과¶
PersonType |
FirstName |
JobTitle |
성별 |
HIREYEAR |
|---|---|---|---|---|
EM |
Ken |
최고 경영자 |
M |
2009 |
EM |
Terri |
엔지니어링 담당 부사장 |
F |
2008 |
EM |
Roberto |
엔지니어링 관리자 |
M |
2007 |
EM |
Rob |
선임 도구 디자이너 |
M |
2007 |
EM |
Gail |
설계 엔지니어 |
F |
2008 |
EM |
Jossef |
설계 엔지니어 |
M |
2008 |
EM |
Dylan |
연구 개발 관리자 |
M |
2009 |
EM |
Diane |
연구 개발 엔지니어 |
F |
2008 |
EM |
Gigi |
연구 개발 엔지니어 |
F |
2009 |
EM |
Michael |
연구 개발 관리자 |
M |
2009 |
EM |
Ovidiu |
선임 도구 디자이너 |
M |
2010 |
EM |
Thierry |
도구 디자이너 |
M |
2007 |
EM |
Janice |
도구 디자이너 |
F |
2010 |
EM |
Michael |
선임 설계 엔지니어 |
M |
2010 |
EM |
Sharon |
설계 엔지니어 |
F |
2011 |
EM |
David |
마케팅 관리자 |
M |
2007 |
EM |
Kevin |
마케팅 도우미 |
M |
2007 |
EM |
John |
마케팅 전문가 |
M |
2011 |
EM |
Mary |
마케팅 도우미 |
F |
2011 |
EM |
Wanida |
마케팅 도우미 |
F |
2011 |
WITH 문을 사용한 열 선택¶
인라인 테이블 값 함수의 본문은 아래와 같이 WITH 문을 사용하여 지정할 수도 있습니다.
Transact-SQL¶
인라인 테이블 값¶
CREATE FUNCTION GetMaritalStatusByGender
(
@P_Gender nchar(1)
)
RETURNS TABLE
AS
RETURN
(
WITH CTE AS
(
SELECT BusinessEntityID, MaritalStatus, Gender
FROM HumanResources.Employee
where Gender = @P_Gender
)
SELECT
MaritalStatus, Gender, CONCAT(P.FirstName,' ', P.LastName) as Name
FROM
CTE INNER JOIN Person.Person P
ON
CTE.BusinessEntityID = P.BusinessEntityID
);
GO
select * from GetMaritalStatusByGender('F');
결과¶
MaritalStatus |
성별 |
이름 |
|---|---|---|
S |
F |
Terri Duffy |
M |
F |
Gail Erickson |
S |
F |
Diane Margheim |
M |
F |
Gigi Matthew |
M |
F |
Janice Galvin |
M |
F |
Sharon Salavaria |
S |
F |
Mary Dempsey |
M |
F |
Wanida Benshoof |
M |
F |
Mary Gibson |
M |
F |
Jill Williams |
S |
F |
Jo Brown |
M |
F |
Britta Simon |
M |
F |
Margie Shoop |
M |
F |
Rebecca Laszlo |
M |
F |
Suchitra Mohan |
M |
F |
Kim Abercrombie |
S |
F |
JoLynn Dobney |
M |
F |
Nancy Anderson |
M |
F |
Ruth Ellerbrock |
M |
F |
Doris Hartwig |
M |
F |
Diane Glimp |
M |
F |
Bonnie Kearney |
M |
F |
Denise Smith |
S |
F |
Diane Tibbott |
M |
F |
Carole Poland |
M |
F |
Carol Philips |
M |
F |
Merav Netz |
S |
F |
Betsy Stadick |
S |
F |
Danielle Tiedt |
S |
F |
Kimberly Zimmerman |
M |
F |
Elizabeth Keyser |
M |
F |
Mary Baker |
M |
F |
Alice Ciccu |
M |
F |
Linda Moschell |
S |
F |
Angela Barbariol |
S |
F |
Kitti Lertpiriyasuwat |
S |
F |
Susan Eaton |
S |
F |
Kim Ralls |
M |
F |
Nicole Holliday |
S |
F |
Anibal Sousa |
M |
F |
Samantha Smith |
S |
F |
Olinda Turner |
S |
F |
Cynthia Randall |
M |
F |
Sandra Reátegui Alayo |
S |
F |
Linda Randall |
S |
F |
Shelley Dyck |
S |
F |
Laura Steele |
S |
F |
Susan Metters |
S |
F |
Katie McAskill-White |
M |
F |
Barbara Decker |
M |
F |
Yvonne McKay |
S |
F |
Janeth Esteves |
M |
F |
Brenda Diaz |
M |
F |
Lorraine Nay |
M |
F |
Paula Nartker |
S |
F |
Lori Kane |
M |
F |
Kathie Flood |
S |
F |
Belinda Newman |
M |
F |
Karen Berge |
M |
F |
Lori Penor |
M |
F |
Jo Berry |
M |
F |
Laura Norman |
M |
F |
Paula Barreto de Mattos |
M |
F |
Mindy Martin |
M |
F |
Deborah Poe |
S |
F |
Candy Spoon |
M |
F |
Barbara Moreland |
M |
F |
Janet Sheperdigian |
S |
F |
Wendy Kahn |
S |
F |
Sheela Word |
M |
F |
Linda Meisner |
S |
F |
Erin Hagens |
M |
F |
Annette Hill |
S |
F |
Jean Trenary |
S |
F |
Stephanie Conroy |
S |
F |
Karen Berg |
M |
F |
Janaina Bueno |
M |
F |
Linda Mitchell |
S |
F |
Jillian Carson |
S |
F |
Pamela Ansman-Wolfe |
S |
F |
Lynn Tsoflias |
M |
F |
Amy Alberts |
S |
F |
Rachel Valdez |
M |
F |
Jae Pak |
Snowflake SQL¶
인라인 테이블 값¶
--** SSC-FDM-0007 - MISSING DEPENDENT OBJECTS "HumanResources.Employee", "Person.Person" **
CREATE OR REPLACE FUNCTION GetMaritalStatusByGender
(P_GENDER STRING
)
RETURNS TABLE(
MaritalStatus STRING /*** SSC-FDM-TS0012 - INFORMATION FOR THE COLUMN MaritalStatus WAS NOT FOUND. STRING DATATYPE USED TO MATCH CAST AS STRING OPERATION ***/,
Gender STRING /*** SSC-FDM-TS0012 - INFORMATION FOR THE COLUMN Gender WAS NOT FOUND. STRING DATATYPE USED TO MATCH CAST AS STRING OPERATION ***/,
Name VARCHAR
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "07/11/2025", "domain": "no-domain-provided" }}'
AS
$$
--** SSC-PRF-TS0001 - PERFORMANCE WARNING - RECURSION FOR CTE NOT CHECKED. MIGHT REQUIRE RECURSIVE KEYWORD **
WITH CTE AS
(
SELECT
BusinessEntityID,
MaritalStatus,
Gender
FROM
HumanResources.Employee
where
Gender = :P_GENDER
)
SELECT
CAST(MaritalStatus AS STRING),
CAST(Gender AS STRING),
CONCAT(P.FirstName,' ', P.LastName) as Name
FROM
CTE
INNER JOIN
Person.Person P
ON CTE.BusinessEntityID = P.BusinessEntityID
$$;
select
*
from
TABLE(GetMaritalStatusByGender('F'));
결과¶
MaritalStatus |
성별 |
이름 |
|---|---|---|
S |
F |
Terri Duffy |
M |
F |
Gail Erickson |
S |
F |
Diane Margheim |
M |
F |
Gigi Matthew |
M |
F |
Janice Galvin |
M |
F |
Sharon Salavaria |
S |
F |
Mary Dempsey |
M |
F |
Wanida Benshoof |
M |
F |
Mary Gibson |
M |
F |
Jill Williams |
S |
F |
Jo Brown |
M |
F |
Britta Simon |
M |
F |
Margie Shoop |
M |
F |
Rebecca Laszlo |
M |
F |
Suchitra Mohan |
M |
F |
Kim Abercrombie |
S |
F |
JoLynn Dobney |
M |
F |
Nancy Anderson |
M |
F |
Ruth Ellerbrock |
M |
F |
Doris Hartwig |
M |
F |
Diane Glimp |
M |
F |
Bonnie Kearney |
M |
F |
Denise Smith |
S |
F |
Diane Tibbott |
M |
F |
Carole Poland |
M |
F |
Carol Philips |
M |
F |
Merav Netz |
S |
F |
Betsy Stadick |
S |
F |
Danielle Tiedt |
S |
F |
Kimberly Zimmerman |
M |
F |
Elizabeth Keyser |
M |
F |
Mary Baker |
M |
F |
Alice Ciccu |
M |
F |
Linda Moschell |
S |
F |
Angela Barbariol |
S |
F |
Kitti Lertpiriyasuwat |
S |
F |
Susan Eaton |
S |
F |
Kim Ralls |
M |
F |
Nicole Holliday |
S |
F |
Anibal Sousa |
M |
F |
Samantha Smith |
S |
F |
Olinda Turner |
S |
F |
Cynthia Randall |
M |
F |
Sandra Reátegui Alayo |
S |
F |
Linda Randall |
S |
F |
Shelley Dyck |
S |
F |
Laura Steele |
S |
F |
Susan Metters |
S |
F |
Katie McAskill-White |
M |
F |
Barbara Decker |
M |
F |
Yvonne McKay |
S |
F |
Janeth Esteves |
M |
F |
Brenda Diaz |
M |
F |
Lorraine Nay |
M |
F |
Paula Nartker |
S |
F |
Lori Kane |
M |
F |
Kathie Flood |
S |
F |
Belinda Newman |
M |
F |
Karen Berge |
M |
F |
Lori Penor |
M |
F |
Jo Berry |
M |
F |
Laura Norman |
M |
F |
Paula Barreto de Mattos |
M |
F |
Mindy Martin |
M |
F |
Deborah Poe |
S |
F |
Candy Spoon |
M |
F |
Barbara Moreland |
M |
F |
Janet Sheperdigian |
S |
F |
Wendy Kahn |
S |
F |
Sheela Word |
M |
F |
Linda Meisner |
S |
F |
Erin Hagens |
M |
F |
Annette Hill |
S |
F |
Jean Trenary |
S |
F |
Stephanie Conroy |
S |
F |
Karen Berg |
M |
F |
Janaina Bueno |
M |
F |
Linda Mitchell |
S |
F |
Jillian Carson |
S |
F |
Pamela Ansman-Wolfe |
S |
F |
Lynn Tsoflias |
M |
F |
Amy Alberts |
S |
F |
Rachel Valdez |
M |
F |
Jae Pak |
알려진 문제¶
발견된 문제 없음
MULTI-STATEMENT TABLE-VALUED¶
TABLE 반환 유형이 있는 Transact-SQL UDF(사용자 정의 함수)를 Snowflake로 변환하기 위한 변환 참조
Applies to
SQL 서버
Azure 시냅스 분석
참고
출력 코드의 일부 부분은 명확성을 위해 생략되었습니다.
참고
이 페이지의 모든 코드 샘플은 아직 SnowConvert AI에서 구현되지 않았습니다. 각 시나리오를 Snowflake로 변환하는 방법에 대한 참조로 해석되어야 합니다. 이러한 변환은 향후 변경될 수 있습니다. 출력 코드의 일부는 명확성을 위해 생략되었습니다.
설명¶
다중 문 테이블 값은 인라인 문 테이블 값(INLINE TABLE-VALUED)과 비슷합니다. 그러나 다중 문 테이블 값은 함수 본문에 둘 이상의 문이 있을 수 있으며, 테이블 열은 반환 유형으로 지정되고 BEGIN/END 블록이 있습니다(다중 문 테이블 값 함수를 생성하는 SQL Server 언어 참조.
Transact-SQL 구문¶
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name
( [ { @parameter_name [ AS ] [ type_schema_name. ] parameter_data_type
[ = default ] [READONLY] }
[ ,...n ]
]
)
RETURNS @return_variable TABLE <table_type_definition>
[ WITH <function_option> [ ,...n ] ]
[ AS ]
BEGIN
function_body
RETURN
END
[ ; ]
Snowflake SQL¶
CREATE OR REPLACE FUNCTION <name> ( [ <arguments> ] )
RETURNS TABLE ( <output_col_name> <output_col_type> [, <output_col_name> <output_col_type> ... ] )
AS '<sql_expression>'
샘플 소스 패턴¶
다음 섹션에서는 이러한 종류의 ofCREATE FUNCTION 구문에 나타날 수 있는 가능한 모든 소스 코드 패턴에 대해 설명합니다.
다중 문 테이블-값 함수의 함수 본문은 SELECT 문이어야 합니다. 따라서 다른 문은 별도로 호출해야 합니다.
테이블에 값 삽입¶
테이블에 1개 이상의 행을 삽입하고 새 값으로 테이블을 반환합니다
Transact-SQL¶
MULTI-STATEMENT TABLE-VALUED¶
CREATE OR ALTER FUNCTION calc_behavioral_segment()
RETURNS @behavioral_segments TABLE (behavioral_segment VARCHAR(50))
AS
BEGIN
DECLARE @col varchar(15)
SET @col = 'Unknown'
INSERT INTO @behavioral_segments
SELECT @col
RETURN
END
SELECT * FROM calc_behavioral_segment();
결과¶
BEHAVIORAL_SEGMENT |
|---|
알 수 없음 |
Snowflake SQL¶
MULTI-STATEMENT TABLE-VALUED¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'TABLE VALUED FUNCTIONS' NODE ***/!!!
CREATE OR ALTER FUNCTION calc_behavioral_segment ()
RETURNS BEHAVIORAL_SEGMENTS TABLE (
behavioral_segment VARCHAR(50))
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
BEGIN
DECLARE @col varchar(15)
SET @col = 'Unknown'
INSERT INTO @behavioral_segments
SELECT @col
RETURN
END
SELECT * FROM calc_behavioral_segment();;
결과¶
BEHAVIORAL_SEGMENT |
|---|
알 수 없음 |
If/else 문에 따른 값 삽입¶
조건에 따라 테이블에 행을 삽입하고 새 값으로 테이블을 반환합니다
Transact-SQL¶
MULTI-STATEMENT TABLE-VALUED¶
CREATE OR ALTER FUNCTION odd_or_even_number(@number INT)
RETURNS @numbers TABLE (number_type VARCHAR(15))
AS
BEGIN
IF ((@number % 2) = 0)
BEGIN
INSERT @numbers SELECT 'Even'
END
ELSE
BEGIN
INSERT @numbers SELECT 'Odd'
END
RETURN
END
SELECT * FROM odd_or_even_number(9);
결과¶
NUMBER_TYPE |
|---|
Odd |
Snowflake SQL¶
MULTI-STATEMENT TABLE-VALUED¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'TABLE VALUED FUNCTIONS' NODE ***/!!!
CREATE OR ALTER FUNCTION odd_or_even_number (NUMBER INT)
RETURNS NUMBERS TABLE (
number_type VARCHAR(15))
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
BEGIN
IF ((@number % 2) = 0)
BEGIN
INSERT @numbers SELECT 'Even'
END
ELSE
BEGIN
INSERT @numbers SELECT 'Odd'
END
RETURN
END
SELECT * FROM odd_or_even_number(9);;
결과¶
NUMBER_TYPE |
|---|
Odd |
If/else 문에 따라 여러 개를 삽입합니다¶
아래 예제는 테이블에 2개 이상의 값을 삽입하고 조건에 따라 2개 이상의 변수를 수정했습니다. 새 값으로 테이블을 반환합니다
Transact-SQL¶
MULTI-STATEMENT TABLE-VALUED¶
CREATE OR ALTER FUNCTION new_employee_hired(@id VARCHAR (50), @position VARCHAR(50), @experience VARCHAR(15))
RETURNS @new_employee TABLE (id_employee VARCHAR (50), working_from_home BIT, team VARCHAR(15), computer VARCHAR(15))
AS
BEGIN
DECLARE @wfh BIT
DECLARE @team VARCHAR(15)
DECLARE @computer VARCHAR(15)
IF @position = 'DEVELOPER'
BEGIN
SET @team = 'TEAM_1'
SET @computer = 'LAPTOP'
END
IF @position = 'IT'
BEGIN
SET @team = 'TEAM_2'
SET @computer = 'DESKTOP'
END
IF @experience = 'JUNIOR'
BEGIN
SET @wfh = '0'
END
IF @experience = 'SENIOR'
BEGIN
SET @wfh = '1'
END
INSERT INTO @new_employee VALUES (@id, @wfh, @team, @computer)
RETURN
END
SELECT * FROM new_employee_hired('123456789', 'DEVELOPER', 'SENIOR');
결과¶
ID_EMPLOYEE |
WORKING_FROM_HOME |
TEAM |
COMPUTER |
|---|---|---|---|
123456789 |
1 |
TEAM_1 |
LAPTOP |
Snowflake¶
MULTI-STATEMENT TABLE-VALUED¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'TABLE VALUED FUNCTIONS' NODE ***/!!!
CREATE OR ALTER FUNCTION new_employee_hired (ID STRING, POSITION STRING, EXPERIENCE STRING)
RETURNS NEW_EMPLOYEE TABLE (
id_employee VARCHAR(50),
working_from_home BOOLEAN,
team VARCHAR(15),
computer VARCHAR(15))
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
BEGIN
DECLARE @wfh BIT
DECLARE @team VARCHAR(15)
DECLARE @computer VARCHAR(15)
IF @position = 'DEVELOPER'
BEGIN
SET @team = 'TEAM_1'
SET @computer = 'LAPTOP'
END
IF @position = 'IT'
BEGIN
SET @team = 'TEAM_2'
SET @computer = 'DESKTOP'
END
IF @experience = 'JUNIOR'
BEGIN
SET @wfh = '0'
END
IF @experience = 'SENIOR'
BEGIN
SET @wfh = '1'
END
INSERT INTO @new_employee VALUES (@id, @wfh, @team, @computer)
RETURN
END
SELECT * FROM new_employee_hired('123456789', 'DEVELOPER', 'SENIOR');;
결과¶
ID_EMPLOYEE |
WORKING_FROM_HOME |
TEAM |
COMPUTER |
|---|---|---|---|
123456789 |
1 |
TEAM_1 |
LAPTOP |
경고
문이 중첩되어 있고 문에서 2개 이상의 변수가 수정되는 경우 저장 프로시저를 사용해야 합니다.
이전에 삽입한 값 업데이트¶
테이블의 열 값을 함수 본문으로 업데이트하고 새 값으로 반환합니다.
Transact-SQL¶
MULTI-STATEMENT TABLE-VALUED¶
CREATE OR ALTER FUNCTION get_employees_history()
RETURNS @employee_history TABLE (
department_name NVARCHAR(50),
first_name NVARCHAR(50),
last_name NVARCHAR(50),
start_date DATE,
end_date DATE,
job_title NVARCHAR(50),
months_working INT
)
BEGIN
INSERT INTO @employee_history
SELECT D.name AS department_name, P.first_name, P.last_name, EH.start_date, EH.end_date, E.job_title, 0 FROM Department D
LEFT OUTER JOIN employee_department_history EH
ON D.department_ID = EH.department_ID
INNER JOIN Employee E
ON E.business_entity_ID = EH.business_entity_ID
INNER JOIN Person P
ON P.business_entity_ID = E.business_entity_ID
UPDATE @employee_history
SET
months_working =
CASE WHEN end_date IS NULL THEN DATEDIFF(MONTH, start_date, GETDATE())
ELSE DATEDIFF(MONTH, start_date, end_date)
END
RETURN;
END;
SELECT TOP(10) * FROM get_employees_history();
결과¶
DEPARTMENT_NAME |
FIRST_NAME |
LAST_NAME |
START_DATE |
END_DATE |
JOB_TITLE |
MONTHS_WORKING |
|---|---|---|---|---|---|---|
Sales |
Syed |
Abbas |
2013-03-14 |
NULL |
Pacific Sales Manager |
106 |
프로덕션 |
Kim |
Abercrombie |
2010-01-16 |
NULL |
Production Technician - WC60 |
144 |
품질 보증 |
Hazem |
Abolrous |
2009-02-28 |
NULL |
Quality Assurance Manager |
155 |
배송 및 수령 |
Pilar |
Ackerman |
2009-01-02 |
NULL |
Shipping and Receiving Supervisor |
156 |
프로덕션 |
Jay |
Adams |
2009-03-05 |
NULL |
Production Technician - WC60 |
154 |
정보 서비스 |
François |
Ajenstat |
2009-01-17 |
NULL |
Database Administrator |
156 |
Sales |
Amy |
Alberts |
2012-04-16 |
NULL |
European Sales Manager |
117 |
프로덕션 |
Greg |
Alderson |
2008-12-02 |
NULL |
Production Technician - WC45 |
157 |
품질 보증 |
Sean |
Alexander |
2008-12-28 |
NULL |
Quality Assurance Technician |
157 |
시설 및 유지 관리 |
Gary |
Altman |
2009-12-02 |
NULL |
Facilities Manager |
145 |
Snowflake SQL¶
MULTI-STATEMENT TABLE-VALUED¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'TABLE VALUED FUNCTIONS' NODE ***/!!!
CREATE OR ALTER FUNCTION get_employees_history ()
RETURNS EMPLOYEE_HISTORY TABLE (
department_name VARCHAR(50),
first_name VARCHAR(50),
last_name VARCHAR(50),
start_date DATE,
end_date DATE,
job_title VARCHAR(50),
months_working INT
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
BEGIN
INSERT INTO @employee_history
SELECT D.name AS department_name, P.first_name, P.last_name, EH.start_date, EH.end_date, E.job_title, 0 FROM Department D
LEFT OUTER JOIN employee_department_history EH
ON D.department_ID = EH.department_ID
INNER JOIN Employee E
ON E.business_entity_ID = EH.business_entity_ID
INNER JOIN Person P
ON P.business_entity_ID = E.business_entity_ID
UPDATE @employee_history
SET
months_working =
CASE WHEN end_date IS NULL THEN DATEDIFF(MONTH, start_date, GETDATE())
ELSE DATEDIFF(MONTH, start_date, end_date)
END
RETURN;
END;
SELECT TOP(10) * FROM get_employees_history();;
결과¶
DEPARTMENT_NAME |
FIRST_NAME |
LAST_NAME |
START_DATE |
END_DATE |
JOB_TITLE |
MONTHS_WORKING |
|---|---|---|---|---|---|---|
Sales |
Syed |
Abbas |
2013-03-14 |
NULL |
Pacific Sales Manager |
106 |
프로덕션 |
Kim |
Abercrombie |
2010-01-16 |
NULL |
Production Technician - WC60 |
144 |
품질 보증 |
Hazem |
Abolrous |
2009-02-28 |
NULL |
Quality Assurance Manager |
155 |
배송 및 수령 |
Pilar |
Ackerman |
2009-01-02 |
NULL |
Shipping and Receiving Supervisor |
156 |
프로덕션 |
Jay |
Adams |
2009-03-05 |
NULL |
Production Technician - WC60 |
154 |
정보 서비스 |
François |
Ajenstat |
2009-01-17 |
NULL |
Database Administrator |
156 |
Sales |
Amy |
Alberts |
2012-04-16 |
NULL |
European Sales Manager |
117 |
프로덕션 |
Greg |
Alderson |
2008-12-02 |
NULL |
Production Technician - WC45 |
157 |
품질 보증 |
Sean |
Alexander |
2008-12-28 |
NULL |
Quality Assurance Technician |
157 |
시설 및 유지 관리 |
Gary |
Altman |
2009-12-02 |
NULL |
Facilities Manager |
145 |
여러 반환 절¶
다음 샘플에는 반환 절이 2개 이상 있는데, 이는 상황에 따라 전체 함수를 계속 실행할 필요가 없기 때문입니다.
Transact-SQL¶
MULTI-STATEMENT TABLE-VALUED¶
CREATE OR ALTER FUNCTIONcreate_new_team(@team_name VARCHAR(50))
</strong>RETURNS @new_team TABLE (type VARCHAR(50), name VARCHAR(50))
AS
BEGIN
DECLARE @employees INT
SET @employees = (SELECT count(*) FROM employee)
DECLARE @type VARCHAR(15)
SET @type = 'small_team'
IF (@employees < 8)
BEGIN
INSERT @new_team VALUES (@type, @team_name)
RETURN
END
SET @type = 'big_team'
INSERT @new_team VALUES (@type, @team_name)
RETURN
END
SELECT * FROMcreate_new_team('Team1');
결과¶
TYPE |
NAME |
|---|---|
SMALL_TEAM |
TEAM1 |
Snowflake SQL¶
MULTI-STATEMENT TABLE-VALUED¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'TABLE VALUED FUNCTIONS' NODE ***/!!!
CREATE OR ALTER FUNCTIONcreate_new_team (TEAM_NAME STRING)
RETURNS NEW_TEAM TABLE (
type VARCHAR(50),
name VARCHAR(50))
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
BEGIN
DECLARE @employees INT
SET @employees = (SELECT count(*) FROM employee)
DECLARE @type VARCHAR(15)
SET @type = 'small_team'
IF (@employees < 8)
BEGIN
INSERT @new_team VALUES (@type, @team_name)
RETURN
END
SET @type = 'big_team'
INSERT @new_team VALUES (@type, @team_name)
RETURN
END
SELECT * FROMcreate_new_team('Team1');;
결과¶
TYPE |
NAME |
|---|---|
SMALL_TEAM |
TEAM1 |
경고
이 변환은 삽입할 값이 하나만 있을 때 적용되며, 값이 2개 이상인 경우 저장 프로시저를 사용해야 합니다.
복잡한 케이스¶
이 예는 중첩된 if 문을 사용하고 실제 조건에 따라 값을 삽입하는 복잡한 경우입니다.
Transact-SQL¶
MULTI-STATEMENT TABLE-VALUED¶
CREATE OR ALTER FUNCTION vacation_status(@id VARCHAR (50))
RETURNS @status TABLE (vacation_status VARCHAR(30))
AS
BEGIN
DECLARE @hire_date DATETIME
SET @hire_date = (SELECT @hire_date FROM employee WHERE employeeId = @id)
DECLARE @vacation_hours INT
SET @vacation_hours = (SELECT count(vacation_hours) FROM employee WHERE employeeId = @id)
DECLARE @time_working INT
SET @time_working = (SELECT DATEDIFF(MONTH, @hire_date,GETDATE()))
IF (@vacation_hours > 0)
BEGIN
IF (@time_working > 3)
BEGIN
IF (@vacation_hours < 120)
BEGIN
INSERT INTO @status VALUES ('Ok')
END
IF (@vacation_hours = 120)
BEGIN
INSERT INTO @status values ('In the limit')
END
IF (@vacation_hours > 120)
BEGIN
INSERT INTO @status VALUES ('With excess')
END
END
ELSE
BEGIN
INSERT INTO @status values ('Hired recently')
END
END
ELSE
BEGIN
INSERT INTO @status values ('No hours')
END
RETURN
END
SELECT * FROM vacation_status('adventure-worksken0')
결과¶
VACATION_STATUS |
|---|
OK |
Snowflake SQL¶
MULTI-STATEMENT TABLE-VALUED¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'TABLE VALUED FUNCTIONS' NODE ***/!!!
CREATE OR ALTER FUNCTION vacation_status (ID STRING)
RETURNS STATUS TABLE (
vacation_status VARCHAR(30))
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
BEGIN
DECLARE @hire_date DATETIME
SET @hire_date = (SELECT @hire_date FROM employee WHERE employeeId = @id)
DECLARE @vacation_hours INT
SET @vacation_hours = (SELECT count(vacation_hours) FROM employee WHERE employeeId = @id)
DECLARE @time_working INT
SET @time_working = (SELECT DATEDIFF(MONTH, @hire_date,GETDATE()))
IF (@vacation_hours > 0)
BEGIN
IF (@time_working > 3)
BEGIN
IF (@vacation_hours < 120)
BEGIN
INSERT INTO @status VALUES ('Ok')
END
IF (@vacation_hours = 120)
BEGIN
INSERT INTO @status values ('In the limit')
END
IF (@vacation_hours > 120)
BEGIN
INSERT INTO @status VALUES ('With excess')
END
END
ELSE
BEGIN
INSERT INTO @status values ('Hired recently')
END
END
ELSE
BEGIN
INSERT INTO @status values ('No hours')
END
RETURN
END
SELECT * FROM vacation_status('adventure-worksken0');
Second Tab¶
VACATION_STATUS |
|---|
OK |
Known Issues¶
쿼리와 함께 문이 있는 동안¶
이 예제의 문제점은 메인 select의 WITH 절 내에서 while 문을 CTE 로 변환할 방법이 없기 때문에 동일한 논리를 유지하기 위해 이 문을 저장 프로시저로 변환해야 한다는 것입니다.
Transact-SQL¶
MULTI-STATEMENT TABLE-VALUED¶
--Additional Params: -t JavaScript
CREATE OR ALTER FUNCTION get_group_name
(@department_id INT)
RETURNS @group_names TABLE (group_name VARCHAR(15))
AS
BEGIN
DECLARE @name VARCHAR(30) = 'Another Department'
WHILE @name = 'Another Department'
BEGIN
IF (@department_id < 3)
BEGIN
SET @name = 'engineering'
END
IF @department_id = 3
BEGIN
SET @name = 'Tool Design'
END
SELECT @department_id = @department_id / 3
END
INSERT @group_names SELECT @name
RETURN
END
SELECT * FROM get_group_name(9);
결과¶
GROUP_NAME |
|---|
도구 설계 |
Snowflake SQL¶
MULTI-STATEMENT TABLE-VALUED¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'TABLE VALUED FUNCTIONS' NODE ***/!!!
CREATE OR ALTER FUNCTION get_group_name
(DEPARTMENT_ID INT)
RETURNS @group_names TABLE (
group_name VARCHAR(15))
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
BEGIN
DECLARE @name VARCHAR(30) = 'Another Department'
WHILE @name = 'Another Department'
BEGIN
IF (@department_id < 3)
BEGIN
SET @name = 'engineering'
END
IF @department_id = 3
BEGIN
SET @name = 'Tool Design'
END
SELECT @department_id = @department_id / 3
END
INSERT @group_names SELECT @name
RETURN
END
SELECT * FROM get_group_name(9);;
결과¶
GROUP_NAME |
|---|
도구 설계 |
커서 선언하기¶
사용자 정의 함수는 DECLARE, OPEN, FETCH, CLOSE 또는 DEALLOCATE a CURSOR 가 아니어야 합니다. 커서로 작업하려면 저장 프로시저를 사용합니다.
Transact-SQL¶
MULTI-STATEMENT TABLE-VALUED¶
--Additional Params: -t JavaScript
CREATE OR ALTER FUNCTION amount_new_specimens(@id int)
RETURNS @new_specimens TABLE (amount int)
AS
BEGIN
DECLARE @first_specimen VARCHAR(30) ;
set @first_specimen = (select name_specimen from specimen where specimen_id = @id);
DECLARE @second_specimen VARCHAR(30);
DECLARE @specimens TABLE (name_specimen VARCHAR(30))
DECLARE Cursor1 CURSOR
FOR SELECT name_specimen
FROM specimen
OPEN cursor1
FETCH NEXT FROM cursor1
INTO @second_specimen;
WHILE @@FETCH_STATUS = 0
BEGIN
IF @first_specimen <> @second_specimen
BEGIN
INSERT INTO @specimens values (CONCAT_WS('-', @first_specimen, @second_specimen))
END
FETCH NEXT FROM cursor1
INTO @second_specimen;
END
CLOSE cursor1;
DEALLOCATE cursor1;
INSERT INTO @new_specimens SELECT COUNT(*) FROM @specimens
RETURN
END
SELECT * FROM amount_new_specimens(1);
결과¶
AMOUNT |
|---|
3 |
Snowflake SQL¶
MULTI-STATEMENT TABLE-VALUED¶
--Additional Params: -t JavaScript
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'TABLE VALUED FUNCTIONS' NODE ***/!!!
CREATE OR ALTER FUNCTION amount_new_specimens (ID INT)
RETURNS @new_specimens TABLE (
amount INT
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
BEGIN
DECLARE @first_specimen VARCHAR(30) ;
set @first_specimen = (select name_specimen from specimen where specimen_id = @id);
DECLARE @second_specimen VARCHAR(30);
DECLARE @specimens TABLE (name_specimen VARCHAR(30))
DECLARE Cursor1 CURSOR
FOR SELECT name_specimen
FROM specimen
OPEN cursor1
FETCH NEXT FROM cursor1
INTO @second_specimen;
WHILE @@FETCH_STATUS = 0
BEGIN
IF @first_specimen <> @second_specimen
BEGIN
INSERT INTO @specimens values (CONCAT_WS('-', @first_specimen, @second_specimen))
END
FETCH NEXT FROM cursor1
INTO @second_specimen;
END
CLOSE cursor1;
DEALLOCATE cursor1;
INSERT INTO @new_specimens SELECT COUNT(*) FROM @specimens
RETURN
END
SELECT * FROM amount_new_specimens(1);;
결과¶
AMOUNT |
|---|
3 |
공통 테이블 식에서는 다른 문이 지원되지 않습니다¶
UPDATE, INSERT, DELETE, ALTER 또는 DROP절은 구분 기호를 사용하여 선언한 후에도 일반 테이블 식의 본문에서 지원되지 않습니다. 따라서 함수를 저장 프로시저로 작동하도록 수정할 수 있습니다.
Transact-SQL¶
MULTI-STATEMENT TABLE-VALUED¶
--Additional Params: -t JavaScript
CREATE OR ALTER PROCEDURE product_history
AS
BEGIN
DECLARE @product_history TABLE (
product_name NVARCHAR(50),
rating INT
)
INSERT INTO @product_history
SELECT P.Name AS product_name, AVG(ALL R.rating) FROM Production.product P
INNER JOIN Production.product_review R
ON R.product_ID = P.product_ID
GROUP BY P.Name;
DELETE FROM @product_history
WHERE rating < 2;
SELECT * FROM @product_history;
END
GO;
EXEC product_history
결과¶
PRODUCT_NAME |
Rating |
|---|---|
HL Mountain Pedal |
3 |
Mountain Bike Socks, M |
5 |
Road-550-W Yellow, 40 |
5 |
Snowflake SQL¶
MULTI-STATEMENT TABLE-VALUED¶
CREATE OR REPLACE PROCEDURE product_history ()
RETURNS STRING
LANGUAGE JAVASCRIPT
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"transact"}}'
EXECUTE AS CALLER
AS
$$
// REGION SnowConvert AI Helpers Code
var _RS, ROW_COUNT, _ROWS, MESSAGE_TEXT, SQLCODE = 0, SQLSTATE = '00000', OBJECT_SCHEMA_NAME = 'UNKNOWN', ERROR_HANDLERS, NUM_ROWS_AFFECTED, PROC_NAME = arguments.callee.name, DOLLAR_DOLLAR = '$' + '$';
function* sqlsplit(sql) {
var part = '';
var ismark = () => sql[i] == '$' && sql[i + 1] == '$';
for(var i = 0;i < sql.length;i++) {
if (sql[i] == ';') {
yield part + sql[i];
part = '';
} else if (ismark()) {
part += sql[i++] + sql[i++];
while ( i < sql.length && !ismark() ) {
part += sql[i++];
}
part += sql[i] + sql[i++];
} else part += sql[i];
}
if (part.trim().length) yield part;
};
var formatDate = (arg) => (new Date(arg - (arg.getTimezoneOffset() * 60000))).toISOString().slice(0,-1);
var fixBind = function (arg) {
arg = arg == undefined ? null : arg instanceof Date ? formatDate(arg) : arg;
return arg;
};
var EXEC = (stmt,binds = [],severity = "16",noCatch = false) => {
binds = binds ? binds.map(fixBind) : binds;
for(var stmt of sqlsplit(stmt)) {
try {
_RS = snowflake.createStatement({
sqlText : stmt,
binds : binds
});
_ROWS = _RS.execute();
ROW_COUNT = _RS.getRowCount();
NUM_ROWS_AFFECTED = _RS.getNumRowsAffected();
return {
THEN : (action) => !SQLCODE && action(fetch(_ROWS))
};
} catch(error) {
let rStack = new RegExp('At .*, line (\\d+) position (\\d+)');
let stackLine = error.stackTraceTxt.match(rStack) || [0,-1];
MESSAGE_TEXT = error.message.toString();
SQLCODE = error.code.toString();
SQLSTATE = error.state.toString();
snowflake.execute({
sqlText : `SELECT UPDATE_ERROR_VARS_UDF(?,?,?,?,?,?)`,
binds : [stackLine[1],SQLCODE,SQLSTATE,MESSAGE_TEXT,PROC_NAME,severity]
});
throw error;
}
}
};
// END REGION
EXEC(`CREATE OR REPLACE TEMPORARY TABLE T_product_history (
product_name VARCHAR(50),
rating INT
)`);
EXEC(` INSERT INTO T_product_history
SELECT
P.Name AS product_name,
AVG(ALL R.rating) FROM
Production.product P
INNER JOIN
Production.product_review R
ON R.product_ID = P.product_ID
GROUP BY
P.Name`);
EXEC(`DELETE FROM
T_product_history
WHERE
rating < 2`);
EXEC(`
SELECT
*
FROM
T_product_history`);
$$;
;
CALL product_history();
결과¶
PRODUCT_NAME |
Rating |
|---|---|
HL Mountain Pedal |
3 |
Mountain Bike Socks, M |
5 |
Road-550-W Yellow, 40 |
5 |
관련 EWIs¶
SSC-EWI-0040: 문이 지원되지 않습니다.
SSC-EWI-0073: 보류 중 함수 동등성 검토
SCALAR¶
스칼라 반환 유형이 있는 Transact-SQL UDF(사용자 정의 함수)를 Snowflake로 변환하기 위한 변환 참조
Applies to
SQL 서버
Azure 시냅스 분석
설명¶
참고
출력 코드의 일부 부분은 명확성을 위해 생략되었습니다.
스칼라 사용자 정의 함수는 매개 변수를 수락하고, 복잡한 계산과 같은 작업을 수행하고, 해당 작업의 결과를 스칼라 값으로 반환하는 Transact-SQL 또는 CLR(공용 언어 런타임) 루틴입니다. (SQL Server 언어 ReferenceCREATE FUNCTION 하위 섹션).
참고
이러한 함수는 일반적으로 SELECT 문 또는 단일 변수 설정(대부분 저장 프로시저 내부) 내에서 사용됩니다.
Transact-SQL 구문¶
-- Transact-SQL Scalar Function Syntax
CREATE [ OR ALTER ] FUNCTION [ schema_name. ] function_name
( [ { @parameter_name [ AS ][ type_schema_name. ] parameter_data_type
[ = default ] [ READONLY ] }
[ ,...n ]
]
)
RETURNS return_data_type
[ WITH <function_option> [ ,...n ] ]
[ AS ]
BEGIN
function_body
RETURN scalar_expression
END
[ ; ]
Snowflake 구문¶
Snowflake는 사용자 정의 함수에서 3가지 언어를 지원합니다.
SQL
JavaScript
Java
현재, SnowConvert AI는 SQL 및 JavaScript만 대상 언어로 지원합니다.
SQL¶
참고
SQL 사용자 정의 함수는 본문으로 1개의 쿼리만 지원합니다. 데이터베이스에서 읽을 수는 있지만 쓰거나 수정할 수는 없습니다. (Scalar SQL UDFs Reference).
CREATE [ OR REPLACE ] [ SECURE ] FUNCTION <name> ( [ <arg_name> <arg_data_type> ] [ , ... ] )
RETURNS { <result_data_type> | TABLE ( <col_name> <col_data_type> [ , ... ] ) }
[ [ NOT ] NULL ]
[ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ]
[ VOLATILE | IMMUTABLE ]
[ COMMENT = '<string_literal>' ]
AS '<function_definition>'
JavaScript¶
참고
JavaScript 사용자 정의 함수는 본문에서 여러 문을 허용하지만 데이터베이스 쿼리를 수행할 수는 없습니다. (Scalar JavaScript UDFs Reference)
CREATE [ OR REPLACE ] [ SECURE ] FUNCTION <name> ( [ <arg_name> <arg_data_type> ] [ , ... ] )
RETURNS { <result_data_type> | TABLE ( <col_name> <col_data_type> [ , ... ] ) }
[ [ NOT ] NULL ]
LANGUAGE JAVASCRIPT
[ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ]
[ VOLATILE | IMMUTABLE ]
[ COMMENT = '<string_literal>' ]
AS '<function_definition>'
샘플 소스 패턴¶
문 설정 및 선언하기¶
함수 본문에서 가장 일반적인 문은DECLARE및SET문입니다. 기본값이 없는 DECLARE 문의 경우 변환이 무시됩니다. 기본값이 있는 SET 문과 DECLARE 문은 COMMON TABLE EXPRESSION. 로 변환됩니다. 각 공통 테이블 식에는 로컬 변수 값을 나타내는 열이 포함됩니다.
Transact-SQL¶
쿼리¶
CREATE OR ALTER FUNCTION PURCHASING.GetVendorName()
RETURNS NVARCHAR(50) AS
BEGIN
DECLARE @result NVARCHAR(50)
DECLARE @BUSINESSENTITYID INT
SET @BUSINESSENTITYID = 1492
SELECT @result = Name FROM PURCHASING.VENDOR WHERE BUSINESSENTITYID = @BUSINESSENTITYID
RETURN @result
END
GO
SELECT PURCHASING.GetVendorName() as vendor_name;
결과¶
vendor_name |
|---|
Australia Bike Retailer |
Snowflake¶
쿼리¶
CREATE OR REPLACE FUNCTION PURCHASING.GetVendorName ()
RETURNS VARCHAR(50)
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
$$
WITH CTE1 AS
(
SELECT
1492 AS BUSINESSENTITYID
),
CTE2 AS
(
SELECT
Name AS RESULT
FROM
PURCHASING.VENDOR
WHERE
BUSINESSENTITYID = (
SELECT
BUSINESSENTITYID
FROM
CTE1
)
)
SELECT
RESULT
FROM
CTE2
$$;
SELECT
PURCHASING.GetVendorName() as vendor_name;
결과¶
VENDOR_NAME |
|---|
Australia Bike Retailer |
If/Else 문 변환¶
If/Else 문은 다른 방식으로 처리할 수 있는데, 자바스크립트로 변환하거나 쿼리 내부의 조건문을 허용하는 선택 내부의 CASE EXPRESSION 를 사용하여 SQL 로 변환할 수 있지만, 자바스크립트 변환은 매우 간단하지만 Case 문은 언뜻 보기에 그렇게 명확하지 않을 수 있습니다.
Transact-SQL¶
쿼리¶
CREATE OR ALTER FUNCTION PURCHASING.HasActiveFlag(@BusinessEntityID int)
RETURNS VARCHAR(10) AS
BEGIN
DECLARE @result VARCHAR(10)
DECLARE @ActiveFlag BIT
SELECT @ActiveFlag = ActiveFlag from PURCHASING.VENDOR v where v.BUSINESSENTITYID = @BusinessEntityID
IF @ActiveFlag = 1
SET @result = 'YES'
ELSE IF @ActiveFlag = 0
SET @result = 'NO'
RETURN @result
END
GO
SELECT PURCHASING.HasActiveFlag(1516) as has_active_flag;
결과¶
has_active_flag |
|---|
NO |
Snowflake¶
쿼리¶
CREATE OR REPLACE FUNCTION PURCHASING.HasActiveFlag (P_BUSINESSENTITYID INT)
RETURNS VARCHAR(10)
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
$$
WITH CTE1 AS
(
SELECT
ActiveFlag AS ACTIVEFLAG
from
PURCHASING.VENDOR v
where
v.BUSINESSENTITYID = P_BUSINESSENTITYID
),
CTE2 AS
(
SELECT
CASE
WHEN (
SELECT
ACTIVEFLAG
FROM
CTE1
) = 1
THEN 'YES'
WHEN (
SELECT
ACTIVEFLAG
FROM
CTE1
) = 0
THEN 'NO'
END AS RESULT
)
SELECT
RESULT
FROM
CTE2
$$;
SELECT
PURCHASING.HasActiveFlag(1516) as has_active_flag;
결과¶
HAS_ACTIVE_FLAG |
|---|
NO |
중첩된 문¶
중첩된 문의 경우 정형 프로그래밍이 단일 쿼리로 변환됩니다. 플로우 제어의 문은 실행 순서를 유지하기 위해 테이블 구조에 중첩됩니다.
참고
CASE EXPRESSIONS 은 문당 1개의 값만 반환할 수 있습니다
예¶
참고
두 프로그래밍 패러다임의 다음 코드는 기능적으로 동일합니다.
정형 프로그래밍¶
DECLARE @VendorId AS int;
DECLARE @AccountNumber AS VARCHAR(50);
SELECT @VendorId = poh.VendorID
FROM Purchasing.PurchaseOrderHeader poh
WHERE PurchaseOrderID = 1
SELECT @AccountNumber = v.AccountNumber
FROM Purchasing.Vendor v
WHERE v.BusinessEntityID = @VendorId
SQL¶
SELECT V.AccountNumber AccountNumber
FROM (SELECT poh.VendorID VendorId
FROM Purchasing.PurchaseOrderHeader poh
WHERE PurchaseOrderID = 1
) T1, Purchasing.Vendor v
WHERE v.BusinessEntityID = T1.VendorId
결과¶
AccountNumber |
|---|
LITWARE0001 |
SELECTs 를 통한 조건부 변수¶
조건문 내에서 변수를 정의하고 할당하는 것은 코드 아래쪽에서 변수를 참조할 때 변수가 마지막으로 수정된 위치를 알아야 하므로 다소 문제가 되는 경향이 있습니다. 뿐만 아니라 참조가 다른 조건문 내에 있는 경우 이전에 알려진 변수에 대한 할당을 참조하는 일종의 리디렉션이 있어야 합니다.
이러한 모든 상황은 입력 코드에서 찾을 수 있는 중첩 및 복잡한 쿼리로 인해 악화됩니다. 그렇기 때문에 이러한 패턴이 발견되면 특정 EWI가 추가됩니다.
다음 시나리오에서 첫 번째 IF 문은 내용이 충분히 간단하기 때문에 문제 없이 변환할 수 있습니다. 두 번째와 세 번째 IF 문은 SELECT 를 통한 변수 할당 이외의 문이 있기 때문에 현재 지원되지 않으므로 설명이 생략되었습니다.
SQL 서버¶
쿼리¶
CREATE or ALTER FUNCTION PURCHASING.SELECTINUDF (
@param1 varchar(12)
)
RETURNS int
AS
BEGIN
declare @var1 int;
declare @var2 int;
declare @var3 int;
IF @param1 = 'first'
BEGIN
select @var1 = col1 + 10 from table1 WHERE id = 0;
select @var2 = col1 + 20 from table1 WHERE id = 0;
select @var3 = col1 + 30 from table1 WHERE id = 0;
END
IF @param1 = 'second'
BEGIN
declare @var4 int = 10;
select @var1 = col1 + 40 from table1 WHERE id = 0;
select @var2 = col1 + 40 from table1 WHERE id = 0;
END
IF @param1 = 'third'
BEGIN
select col1 from table1 where id = 0;
select @var1 = col1 + 50 from table1 WHERE id = 0;
select @var2 = col1 + 50 from table1 WHERE id = 0;
END
RETURN @var1
END
SELECT PURCHASING.SELECTINUDF('first') as result; -- Assuming table1.col1 is 0 when ID = 0
결과¶
RESULT |
|---|
10 |
Snowflake¶
쿼리¶
CREATE OR REPLACE FUNCTION PURCHASING.SELECTINUDF (PARAM1 STRING)
RETURNS INT
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
$$
WITH CTE1 AS
(
SELECT
CASE
WHEN PARAM1 = 'first'
THEN (SELECT
col1 + 10 AS VAR1 from
table1
WHERE
id = 0)
END AS VAR1,
CASE
WHEN PARAM1 = 'first'
THEN (SELECT
col1 + 20 AS VAR2 from
table1
WHERE
id = 0)
END AS VAR2,
CASE
WHEN PARAM1 = 'first'
THEN (SELECT
col1 + 30 AS VAR3 from
table1
WHERE
id = 0)
END AS VAR3
),
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'IF STATEMENT' NODE ***/!!!
CTE2 AS
(
/* IF @param1 = 'second'
BEGIN
declare @var4 int = 10;
select @var1 = col1 + 40 from table1 WHERE id = 0;
select @var2 = col1 + 40 from table1 WHERE id = 0;
END*/
SELECT
null
),
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'IF STATEMENT' NODE ***/!!!
CTE3 AS
(
/* IF @param1 = 'third'
BEGIN
select col1 from table1 where id = 0;
select @var1 = col1 + 50 from table1 WHERE id = 0;
select @var2 = col1 + 50 from table1 WHERE id = 0;
END*/
SELECT
null
),
CTE4 AS
(
SELECT
PURCHASING.SELECTINUDF('first') as result
)
SELECT
VAR1
FROM
CTE4
$$ -- Assuming table1.col1 is 0 when ID = 0
;
결과¶
RESULT |
|---|
10 |
변수 할당 및 반환¶
이 간단한 패턴에서는 변수 선언을 한 다음 SELECT 문을 사용하여 해당 변수를 설정하고 마지막으로 반환합니다. 원래 동작을 유지하기 위해 공통 테이블 식으로 마이그레이션할 예정입니다.
SQL 서버¶
쿼리¶
CREATE OR ALTER FUNCTION Purchasing.GetTotalFreight()
RETURNS MONEY AS
BEGIN
DECLARE @Result MONEY
SELECT @Result = ISNULL(SUM(t.Freight), 0) from Purchasing.PurchaseOrderHeader t
return @Result
END
GO
select Purchasing.GetTotalFreight() as Result;
결과¶
결과 |
|---|
1583978.2263 |
Snowflake¶
쿼리¶
CREATE OR REPLACE FUNCTION Purchasing.GetTotalFreight ()
RETURNS NUMBER(38, 4)
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
$$
WITH CTE1 AS
(
SELECT
NVL(SUM(t.Freight), 0) AS RESULT from
Purchasing.PurchaseOrderHeader t
)
SELECT
RESULT
FROM
CTE1
$$;
select
Purchasing.GetTotalFreight() as Result;
결과¶
RESULT |
|---|
1583978.2263 |
다중 함수 호출¶
이 특정 패턴의 경우 명백한 쿼리는 없지만 동일한 변수에 대해 작업하고 마지막에 반환하는 여러 함수에 대한 호출이 여러 번 있습니다. Snowflake는 함수 내부의 쿼리만 지원하므로 이 블록의 해결책은 Select에 추가하고 내부에 호출을 중첩하여 반환 값이 소스의 반환 값과 동일한지 확인하는 것입니다.
SQL 서버¶
쿼리¶
CREATE OR ALTER FUNCTION PURCHASING.Foo
(
@PARAM1 INT
)
RETURNS varchar(25)
AS
BEGIN
DECLARE @filter INT = @PARAM1
DECLARE @NAME VARCHAR(25) = (SELECT Name from Purchasing.Vendor v where BusinessEntityID = @filter)
SET @NAME = REPLACE(@NAME, 'Australia', 'USA')
SET @NAME = REPLACE(@NAME, 'Bike', 'Car')
RETURN @NAME
END
GO
SELECT PURCHASING.Foo(1492) AS Name;
결과¶
이름 |
|---|
USA Car Retailer |
Snowflake¶
쿼리¶
CREATE OR REPLACE FUNCTION PURCHASING.Foo (PARAM1 INT)
RETURNS VARCHAR(25)
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
$$
WITH CTE1 AS
(
SELECT
PARAM1 AS FILTER
),
CTE2 AS
(
SELECT
(SELECT
Name
from
Purchasing.Vendor v
where
BusinessEntityID = (
SELECT
FILTER
FROM
CTE1
)
) AS NAME
),
CTE3 AS
(
SELECT
REPLACE((
SELECT
NAME
FROM
CTE3
), 'Australia', 'USA') AS NAME
),
CTE4 AS
(
SELECT
REPLACE((
SELECT
NAME
FROM
CTE4
), 'Bike', 'Car') AS NAME
)
SELECT
NAME
FROM
CTE4
$$;
SELECT
PURCHASING.Foo(1492) AS Name;
결과¶
NAME |
|---|
USA Car Retailer |
여러 IF 조건에 따라 변수를 증가시키고 그 값을 반환합니다¶
이 패턴의 경우 여러 IF 조건을 사용하여 변수를 수정(이 경우 증가)합니다. 처음에 변수 세트가 초기화되고 결과 변수를 늘릴지 여부를 결정하는 데 사용됩니다. 마지막으로 결과 변수가 반환됩니다.
SQL 서버¶
쿼리¶
CREATE OR ALTER FUNCTION PURCHASING.FOO()
RETURNS MONEY
AS
BEGIN
declare @firstValue MONEY
declare @secondValue MONEY
declare @Result MONEY
select @Result = 0
select @firstValue = SubTotal from Purchasing.PurchaseOrderHeader where PurchaseOrderID = 1
select @secondValue = SubTotal from Purchasing.PurchaseOrderHeader where PurchaseOrderID = 2
if @firstValue is not null
select @Result = @Result + @firstValue
if @secondValue is not null
select @Result = @Result + @secondValue
return @Result
END
GO
SELECT PURCHASING.Foo() AS Result;
결과¶
결과 |
|---|
473.1415 |
Snowflake¶
쿼리¶
CREATE OR REPLACE FUNCTION PURCHASING.FOO ()
RETURNS NUMBER(38, 4)
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
$$
WITH CTE1 AS
(
select
0 AS RESULT
),
CTE2 AS
(
select
SubTotal AS FIRSTVALUE
from
Purchasing.PurchaseOrderHeader
where
PurchaseOrderID = 1
),
CTE3 AS
(
select
SubTotal AS SECONDVALUE
from
Purchasing.PurchaseOrderHeader
where
PurchaseOrderID = 2
),
CTE4 AS
(
SELECT
CASE
WHEN (
SELECT
FIRSTVALUE
FROM
CTE2
) is not null
THEN (
select
(
SELECT
RESULT
FROM
CTE1
) + (
SELECT
FIRSTVALUE
FROM
CTE2
) AS RESULT)
END AS RESULT
),
CTE5 AS
(
SELECT
CASE
WHEN (
SELECT
SECONDVALUE
FROM
CTE3
) is not null
THEN (
select
(
SELECT
RESULT
FROM
CTE1
) + (
SELECT
SECONDVALUE
FROM
CTE3
) AS RESULT)
ELSE (SELECT
RESULT
FROM
CTE4)
END AS RESULT
)
SELECT
RESULT
FROM
CTE5
$$;
SELECT
PURCHASING.Foo() AS Result;
결과¶
RESULT |
|---|
473.1415 |
RETURN 문 2개 이상¶
이 패턴에서는 CASE 식에서 실행되는 마지막 문과 같이 코드 플로우를 끊는 반환 절이 포함된 IF 블록을 본문 끝에 추가합니다.
기본 케이스¶
이 특정 시나리오의 경우 조건부 RETURN 문과 최종 RETURN 문 사이에는 논리가 없으므로 모든 본문이 단일 CASE EXPRESSION 에 매핑됩니다.
SQL 서버¶
쿼리¶
CREATE OR ALTER FUNCTION [PURCHASING].[FOO] ()
RETURNS INT
AS
BEGIN
IF exists (SELECT PreferredVendorStatus FROM Purchasing.Vendor v )
RETURN 1
RETURN 0
END
GO
SELECT PURCHASING.FOO() as result;
결과¶
결과 |
|---|
1 |
Snowflake¶
쿼리¶
CREATE OR REPLACE FUNCTION PURCHASING.FOO ()
RETURNS INT
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
$$
SELECT
CASE
WHEN exists (SELECT
PreferredVendorStatus
FROM
Purchasing.Vendor v
)
THEN 1
ELSE 0
END
$$;
SELECT
PURCHASING.FOO() as result;
결과¶
RESULT |
|---|
1 |
일반 테이블 식¶
일반 테이블 식은 원래 코드와 같이 유지되며 생성된 식과 연결됩니다. SnowConvert AI는 중복된 이름 생성을 방지하기 위해 먼저 모든 원래 COMMON TABLE EXPRESSION 이름을 식별할 수 있습니다.
SQL 서버¶
쿼리¶
CREATE OR ALTER FUNCTION [PURCHASING].[FOO]
(
@status INT
)
Returns INT
As
Begin
Declare @result as int = 0
;WITH ctetable(RevisionNumber) as
(
SELECT RevisionNumber
FROM Purchasing.PurchaseOrderHeader poh
where poh.Status = @status
),
finalCte As
(
SELECT RevisionNumber FROM ctetable
)
Select @result = count(RevisionNumber) from finalCte
return @result;
End
GO
SELECT PURCHASING.FOO(4) as result;
결과¶
결과 |
|---|
3689 |
Snowflake¶
쿼리¶
CREATE OR REPLACE FUNCTION PURCHASING.FOO (STATUS INT)
Returns INT
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"transact"}}'
AS
$$
WITH CTE1 AS
(
SELECT
0 AS RESULT
),
ctetable (
RevisionNumber
) as
(
SELECT
RevisionNumber
FROM
Purchasing.PurchaseOrderHeader poh
where
poh.Status = STATUS
),
finalCte As
(
SELECT
RevisionNumber
FROM
ctetable
),
CTE2 AS
(
Select
COUNT(RevisionNumber) AS RESULT from
finalCte
)
SELECT
RESULT
FROM
CTE2
$$;
SELECT
PURCHASING.FOO(4) as result;
결과¶
RESULT |
|---|
3689 |
JavaScript UDFs 로 변환¶
문이 여러 개 있고 함수가 데이터베이스에 어떤 방식으로도 액세스하지 않는 경우 기능적 동등성을 유지하면서 JavaScript 함수로 변환할 수 있습니다
SQL 서버¶
쿼리 1¶
CREATE OR ALTER FUNCTION PURCHASING.GetFiscalYear
(
@DATE AS DATETIME
)
RETURNS INT
AS
BEGIN
DECLARE @FiscalYear AS INT
DECLARE @CurMonth AS INT
SET @CurMonth = DATEPART(M,@DATE)
SET @FiscalYear = DATEPART(YYYY, @DATE)
IF (@CurMonth >= 7)
BEGIN
SET @FiscalYear = @FiscalYear + 1
END
RETURN @FiscalYear
END
GO
SELECT PURCHASING.GetFiscalYear('2020-10-10') as DATE;
쿼리 2¶
CREATE OR ALTER FUNCTION PURCHASING.[getCleanChargeCode]
(
@ChargeCode varchar(50)
)
returns varchar(50) as
begin
declare @CleanChargeCode varchar(50),@Len int,@Pos int=2
set @Pos=LEN(@ChargeCode)-1
while @Pos > 1
begin
set @CleanChargeCode=RIGHT(@ChargeCode,@Pos)
if TRY_CAST(@CleanChargeCode as bigint) is not null
return @CleanChargeCode
set @Pos=@Pos-1
end
set @Pos=LEN(@ChargeCode)-1
while @Pos > 1
begin
set @CleanChargeCode=LEFT(@ChargeCode,@Pos)
if TRY_CAST(@CleanChargeCode as bigint) is not null
return @CleanChargeCode
set @Pos=@Pos-1
end
return null
end
GO
SELECT PURCHASING.[getCleanChargeCode]('16test') AS CleanChargeCode;
결과 1¶
DATE |
|---|
2021 |
결과 2¶
CleanChargeCode |
|---|
16 |
Snowflake¶
쿼리 1¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0068 - USER DEFINED FUNCTION WAS TRANSFORMED TO SNOWFLAKE PROCEDURE ***/!!!
CREATE OR REPLACE PROCEDURE PURCHASING.GetFiscalYear (DATE TIMESTAMP_NTZ(3))
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "07/11/2025", "domain": "no-domain-provided" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
FISCALYEAR INT;
CURMONTH INT;
BEGIN
CURMONTH := DATE_PART(month, :DATE :: TIMESTAMP);
FISCALYEAR := DATE_PART(year, :DATE :: TIMESTAMP);
IF ((:CURMONTH >= 7)) THEN
BEGIN
FISCALYEAR := :FISCALYEAR + 1;
END;
END IF;
RETURN :FISCALYEAR;
END;
$$;
SELECT
PURCHASING.GetFiscalYear('2020-10-10') !!!RESOLVE EWI!!! /*** SSC-EWI-0067 - UDF WAS TRANSFORMED TO SNOWFLAKE PROCEDURE, CALLING PROCEDURES INSIDE QUERIES IS NOT SUPPORTED ***/!!! as DATE;
쿼리 2¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0068 - USER DEFINED FUNCTION WAS TRANSFORMED TO SNOWFLAKE PROCEDURE ***/!!!
CREATE OR REPLACE PROCEDURE PURCHASING.getCleanChargeCode (CHARGECODE STRING)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "07/16/2025", "domain": "no-domain-provided" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
CLEANCHARGECODE VARCHAR(50);
LEN INT;
POS INT := 2;
BEGIN
POS := LEN(:CHARGECODE)-1;
WHILE (:POS > 1) LOOP
CLEANCHARGECODE := RIGHT(:CHARGECODE, :POS);
IF (CAST(:CLEANCHARGECODE AS BIGINT) /*** SSC-FDM-TS0005 - TRY_CONVERT/TRY_CAST COULD NOT BE CONVERTED TO TRY_CAST ***/!!!RESOLVE EWI!!! /*** SSC-EWI-TS0074 - CAST RESULT MAY BE DIFFERENT FROM TRY_CAST FUNCTION DUE TO MISSING DEPENDENCIES ***/!!! is not null) THEN
RETURN :CLEANCHARGECODE;
END IF;
POS := :POS -1;
END LOOP;
POS := LEN(:CHARGECODE)-1;
WHILE (:POS > 1) LOOP
CLEANCHARGECODE := LEFT(:CHARGECODE, :POS);
IF (CAST(:CLEANCHARGECODE AS BIGINT) /*** SSC-FDM-TS0005 - TRY_CONVERT/TRY_CAST COULD NOT BE CONVERTED TO TRY_CAST ***/!!!RESOLVE EWI!!! /*** SSC-EWI-TS0074 - CAST RESULT MAY BE DIFFERENT FROM TRY_CAST FUNCTION DUE TO MISSING DEPENDENCIES ***/!!! is not null) THEN
RETURN :CLEANCHARGECODE;
END IF;
POS := :POS -1;
END LOOP;
RETURN null;
END;
$$;
SELECT
PURCHASING.getCleanChargeCode('16test') !!!RESOLVE EWI!!! /*** SSC-EWI-0067 - UDF WAS TRANSFORMED TO SNOWFLAKE PROCEDURE, CALLING PROCEDURES INSIDE QUERIES IS NOT SUPPORTED ***/!!! AS CleanChargeCode;
결과 1¶
DATE |
|---|
2021.0 |
결과 2¶
CLEANCHARGECODE |
|---|
16 |
Known Issues¶
경고
사용자 정의 함수는 데이터베이스 상태를 수정하는 작업을 수행하는 데 사용할 수 없습니다
경고
사용자 정의 함수에는 테이블을 대상으로 하는 OUTPUT INTO 절을 포함할 수 없습니다
경고
사용자 정의 함수는 DECLARE, OPEN, FETCH, CLOSE 또는 DEALLOCATE a CURSOR 가 아니어야 합니다. 커서를 사용해야 하는 경우 저장 프로시저를 사용합니다.
경고
사용자 정의 함수는 데이터베이스에 대한 호출이 1개 이상 있는 경우 WHILE 같은 플로우 제어 문을 수행할 수 없습니다
경고
저장 프로시저로 변환된 다른 사용자 정의 함수에 대한 참조가 있는 사용자 정의 함수도 저장 프로시저로 변환됩니다.
경고
@@ROWCOUNT 를 사용하는 사용자 정의 함수는 SQL 에서 지원되지 않으며 기능적 동등성을 유지하기 위해 저장 프로시저로 변환해야 합니다.
경고
변수를 자신에게 할당하는SELECT문이 있는 사용자 정의 함수는 Snowflake에서 지원되지 않습니다. SELECT @local_variable 참조
지원되지 않는 모든 케이스에 대해서는 관련 EWIs 및 아래 패턴을 확인하여 권장 사항과 가능한 해결 방법을 확인하십시오.
쿼리 옆의 if/else 문 이외의 조건문¶
다음 시나리오는 다른 쿼리와 함께 “while 문”을 사용하는 경우입니다. 이 예제의 문제점은 메인 선택의 WITH 절 내에 있는 동안 문을 CTE 으로 변환할 방법이 없기 때문에 동일한 논리를 유지하기 위해 이 문을 JavaScript 프로시저로 변환해야 한다는 것입니다.
SQL 서버¶
쿼리¶
CREATE OR ALTER FUNCTION PURCHASING.FOO()
RETURNS INT
AS
BEGIN
DECLARE @i int = 0, @p int;
Select @p = COUNT(*) FROM PURCHASING.VENDOR
WHILE (@p < 1000)
BEGIN
SET @i = @i + 1
SET @p = @p + @i
END
IF (@i = 6)
RETURN 1
RETURN @p
END
GO
SELECT PURCHASING.FOO() as result;
결과¶
결과 |
|---|
1007 |
Snowflake
쿼리¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0068 - USER DEFINED FUNCTION WAS TRANSFORMED TO SNOWFLAKE PROCEDURE ***/!!!
CREATE OR REPLACE PROCEDURE PURCHASING.FOO ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "07/11/2025", "domain": "no-domain-provided" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
I INT := 0;
P INT;
BEGIN
Select
COUNT(*)
INTO
:P
FROM
PURCHASING.VENDOR;
WHILE (:P < 1000) LOOP
I := :I + 1;
P := :P + :I;
END LOOP;
IF ((:I = 6)) THEN
RETURN 1;
END IF;
RETURN :P;
END;
$$;
SELECT
PURCHASING.FOO() !!!RESOLVE EWI!!! /*** SSC-EWI-0067 - UDF WAS TRANSFORMED TO SNOWFLAKE PROCEDURE, CALLING PROCEDURES INSIDE QUERIES IS NOT SUPPORTED ***/!!! as result;
결과¶
FOO |
|---|
1007 |
행 집합을 반복하는 자체 값을 사용하여 변수 할당하기¶
다음 예제에서는 @names 변수를 사용하여 열의 여러 값을 1개의 문자열로 연결합니다. 변수는 그림과 같이 각 반복마다 업데이트되며 SnowFlake UDFs 에서 지원되지 않습니다. 이 시나리오에서는 함수를 _procedure_로 변환해야 합니다.
SQL 서버
쿼리¶
CREATE OR ALTER FUNCTION PURCHASING.FOO()
RETURNS VARCHAR(8000)
AS
BEGIN
DECLARE @names varchar(8000)
SET @names = ''
SELECT @names = ISNULL(@names + ' ', '') + Name from Purchasing.Vendor v
return @names
END
GO
select PURCHASING.FOO() as names;
결과¶
names |
|---|
Australia Bike Retailer Allenson Cycles Advanced Bicycles Trikes, Inc. Morgan Bike Accessories Cycling Master Chicago Rent-All Greenwood Athletic Company Compete Enterprises, Inc International Light Speed Training Systems Gardner Touring Cycles Internati |
Snowflake 쿼리
!!!RESOLVE EWI!!! /*** SSC-EWI-0068 - USER DEFINED FUNCTION WAS TRANSFORMED TO SNOWFLAKE PROCEDURE ***/!!!
CREATE OR REPLACE PROCEDURE PURCHASING.FOO ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "07/11/2025", "domain": "no-domain-provided" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
NAMES VARCHAR(8000);
BEGIN
NAMES := '';
SELECT
NVL(:NAMES || ' ', '') + Name
INTO
:NAMES
from
Purchasing.Vendor v;
RETURN :NAMES;
END;
$$;
select
PURCHASING.FOO() !!!RESOLVE EWI!!! /*** SSC-EWI-0067 - UDF WAS TRANSFORMED TO SNOWFLAKE PROCEDURE, CALLING PROCEDURES INSIDE QUERIES IS NOT SUPPORTED ***/!!! as names;
경고
위에서 설명한 시나리오의 경우 다음 제한 사항을 고려하십시오.
SELECT,INSERT,DELETE,UPDATE또는MERGE같은 DML 쿼리에서 사용자 정의 함수에 대한 모든 호출은 이러한 쿼리 내의 저장 프로시저 호출이 허용되지 않으므로 실패합니다.프로시저 내에서 사용자 정의 함수를 호출할 때는
CALL키워드를 앞에 붙여야 합니다.에 사용되는 사용 정의 함수는 COMPUTEDCOLUMNS 에서 사용되는 사용 정의 함수는 실행 중에 실패합니다.
관련 EWIs¶
SSC-EWI-0067: UDF 가 Snowflake 프로시저로 변환되었으며, 쿼리 내에서 프로시저를 호출하는 기능은 지원되지 않습니다.
SSC-EWI-0068: 사용자 정의 함수가 Snowflake 프로시저로 변환되었습니다.
SSC-EWI-0073: 보류 중 함수 동등성 검토.
Snowflake 스크립트 UDF(SCALAR)¶
SQL Server 스칼라 사용자 정의 함수에서 [Snowflake Scripting UDFs]로의 변환 참조(/developer-guide/udf/sql/udf-sql-procedural-functions)
Applies to
SQL 서버
Azure 시냅스 분석
설명¶
SnowConvert는 특정 기준을 충족하는 경우 모든 함수를 저장 프로시저로 변환하는 대신 SQL Server 스칼라 사용자 정의 함수를 Snowflake Scripting UDFs(SnowScript UDFs)로 직접 변환하도록 지원합니다.
Snowflake Scripting UDFs는 SQL UDF 본문 내에서 Snowflake의 프로시저 언어 구문(Snowscript)을 사용하여 작성된 사용자 정의 함수입니다. 변수, 루프, 조건부 논리, 예외 처리를 지원합니다.
함수가 SnowScript UDFs가 되는 경우¶
SnowConvert는 각 SQL Server 함수를 분석하고 적절한 Snowflake 대상을 자동으로 결정합니다. 함수는 데이터 액세스 작업 없이 프로시저 논리만 포함하는 경우 SnowScript UDF가 됩니다.
샘플 소스 패턴¶
단순 계산 함수¶
데이터를 쿼리하지 않고 계산을 수행하는 기본 스칼라 함수입니다.
SQL 서버¶
CREATE FUNCTION dbo.CalculateProfit
(
@Cost DECIMAL(10,2),
@Revenue DECIMAL(10,2)
)
RETURNS DECIMAL(10,2)
AS
BEGIN
DECLARE @Profit DECIMAL(10,2)
SET @Profit = @Revenue - @Cost
RETURN @Profit
END
GO
SELECT dbo.CalculateProfit(100.00, 150.00) as Profit;
결과¶
Profit |
|---|
50.00 |
Snowflake(SnowScript UDF)¶
CREATE OR REPLACE FUNCTION dbo.CalculateProfit (COST DECIMAL(10,2), REVENUE DECIMAL(10,2))
RETURNS DECIMAL(10, 2)
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "10/09/2025", "domain": "no-domain-provided", "migrationid": "QsqZARsvG3aeleeXZB43fg==" }}'
AS
$$
DECLARE
PROFIT DECIMAL(10, 2);
BEGIN
PROFIT := :REVENUE - :COST;
RETURN :PROFIT;
END;
$$;
SELECT
dbo.CalculateProfit(100.00, 150.00) as Profit;
결과¶
PROFIT |
|---|
50.00 |
조건부 논리(IF/ELSE)가 있는 함수¶
비즈니스 논리에 대해 IF/ELSE 문을 사용하는 함수입니다.
SQL 서버¶
CREATE FUNCTION dbo.GetDiscountRate
(
@CustomerType VARCHAR(20),
@OrderAmount DECIMAL(10,2)
)
RETURNS DECIMAL(5,2)
AS
BEGIN
DECLARE @Discount DECIMAL(5,2)
IF @CustomerType = 'Premium'
SET @Discount = 0.15
ELSE IF @CustomerType = 'Standard'
SET @Discount = 0.10
ELSE
SET @Discount = 0.05
IF @OrderAmount > 1000
SET @Discount = @Discount + 0.05
RETURN @Discount
END
GO
SELECT dbo.GetDiscountRate('Premium', 1200.00) as DiscountRate;
결과¶
DiscountRate |
|---|
0.20 |
Snowflake(SnowScript UDF)¶
CREATE OR REPLACE FUNCTION dbo.GetDiscountRate (CUSTOMERTYPE STRING, ORDERAMOUNT DECIMAL(10,2))
RETURNS DECIMAL(5, 2)
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "10/09/2025", "domain": "no-domain-provided", "migrationid": "QsqZARsvG3aeleeXZB43fg==" }}'
AS
$$
DECLARE
DISCOUNT DECIMAL(5, 2);
BEGIN
IF (:CUSTOMERTYPE = 'Premium') THEN
DISCOUNT := 0.15;
ELSEIF (:CUSTOMERTYPE = 'Standard') THEN
DISCOUNT := 0.10;
ELSE
DISCOUNT := 0.05;
END IF;
IF (:ORDERAMOUNT > 1000) THEN
DISCOUNT := :DISCOUNT + 0.05;
END IF;
RETURN :DISCOUNT;
END;
$$;
SELECT
dbo.GetDiscountRate('Premium', 1200.00) as DiscountRate;
결과¶
DISCOUNTRATE |
|---|
0.20 |
WHILE 루프가 있는 함수¶
반복 계산을 위해 WHILE 루프를 사용하는 함수입니다.
SQL 서버¶
CREATE FUNCTION dbo.Factorial
(
@Number INT
)
RETURNS BIGINT
AS
BEGIN
DECLARE @Result BIGINT = 1
DECLARE @Counter INT = 1
WHILE @Counter <= @Number
BEGIN
SET @Result = @Result * @Counter
SET @Counter = @Counter + 1
END
RETURN @Result
END
GO
SELECT dbo.Factorial(5) as FactorialResult;
결과¶
FactorialResult |
|---|
120 |
Snowflake(SnowScript UDF)¶
CREATE OR REPLACE FUNCTION dbo.Factorial (NUMBER INT)
RETURNS BIGINT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "10/09/2025", "domain": "no-domain-provided", "migrationid": "QsqZARsvG3aeleeXZB43fg==" }}'
AS
$$
DECLARE
RESULT BIGINT := 1;
COUNTER INT := 1;
BEGIN
WHILE (:COUNTER <= :NUMBER) LOOP
RESULT := :RESULT * :COUNTER;
COUNTER := :COUNTER + 1;
END LOOP;
RETURN :RESULT;
END;
$$;
SELECT
dbo.Factorial(5) as FactorialResult;
결과¶
FACTORIALRESULT |
|---|
120 |
문자열 조작 함수¶
루프 및 조건부 논리를 사용하는 복잡한 문자열 작업입니다.
SQL 서버¶
CREATE FUNCTION dbo.CleanPhoneNumber
(
@Phone VARCHAR(20)
)
RETURNS VARCHAR(10)
AS
BEGIN
DECLARE @Clean VARCHAR(10) = ''
DECLARE @i INT = 1
DECLARE @Char CHAR(1)
WHILE @i <= LEN(@Phone)
BEGIN
SET @Char = SUBSTRING(@Phone, @i, 1)
IF @Char BETWEEN '0' AND '9'
SET @Clean = @Clean + @Char
SET @i = @i + 1
END
RETURN @Clean
END
GO
SELECT dbo.CleanPhoneNumber('(555) 123-4567') as CleanPhone;
결과¶
CleanPhone |
|---|
5551234567 |
Snowflake(SnowScript UDF)¶
CREATE OR REPLACE FUNCTION dbo.CleanPhoneNumber (PHONE STRING)
RETURNS VARCHAR(10)
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "10/09/2025", "domain": "no-domain-provided", "migrationid": "QsqZARsvG3aeleeXZB43fg==" }}'
AS
$$
DECLARE
CLEAN VARCHAR(10) := '';
I INT := 1;
CHAR CHAR(1);
BEGIN
WHILE (:I <= LEN(:PHONE)) LOOP
CHAR := SUBSTRING(:PHONE, :I, 1);
IF (:CHAR BETWEEN '0' AND '9') THEN
CLEAN := :CLEAN + :CHAR;
END IF;
I := :I + 1;
END LOOP;
RETURN :CLEAN;
END;
$$;
SELECT
dbo.CleanPhoneNumber('(555) 123-4567') as CleanPhone;
결과¶
CLEANPHONE |
|---|
5551234567 |
CASE 문 논리¶
분류를 위해 CASE 식을 사용하는 함수입니다.
SQL 서버¶
CREATE FUNCTION dbo.GetGrade
(
@Score INT
)
RETURNS CHAR(1)
AS
BEGIN
DECLARE @Grade CHAR(1)
SET @Grade = CASE
WHEN @Score >= 90 THEN 'A'
WHEN @Score >= 80 THEN 'B'
WHEN @Score >= 70 THEN 'C'
WHEN @Score >= 60 THEN 'D'
ELSE 'F'
END
RETURN @Grade
END
GO
SELECT dbo.GetGrade(85) as Grade;
결과¶
Grade |
|---|
B |
Snowflake(SnowScript UDF)¶
CREATE OR REPLACE FUNCTION dbo.GetGrade (SCORE INT)
RETURNS CHAR(1)
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "10/09/2025", "domain": "no-domain-provided", "migrationid": "QsqZARsvG3aeleeXZB43fg==" }}'
AS
$$
DECLARE
GRADE CHAR(1);
BEGIN
CASE
WHEN :SCORE >= 90 THEN
GRADE := 'A';
WHEN :SCORE >= 80 THEN
GRADE := 'B';
WHEN :SCORE >= 70 THEN
GRADE := 'C';
WHEN :SCORE >= 60 THEN
GRADE := 'D';
ELSE
GRADE := 'F';
END;
RETURN :GRADE;
END;
$$;
SELECT
dbo.GetGrade(85) as Grade;
결과¶
GRADE |
|---|
B |
Select Into variable assingment¶
Functions using simple select into for variable assignment.
SQL 서버¶
CREATE FUNCTION dbo.CalculatePrice
(
@BasePrice DECIMAL(10, 2),
@Quantity INT
)
RETURNS DECIMAL(10, 2)
AS
BEGIN
DECLARE @Discount DECIMAL(5, 2);
DECLARE @Subtotal DECIMAL(10, 2);
DECLARE @FinalPrice DECIMAL(10, 2);
SELECT @Discount = CASE
WHEN @Quantity >= 10 THEN 0.15
WHEN @Quantity >= 5 THEN 0.10
ELSE 0.05
END,
@Subtotal = @BasePrice * @Quantity;
SET @FinalPrice = @Subtotal * (1 - @Discount);
RETURN @FinalPrice;
END;
결과¶
CALCULATEPRICE(100, 3) |
|---|
285 |
Snowflake(SnowScript UDF)¶
CREATE OR REPLACE FUNCTION dbo.CalculatePrice (BASEPRICE DECIMAL(10, 2), QUANTITY INT)
RETURNS DECIMAL(10, 2)
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "transact", "convertedOn": "11/26/2025", "domain": "no-domain-provided", "migrationid": "T8GaASfFsHeOffK4v3SnIQ==" }}'
AS
$$
DECLARE
DISCOUNT DECIMAL(5, 2);
SUBTOTAL DECIMAL(10, 2);
FINALPRICE DECIMAL(10, 2);
BEGIN
DISCOUNT := CASE
WHEN :QUANTITY >= 10 THEN 0.15
WHEN :QUANTITY >= 5 THEN 0.10
ELSE 0.05
END;
SUBTOTAL := :BASEPRICE * :QUANTITY;
FINALPRICE := :SUBTOTAL * (1 - :DISCOUNT);
RETURN :FINALPRICE;
END;
$$;
결과¶
CALCULATEPRICE(100, 3) |
|---|
285 |
Known Issues¶
경고
SnowConvert AI will not translate UDFs containing the following elements into SnowScripting UDFs, as these features are unsupported in SnowScripting UDFs:
데이터베이스 테이블 액세스
커서 사용
기타 UDFs 호출
집계 또는 윈도우 함수 포함
DML 작업(INSERT/UPDATE/DELETE) 수행
결과 세트 반환
관련 EWIs¶
SSC-EWI-0067: UDF 가 Snowflake 프로시저로 변환되었으며, 쿼리 내에서 프로시저를 호출하는 기능은 지원되지 않습니다.
SSC-EWI-0068: 사용자 정의 함수가 Snowflake 프로시저로 변환되었습니다.
SSC-EWI-0073: 보류 중 함수 동등성 검토.