SnowConvert : Teradata SQL vers Snowflake Scripting (Procédures)¶
ABORT et ROLLBACK¶
Description ¶
Les instructions ABORT
et ROLLBACK
de Teradata sont remplacées par une instruction ROLLBACK
dans Snowflake Scripting.
Pour plus d’informations sur Teradata ABORT et pour ROLLBACK.
ABORT [abort_message] [FROM option] [WHERE abort_condition];
ROLLBACK [WORK] [abort_message] [FROM clause] [WHERE clause];
Échantillons de modèles de sources ¶
ABORT et ROLLBACK de base¶
Teradata ¶
REPLACE PROCEDURE procedureBasicAbort()
BEGIN
ABORT;
ROLLBACK;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE procedureBasicAbort ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
ROLLBACK;
ROLLBACK;
END;
$$;
ABORT et ROLLBACK conditionnels¶
Teradata ¶
REPLACE PROCEDURE procedureWhereAbort(AnotherValueProc INTEGER)
BEGIN
ABORT WHERE AValueProc > 2;
ROLLBACK WHERE (AnotherValueProc > 2);
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE procedureWhereAbort (ANOTHERVALUEPROC INTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/23/2024" }}'
EXECUTE AS CALLER
AS
$$
BEGIN
IF (AValueProc > 2) THEN
ROLLBACK;
END IF;
IF (AnotherValueProc > 2) THEN
ROLLBACK;
END IF;
END;
$$;
ABORT et ROLLBACK avec les références de table et clause FROM¶
Teradata ¶
CREATE TABLE ReferenceTable
(ColumnValue INTEGER);
CREATE TABLE ReferenceTable2
(ColumnValue INTEGER);
REPLACE PROCEDURE procedureFromAbort()
BEGIN
ROLLBACK FROM ReferenceTable, ReferenceTable2
WHERE ReferenceTable.ColumnValue = ReferenceTable2.ColumnValue;
ABORT FROM ReferenceTable, ReferenceTable2
WHERE ReferenceTable.ColumnValue = ReferenceTable2.ColumnValue;
END;
Snowflake Scripting ¶
CREATE OR REPLACE TABLE ReferenceTable
(
ColumnValue INTEGER)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
CREATE TABLE ReferenceTable2
(
ColumnValue INTEGER)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
CREATE OR REPLACE PROCEDURE procedureFromAbort ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
LET _ROW_COUNT FLOAT;
SELECT
COUNT(*)
INTO
_ROW_COUNT
FROM
ReferenceTable,
ReferenceTable2
WHERE
ReferenceTable.ColumnValue = ReferenceTable2.ColumnValue;
IF (_ROW_COUNT > 0) THEN
ROLLBACK;
END IF;
SELECT
COUNT(*)
INTO
_ROW_COUNT
FROM
ReferenceTable,
ReferenceTable2
WHERE
ReferenceTable.ColumnValue = ReferenceTable2.ColumnValue;
IF (_ROW_COUNT > 0) THEN
ROLLBACK;
END IF;
END;
$$;
ABORT et ROLLBACK avec des références de table sans la clause FROM¶
Teradata ¶
CREATE TABLE ReferenceTable
(ColumnValue INTEGER);
REPLACE PROCEDURE procedureFromTableAbort()
BEGIN
ROLLBACK WHERE ReferenceTable.ColumnValue > 2;
ABORT WHERE ReferenceTable.ColumnValue > 4;
END;
Snowflake Scripting ¶
CREATE OR REPLACE TABLE ReferenceTable
(
ColumnValue INTEGER)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
CREATE OR REPLACE PROCEDURE procedureFromTableAbort ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
LET _ROW_COUNT FLOAT;
SELECT
COUNT(*)
INTO
_ROW_COUNT
FROM
ReferenceTable
WHERE
ReferenceTable.ColumnValue > 2;
IF (_ROW_COUNT > 0) THEN
ROLLBACK;
END IF;
SELECT
COUNT(*)
INTO
_ROW_COUNT
FROM
ReferenceTable
WHERE
ReferenceTable.ColumnValue > 4;
IF (_ROW_COUNT > 0) THEN
ROLLBACK;
END IF;
END;
$$;
Problèmes connus¶
1. Custom Error Message¶
Bien que ROLLBACK AND ABORT soient pris en charge, leur utilisation avec un message d’erreur personnalisé n’est pas prise en charge.
Teradata ¶
ABORT 'Error message for abort';
ROLLBACK 'Error message for rollback';
Snowflake Scripting ¶
ABORT 'Error message for abort';
ROLLBACK 'Error message for rollback';
2. Aggregate function¶
L’utilisation de la fonction d’agrégation combinée avec ABORT/ROLLBACK n’est pas prise en charge
Teradata ¶
ROLLBACK WHERE SUM(ATable.AValue) < 2;
ABORT WHERE SUM(ATable.AValue) < 2;
Snowflake Scripting ¶
ROLLBACK WHERE SUM(ATable.AValue) < 2;
ABORT WHERE SUM(ATable.AValue) < 2;
ACTIVITY_COUNT¶
Description¶
La variable de statut ACTIVITY_COUNT
renvoie le nombre de lignes affectées par une instruction SQL DML dans une application intégrée SQL ou une procédure stockée. Pour plus d’informations, cliquez ici.
Il n’y a pas d’équivalent direct dans Snowflake. Toutefois, il existe une solution de contournement permettant d’émuler le comportement de ACTIVITY_COUNT
. Il suffit d’utiliser la requête suivante :
SELECT $1 FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()));
Cette requête récupère et renvoie la première colonne du jeu de résultats de la dernière requête exécutée dans la session en cours. En outre, $1
peut être remplacé par "number of rows inserted"
, "number of rows updated"
ou "number of rows deleted"
en fonction du type de requête.
Comme prévu, cette traduction se comporte comme son homologue de Teradata uniquement lorsqu’aucune autre requête que l’instruction SQL DML n’est exécutée avant l’appel à LAST_QUERY_ID
.
Modèles d’échantillons de sources¶
Données de configuration¶
Teradata¶
CREATE TABLE employees (
employee_id INT NOT NULL,
first_name VARCHAR(50),
last_name VARCHAR(50),
department_id INT,
salary DECIMAL(10,2),
PRIMARY KEY (employee_id)
);
INSERT INTO employees (employee_id, first_name, last_name, department_id, salary)
VALUES (1, 'John', 'Doe', 10, 60000.00);
INSERT INTO employees (employee_id, first_name, last_name, department_id, salary)
VALUES (2, 'Johny', 'Doey', 10, 65000.00);
INSERT INTO employees (employee_id, first_name, last_name, department_id, salary)
VALUES (3, 'Max', 'Smith', 10, 70000.00);
DROP TABLE activity_log;
CREATE TABLE activity_log (
log_id INT GENERATED ALWAYS AS IDENTITY (START WITH 1 INCREMENT BY 1) NOT NULL,
operation VARCHAR(200),
row_count INT,
log_timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (log_id)
);
Snowflake¶
CREATE OR REPLACE TABLE employees (
employee_id INT NOT NULL,
first_name VARCHAR(50),
last_name VARCHAR(50),
department_id INT,
salary DECIMAL(10,2),
PRIMARY KEY (employee_id)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/11/2024" }}'
;
INSERT INTO employees (employee_id, first_name, last_name, department_id, salary)
VALUES (1, 'John', 'Doe', 10, 60000.00);
INSERT INTO employees (employee_id, first_name, last_name, department_id, salary)
VALUES (2, 'Johny', 'Doey', 10, 65000.00);
INSERT INTO employees (employee_id, first_name, last_name, department_id, salary)
VALUES (3, 'Max', 'Smith', 10, 70000.00);
CREATE OR REPLACE TABLE activity_log (
log_id INT DEFAULT activity_log_log_id.NEXTVAL NOT NULL,
operation VARCHAR(200),
row_count INT,
log_timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP(),
PRIMARY KEY (log_id)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/11/2024" }}'
;
Utilisation prise en charge¶
Teradata¶
REPLACE PROCEDURE UpdateEmployeeSalaryAndLog ()
BEGIN
DECLARE row_count1 INT;
UPDATE employees
SET salary = 80000
WHERE department_id = 10;
-- Get the ACTIVITY_COUNT
SET row_count1 = ACTIVITY_COUNT;
-- Insert the ACTIVITY_COUNT into the activity_log table
INSERT INTO activity_log (operation, row_count)
VALUES ('UPDATE WHERE dept=10', row_count1);
END;
CALL UpdateEmployeeSalaryAndLog();
SELECT * FROM ACTIVITY_LOG;
LOG_ID | OPERATION | ROW_COUNT | LOG_TIMESTAMP |
-------+----------------------+-----------+----------------------------+
1 | UPDATE WHERE dept=10 | 3 | 2024-07-10 15:58:46.490000 |
Snowflake¶
CREATE OR REPLACE PROCEDURE UpdateEmployeeSalaryAndLog ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/11/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
row_count1 INT;
BEGIN
UPDATE employees
SET salary = 80000
WHERE department_id = 10;
-- Get the ACTIVITY_COUNT
row_count1 := (
SELECT
$1
FROM
TABLE(RESULT_SCAN(LAST_QUERY_ID()))
) /*** SSC-FDM-TD0033 - 'ACTIVITY_COUNT' TRANSFORMATION MIGHT REQUIRE MANUAL ADJUSTMENTS ***/;
-- Insert the ACTIVITY_COUNT into the activity_log table
INSERT INTO activity_log (operation, row_count)
VALUES ('UPDATE WHERE dept=10', :row_count1);
END;
$$;
CALL UpdateEmployeeSalaryAndLog();
SELECT
* FROM
ACTIVITY_LOG;
LOG_ID | OPERATION | ROW_COUNT | LOG_TIMESTAMP |
-------+----------------------+-----------+--------------------------+
102 | UPDATE WHERE dept=10 | 3 | 2024-07-11T12:42:35.280Z |
Problèmes connus¶
Si
ACTIVITY_COUNT
est appelé deux fois ou plus avant l’exécution d’une instruction DML, il se peut que la transformation ne renvoie pas les valeurs attendues. Cliquez ici.Si
ACTIVITY_COUNT
est appelé après l’exécution d’une instruction autre que DML, la transformation ne renverra pas les valeurs attendues. Cliquez ici.ACTIVITY_COUNT
nécessite une correction manuelle lorsqu’il se trouve à l’intérieur d’une instructionSELECT/SET INTO VARIABLE
et n’a pas pu être identifié comme nom de colonne. Cliquez ici.
EWIs connexes¶
SSC-FDM-TD0033 : “ACTIVITY_COUNT” TRANSFORMATION MIGHT REQUIRE MANUAL ADJUSTMENTS.
BEGIN END¶
BEGIN END TRANSACTION¶
Description¶
Définit le début d’une transaction logique explicite en mode session Teradata.
Pour plus d’informations sur la transaction BEGIN END Teradata, cliquez ici.
[ BEGIN TRANSACTION | BT ]
statement
[ statement ]... ]
[ END TRANSACTION | ET ];
Échantillon de modèle de source ¶
Teradata ¶
REPLACE PROCEDURE BeginEndProcedure()
BEGIN
DECLARE HELLOSTRING VARCHAR(60);
BEGIN TRANSACTION
SET HELLOSTRING = 'HELLO WORLD';
END TRANSACTION;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE BeginEndProcedure ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
DECLARE
HELLOSTRING VARCHAR(60);
BEGIN
BEGIN TRANSACTION;
HELLOSTRING := 'HELLO WORLD';
COMMIT;
END;
$$;
BEGIN END REQUEST¶
Description¶
Délimite une requête à plusieurs instructions SQL
Pour plus d’informations sur la requête BEGIN END Teradata, cliquez ici.
BEGIN REQUEST
statement
[ statement ]... ]
END REQUEST;
Échantillon de modèle de source ¶
Teradata ¶
REPLACE PROCEDURE BeginEndProcedure()
BEGIN
DECLARE HELLOSTRING VARCHAR(60);
BEGIN REQUEST
SET HELLOSTRING = 'HELLO WORLD';
END REQUEST;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE BeginEndProcedure ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
DECLARE
HELLOSTRING VARCHAR(60);
BEGIN
BEGIN
HELLOSTRING := 'HELLO WORLD';
COMMIT;
EXCEPTION
WHEN OTHER THEN
ROLLBACK;
END;
END;
$$;
BEGIN END COMPOUND¶
Description¶
Délimite une instruction composée dans une procédure stockée.
Pour plus d’informations sur le composant BEGIN END Teradata, cliquez ici.
label_name: BEGIN
statement
[ statement ]... ]
END label_name;
Échantillon de modèle de source ¶
Teradata ¶
REPLACE PROCEDURE BeginEndProcedure()
BEGIN
DECLARE HELLOSTRING VARCHAR(60);
label_name: BEGIN
SET HELLOSTRING = 'HELLO WORLD';
END label_name;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE BeginEndProcedure ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
DECLARE
HELLOSTRING VARCHAR(60);
BEGIN
!!!RESOLVE EWI!!! /*** SSC-EWI-0058 - FUNCTIONALITY FOR 'label_name LABEL' IS NOT CURRENTLY SUPPORTED BY SNOWFLAKE SCRIPTING ***/!!!
label_name:
BEGIN
HELLOSTRING := 'HELLO WORLD';
END;
END;
$$;
Problèmes connus¶
1. Labels not supported in outer BEGIN END blocks¶
Teradata ¶
REPLACE PROCEDURE procedureLabelSingle()
label_name: BEGIN
DECLARE HELLOSTRING VARCHAR(60);
SET HELLOSTRING = 'HELLO WORLD';
END label_name;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE procedureLabelSingle ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
!!!RESOLVE EWI!!! /*** SSC-EWI-0058 - FUNCTIONALITY FOR 'label_name LABEL' IS NOT CURRENTLY SUPPORTED BY SNOWFLAKE SCRIPTING ***/!!!
label_name:
DECLARE
HELLOSTRING VARCHAR(60);
BEGIN
HELLOSTRING := 'HELLO WORLD';
END;
$$;
EWIs connexes¶
SSC-EWI-0058 : La fonctionnalité n’est pas prise en charge actuellement par Snowflake Scripting.
CASE¶
Description ¶
Fournit une exécution conditionnelle des instructions en fonction de l’évaluation de l’expression conditionnelle spécifiée ou de l’égalité de deux opérandes.
L’instruction CASE est différente de l’expression SQL CASE, __ qui renvoie le résultat d’une expression.
Pour plus d’informations sur Teradata CASE, cliquez ici.
-- Simple CASE
CASE operant_1
[ WHEN operant_2 THEN
statement
[ statement ]... ]...
[ ELSE
statement
[ statement ]... ]
END CASE;
-- Searched CASE
CASE
[ WHEN conditional_expression THEN
statement
[ statement ]... ]...
[ ELSE
statement
[ statement ]... ]
END CASE;
Échantillons de modèles de sources ¶
Échantillon de table auxiliaire¶
CREATE TABLE case_table(col varchar(30));
CREATE OR REPLACE TABLE case_table (
col varchar(30))
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
Cas simple¶
Teradata¶
CREATE PROCEDURE caseExample1 ( grade NUMBER )
BEGIN
CASE grade
WHEN 10 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Excellent');
WHEN 9 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Very Good');
WHEN 8 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Good');
WHEN 7 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Fair');
WHEN 6 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Poor');
ELSE INSERT INTO CASE_TABLE(COL) VALUES ('No such grade');
END CASE;
END;
CALL caseExample1(6);
CALL caseExample1(4);
CALL caseExample1(10);
SELECT * FROM CASE_TABLE;
|COL |
|-------------|
|Poor |
|No such grade|
|Excellent |
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE caseExample1 (GRADE NUMBER(38, 18))
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
CASE (grade)
WHEN 10 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Excellent');
WHEN 9 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Very Good');
WHEN 8 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Good');
WHEN 7 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Fair');
WHEN 6 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Poor');
ELSE
INSERT INTO CASE_TABLE (COL)
VALUES ('No such grade');
END CASE;
END;
$$;
CALL caseExample1(6);
CALL caseExample1(4);
CALL caseExample1(10);
SELECT * FROM CASE_TABLE;
|COL |
|-------------|
|Poor |
|No such grade|
|Excellent |
Cas recherché¶
Teradata¶
CREATE PROCEDURE caseExample2 ( grade NUMBER )
BEGIN
CASE
WHEN grade = 10 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Excellent');
WHEN grade = 9 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Very Good');
WHEN grade = 8 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Good');
WHEN grade = 7 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Fair');
WHEN grade = 6 THEN INSERT INTO CASE_TABLE(COL) VALUES ('Poor');
ELSE INSERT INTO CASE_TABLE(COL) VALUES ('No such grade');
END CASE;
END;
CALL caseExample2(6);
CALL caseExample2(4);
CALL caseExample2(10);
SELECT * FROM CASE_TABLE;
|COL |
|-------------|
|Poor |
|No such grade|
|Excellent |
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE caseExample2 (GRADE NUMBER(38, 18))
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
CASE
WHEN grade = 10 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Excellent');
WHEN grade = 9 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Very Good');
WHEN grade = 8 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Good');
WHEN grade = 7 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Fair');
WHEN grade = 6 THEN
INSERT INTO CASE_TABLE (COL)
VALUES ('Poor');
ELSE
INSERT INTO CASE_TABLE (COL)
VALUES ('No such grade');
END CASE;
END;
$$;
CALL caseExample2(6);
CALL caseExample2(4);
CALL caseExample2(10);
SELECT * FROM CASE_TABLE;
|COL |
|-------------|
|Poor |
|No such grade|
|Excellent |
Problèmes connus¶
Aucun problème n’a été constaté.
EWIs connexes¶
Pas d’EWIs connexes.
CREATE MACRO¶
Description ¶
Teradata CREATE MACRO
définit une ou plusieurs instructions qui sont couramment utilisées ou qui effectuent une opération complexe, ce qui permet d’éviter d’écrire plusieurs fois la même séquence d’instructions. La macro est exécutée lorsqu’elle est appelée par l’instruction EXECUTE.
Pour plus d’informations sur CREATE MACRO
, cliquez ici.
CREATE MACRO <macroname> [(parameter1, parameter2,...)] (
<sql_statements>
);
[ EXECUTE | EXEC ] <macroname>;
Échantillons de modèles de sources ¶
Données de configuration¶
Le code suivant est nécessaire à l’exécution des modèles d’échantillons présentés dans cette section.
CREATE TABLE DEPOSIT
(
ACCOUNTNO NUMBER,
ACCOUNTNAME VARCHAR(100)
);
INSERT INTO DEPOSIT VALUES (1, 'Account 1');
INSERT INTO DEPOSIT VALUES (2, 'Account 2');
INSERT INTO DEPOSIT VALUES (3, 'Account 3');
INSERT INTO DEPOSIT VALUES (4, 'Account 4');
CREATE OR REPLACE TABLE DEPOSIT
(
ACCOUNTNO NUMBER(38, 18),
ACCOUNTNAME VARCHAR(100)
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
INSERT INTO DEPOSIT
VALUES (1, 'Account 1');
INSERT INTO DEPOSIT
VALUES (2, 'Account 2');
INSERT INTO DEPOSIT
VALUES (3, 'Account 3');
INSERT INTO DEPOSIT
VALUES (4, 'Account 4');
Macro de base ¶
Comme il n’y a pas d’objet macro dans Snowflake, l’outil de conversion transforme les macros Teradata en procédures stockées Snowflake Scripting. En outre, pour répliquer la fonctionnalité du jeu de résultats renvoyé, dans Snowflake Scripting, la requête censée renvoyer un ensemble de données à partir d’une macro est affectée à une variable RESULTSET
qui sera ensuite renvoyée.
Teradata ¶
REPLACE MACRO DEPOSITID (ID INT)
AS
(
SELECT * FROM DEPOSIT WHERE ACCOUNTNO=:ID;
);
EXECUTE DEPOSITID(2);
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 2 | Account 2 |
+--------------+--------------+
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE DEPOSITID (ID FLOAT)
RETURNS TABLE ()
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
LET res RESULTSET := (SELECT * FROM DEPOSIT WHERE ACCOUNTNO=:ID);
RETURN TABLE(res);
END;
$$;
CALL DEPOSITID(2);
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 2 | Account 2 |
+--------------+--------------+
Une macro appelle une autre macro ¶
SnowConvert prend en charge le scénario dans lequel une macro appelle une autre macro et, par transitivité, un jeu de résultats est renvoyé en obtenant les paramètres de Snowflake RESULT_SCAN(LAST_QUERY_ID())
.
Teradata¶
REPLACE MACRO MacroCallOtherMacro (ID INT)
AS
(
EXECUTE DEPOSITID(:ID);
);
EXECUTE MacroCallOtherMacro(2);
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 2 | Account 2 |
+--------------+--------------+
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE MacroCallOtherMacro (ID FLOAT)
RETURNS TABLE (
)
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "09/09/2024" }}'
EXECUTE AS CALLER
AS
$$
BEGIN
CALL DEPOSITID(:ID);
LET res RESULTSET :=
(
SELECT
*
FROM
TABLE(RESULT_SCAN(LAST_QUERY_ID()))
);
RETURN TABLE(res);
END;
$$;
CALL MacroCallOtherMacro(2);
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 2 | Account 2 |
+--------------+--------------+
Macro sans jeu de résultats¶
Toutes les macros ne sont pas destinées à renvoyer un jeu de résultats. Le scénario mentionné est également pris en charge.
Teradata¶
REPLACE MACRO MacroWithoutSelect (ACCOUNTNO NUMBER, ACCOUNTNAME VARCHAR(100))
AS
(
INSERT INTO DEPOSIT VALUES (:ACCOUNTNO, :ACCOUNTNAME);
);
EXECUTE MacroWithoutSelect(5, 'Account 5');
SELECT * FROM DEPOSIT;
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 1 | Account 1 |
+--------------+--------------+
| 2 | Account 2 |
+--------------+--------------+
| 3 | Account 3 |
+--------------+--------------+
| 4 | Account 4 |
+--------------+--------------+
| 5 | Account 5 |
+--------------+--------------+
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE MacroWithoutSelect (ACCOUNTNO FLOAT, ACCOUNTNAME VARCHAR(100))
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
INSERT INTO DEPOSIT
VALUES (:ACCOUNTNO, :ACCOUNTNAME);
END;
$$;
CALL MacroWithoutSelect(5, 'Account 5');
SELECT * FROM DEPOSIT;
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 1 | Account 1 |
+--------------+--------------+
| 2 | Account 2 |
+--------------+--------------+
| 3 | Account 3 |
+--------------+--------------+
| 4 | Account 4 |
+--------------+--------------+
| 5 | Account 5 |
+--------------+--------------+
La macro renvoie plusieurs jeux de résultats¶
Dans Teradata, les macros peuvent renvoyer plus d’un jeu de résultats à partir d’une seule macro.
Les procédures de Snowflake Scripting ne permettent de renvoyer qu’un seul jeu de résultats par procédure. Pour répliquer le comportement de Teradata, lorsqu’il y a deux ou plusieurs jeux de résultats à renvoyer, ils sont stockés dans des tables temporaires. La procédure Snowflake Scripting renvoie un tableau contenant le nom des tables temporaires.
Teradata¶
REPLACE MACRO DEPOSITID (ID INT)
AS
(
SELECT * FROM DEPOSIT WHERE ACCOUNTNO=4;
SELECT * FROM DEPOSIT WHERE ACCOUNTNO=:ID;
EXECUTE DEPOSITID(:ID);
);
EXECUTE DEPOSITID(2);
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 4 | Account 4 |
+--------------+--------------+
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 2 | Account 2 |
+--------------+--------------+
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE DEPOSITID (ID FLOAT)
RETURNS ARRAY
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "09/09/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
return_arr ARRAY := array_construct();
tbl_nm VARCHAR;
BEGIN
tbl_nm := 'RESULTSET_' || REPLACE(UPPER(UUID_STRING()), '-', '_');
CREATE OR REPLACE TEMPORARY TABLE IDENTIFIER(:tbl_nm) AS
SELECT
* FROM
DEPOSIT
WHERE ACCOUNTNO=4;
return_arr := array_append(return_arr, :tbl_nm);
tbl_nm := 'RESULTSET_' || REPLACE(UPPER(UUID_STRING()), '-', '_');
CREATE OR REPLACE TEMPORARY TABLE IDENTIFIER(:tbl_nm) AS
SELECT
* FROM
DEPOSIT
WHERE ACCOUNTNO=:ID;
return_arr := array_append(return_arr, :tbl_nm);
CALL DEPOSITID(:ID);
tbl_nm := 'RESULTSET_' || REPLACE(UPPER(UUID_STRING()), '-', '_');
CREATE OR REPLACE TEMPORARY TABLE IDENTIFIER(:tbl_nm) AS
SELECT
*
FROM
TABLE(RESULT_SCAN(LAST_QUERY_ID()));
return_arr := array_append(return_arr, :tbl_nm);
--** SSC-FDM-0020 - MULTIPLE RESULT SETS ARE RETURNED IN TEMPORARY TABLES **
RETURN return_arr;
END;
$$;
CALL DEPOSITID(2);
+-----------------------------------------------------+
| DEPOSIDID |
|-----------------------------------------------------|
| [ |
| "RESULTSET_93D50CBB_F22C_418A_A88C_4E1DE101B500", |
| "RESULTSET_6BDE39D7_0554_406E_B52F_D9E863A3F15C" |
| ] |
+-----------------------------------------------------+
Visualiser les jeux de résultats¶
L’exécution de la procédure ci-dessus sur Snowflake renvoie un tableau contenant les noms des tables temporaires :
[ « RESULTSET_93D50CBB_F22C_418A_A88C_4E1DE101B500 », « RESULTSET_6BDE39D7_0554_406E_B52F_D9E863A3F15C »]
Il est nécessaire d’exécuter les requêtes suivantes pour afficher les jeux de résultats comme dans Teradata.
SELECT * FROM table('RESULTSET_93D50CBB_F22C_418A_A88C_4E1DE101B500');
SELECT * FROM table('RESULTSET_6BDE39D7_0554_406E_B52F_D9E863A3F15C');
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 4 | Account 4 |
+--------------+--------------+
+--------------+--------------+
| ACCOUNTNO | ACCOUNTNAME |
|--------------+--------------|
| 2 | Account 2 |
+--------------+--------------+
Problèmes connus ¶
Aucun problème n’a été constaté.
EWIs connexes¶
SSC-FDM-0020 : Plusieurs jeux de résultats sont renvoyés dans des tables temporaires.
CREATE PROCEDURE¶
Description
L’instruction Teradata CREATE PROCEDURE
et REPLACE PROCEDURE
génère ou remplace une implémentation de procédure stockée et la compile.
Pour plus d’informations sur CREATE PROCEDURE
ou REPLACE PROCEDURE
cliquez ici.
-- Create/replace procedure syntax
{CREATE | REPLACE} PROCEDURE [database_name. | user_name.] procedure_name
([<parameter_definition>[, ...n]])
[<SQL_data_access>]
[DYNAMIC RESULT SETS number_of_sets]
[SQL SECURITY <privilege_option>]
statement;
<parameter_definition> := [IN | OUT | INOUT] parameter_name data_type
<SQL_data_access> := {CONTAINS SQL | MODIFIES SQL DATA | READS SQL DATA}
<privilege_option> := {CREATOR | DEFINER | INVOKER | OWNER}
Échantillons de modèles de sources ¶
Données de configuration¶
Le code suivant est nécessaire à l’exécution des modèles d’échantillons présentés dans cette section.
CREATE TABLE inventory (
product_name VARCHAR(50),
price INTEGER
);
INSERT INTO inventory VALUES ('Bread', 50);
INSERT INTO inventory VALUES ('Tuna', 150);
INSERT INTO inventory VALUES ('Gum', 20);
INSERT INTO inventory VALUES ('Milk', 80);
CREATE OR REPLACE TABLE inventory (
product_name VARCHAR(50),
price INTEGER
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
INSERT INTO inventory
VALUES ('Bread', 50);
INSERT INTO inventory
VALUES ('Tuna', 150);
INSERT INTO inventory
VALUES ('Gum', 20);
INSERT INTO inventory
VALUES ('Milk', 80);
Procédure de base ¶
Teradata ¶
REPLACE PROCEDURE BasicProcedure(IN counterValue INTEGER)
BEGIN
DECLARE productName VARCHAR(50);
DECLARE productPrice INTEGER DEFAULT 0;
DECLARE whileCounter INTEGER DEFAULT 0;
SET productName = 'Salt';
WHILE (whileCounter < counterValue) DO
SET productPrice = 10 + productPrice;
SET whileCounter = whileCounter + 1;
END WHILE;
INSERT INTO inventory VALUES (productName, productPrice);
END;
CALL BasicProcedure(5);
SELECT product_name, price FROM inventory WHERE product_name = 'Salt';
+--------------+--------------+
| product_name | price |
|--------------+--------------|
| Salt | 50 |
+--------------+--------------+
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE BasicProcedure (COUNTERVALUE INTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/23/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
productName VARCHAR(50);
productPrice INTEGER DEFAULT 0;
whileCounter INTEGER DEFAULT 0;
BEGIN
productName := 'Salt';
WHILE (whileCounter < counterValue) LOOP
productPrice := 10 + productPrice;
whileCounter := whileCounter + 1;
END LOOP;
INSERT INTO inventory
VALUES (:productName, :productPrice);
END;
$$;
CALL BasicProcedure(5);
SELECT
product_name,
price FROM
inventory
WHERE product_name = 'Salt';
+--------------+--------------+
| product_name | price |
|--------------+--------------|
| Salt | 50 |
+--------------+--------------+
Un seul paramètre ¶
Teradata¶
REPLACE PROCEDURE procedureLabelSingle(OUT Message VARCHAR(100))
BEGIN
set Message = 'Assignment value. Thanks';
END;
CALL procedureLabelSingle(?);
Message |
------------------------+
Assignment value. Thanks|
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE procedureLabelSingle (
-- OUT
MESSAGE VARCHAR(100))
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/23/2024" }}'
EXECUTE AS CALLER
AS
$$
BEGIN
Message := 'Assignment value. Thanks';
RETURN Message;
END;
$$;
CALL procedureLabelSingle(?);
+───────────────────────────────+
| PROCEDURELABELSINGLE |
+───────────────────────────────+
| ""Assignment value. Thanks"" |
+───────────────────────────────+
Paramètres multiples ¶
Teradata¶
REPLACE PROCEDURE procedureLabelMultiple(OUT Message VARCHAR(100), OUT Message2 VARCHAR(100))
BEGIN
set Message = 'Assignment value. Thanks';
set Message2 = 'Assignment value2. Thanks';
END;
CALL procedureLabelSingle(?, ?);
1 |2 |
------------------------+-------------------------+
Assignment value. Thanks|Assignment value2. Thanks|
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE procedureLabelMultiple (
-- OUT
MESSAGE VARCHAR(100),
-- OUT
MESSAGE2 VARCHAR(100))
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/23/2024" }}'
EXECUTE AS CALLER
AS
$$
BEGIN
Message := 'Assignment value. Thanks';
Message2 := 'Assignment value2. Thanks';
RETURN OBJECT_CONSTRUCT('Message', :Message, 'Message2', :Message2);
END;
$$;
CALL procedureLabelSingle(?, ?);
+─────────────────────────+────────────────────────────────+
| PROCEDURELABELMULTIPLE | |
+─────────────────────────+────────────────────────────────+
| "{ | |
| ""Message"" | ""Assignment value. Thanks"", |
| ""Message2"" | ""Assignment value2. Thanks"" |
| }" | |
+─────────────────────────+────────────────────────────────+
Note
À l’intérieur d’une procédure, l’objet retourné peut être facilement déconstruit en utilisant les instructions suivantes juste après l’appel de la procédure:\ \ LET call_results VARIANT: = (SELECT * FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()))) ;
var1 := GET(:call_results, 'Message');
var2 := GET(:call_results, 'Message2');
\
Paramètres de sortie multiples avec jeux de résultats dynamiques ¶
Teradata¶
REPLACE PROCEDURE Procedure1(out product_name VARCHAR(50), out price integer)
DYNAMIC RESULT SETS 2
BEGIN
DECLARE result_set CURSOR WITH RETURN ONLY FOR
SELECT * FROM inventory;
DECLARE result_set2 CURSOR WITH RETURN ONLY FOR
SELECT * FROM inventory;
SET price = 100;
SET product_name = 'another2';
OPEN result_set2;
OPEN result_set;
END;
REPLACE PROCEDURE Procedure2()
BEGIN
DECLARE price INTEGER;
DECLARE productName varchar(10);
CALL Procedure1(productName, price);
INSERT INTO inventory VALUES(:productName, :price);
END;
CALL Procedure2();
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE Procedure1 (out !!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'OUTPUT PARAMETERS ALONG WITH DYNAMIC RESULT SET' NODE ***/!!! PRODUCT_NAME VARCHAR(50), out !!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'OUTPUT PARAMETERS ALONG WITH DYNAMIC RESULT SET' NODE ***/!!! PRICE integer)
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/23/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
tbl_result_set VARCHAR;
tbl_result_set2 VARCHAR;
return_arr ARRAY := array_construct();
BEGIN
tbl_result_set := 'RESULTSET_' || REPLACE(UPPER(UUID_STRING()), '-', '_');
CREATE OR REPLACE TEMPORARY TABLE IDENTIFIER(:tbl_result_set) AS
SELECT
* FROM
inventory;
LET result_set CURSOR
FOR
SELECT
*
FROM
IDENTIFIER(?);
tbl_result_set2 := 'RESULTSET_' || REPLACE(UPPER(UUID_STRING()), '-', '_');
CREATE OR REPLACE TEMPORARY TABLE IDENTIFIER(:tbl_result_set2) AS
SELECT
* FROM
inventory;
LET result_set2 CURSOR
FOR
SELECT
*
FROM
IDENTIFIER(?);
price := 100;
product_name := 'another2';
OPEN result_set2 USING (tbl_result_set2);
return_arr := array_append(return_arr, :tbl_result_set2);
OPEN result_set USING (tbl_result_set);
return_arr := array_append(return_arr, :tbl_result_set);
--** SSC-FDM-0020 - MULTIPLE RESULT SETS ARE RETURNED IN TEMPORARY TABLES **
RETURN OBJECT_CONSTRUCT('SC_RET_VALUE', :return_arr, 'product_name', :product_name, 'price', :price);
END;
$$;
CREATE OR REPLACE PROCEDURE Procedure2 ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/23/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
price INTEGER;
productName varchar(10);
call_results VARIANT;
BEGIN
call_results := (
CALL Procedure1(:productName, :price)
);
productName := :call_results:product_name;
price := :call_results:price;
INSERT INTO inventory
VALUES (:productName, :price);
END;
$$;
CALL Procedure2();
(1).png)
Problèmes connus ¶
1. Paramètres de sortie
Snowflake Scripting ne prend pas en charge les paramètres OUT/INOUT. Ces paramètres sont donc renvoyés à la fin du corps de la procédure.
2. Accès aux données SQL
Par défaut, les procédures Snowflake prennent en charge l’exécution de tout type d’instruction SQL, y compris les instructions de lecture ou de modification de données, ce qui rend la clause d’accès aux données SQL non pertinente. Cette clause sera ignorée lors de la conversion de la procédure.
3. Objets de premier niveau dans le rapport d’évaluation
Les éléments (tables temporelles ou vues) contenus dans les procédures stockées sont comptabilisés dans le rapport d’évaluation comme des objets de premier niveau. L’équipe de SnowConvert travaille actuellement à une correction pour ce scénario.
EWIs connexes¶
SSC-EWI-0073 : En attente de l’examen de l’équivalence fonctionnelle.
SSC-FDM-0020 : Plusieurs jeux de résultats sont renvoyés dans des tables temporaires.
CURSOR¶
Description ¶
Un curseur est une structure de données utilisée par les procédures stockées lors de l’exécution pour pointer vers un jeu de résultats renvoyé par une requête SQL. Pour plus d’informations, cliquez ici.
DECLARE cursor_name [ SCROLL | NO SCROLL ] CURSOR
[
WITHOUT RETURN
|
WITH RETURN [ ONLY ] [ TO [ CALLER | CLIENT ] ]
]
FOR
cursor_specification [ FOR [ READ ONLY | UPDATE ] ]
|
statement_name
;
FETCH [ [ NEXT | FIRST ] FROM ] cursor_name INTO
[ variable_name | parameter_name ] [ ,...n ]
;
OPEN cursor_name
[ USING [ SQL_identifier | SQL_paramenter ] [ ,...n ] ]
;
CLOSE cursor_name ;
Échantillons de modèles de sources ¶
Données de configuration¶
Le code suivant est nécessaire à l’exécution des modèles d’échantillons présentés dans cette section.
CREATE TABLE vEmployee(
PersonID INT,
LastName VARCHAR(255),
FirstName VARCHAR(255)
);
CREATE TABLE ResTable(
Column1 VARCHAR(255)
);
INSERT INTO vEmployee(PersonID, LastName, FirstName) VALUES (1, 'Smith', 'Christian');
INSERT INTO vEmployee(PersonID, LastName, FirstName) VALUES (2, 'Johnson', 'Jhon');
INSERT INTO vEmployee(PersonID, LastName, FirstName) VALUES (3, 'Brown', 'William');
INSERT INTO vEmployee(PersonID, LastName, FirstName) VALUES (4, 'Williams', 'Gracey');
INSERT INTO vEmployee(PersonID, LastName, FirstName) VALUES (5, 'Garcia', 'Julia');
INSERT INTO vEmployee(PersonID, LastName, FirstName) VALUES (6, 'Miller', 'Peter');
INSERT INTO vEmployee(PersonID, LastName, FirstName) VALUES (7, 'Davis', 'Jannys');
CREATE TABLE TEST_TABLE (
ColumnA NUMBER,
ColumnB VARCHAR(8),
ColumnC VARCHAR(8));
SELECT * FROM TEST_TABLE;
INSERT INTO TEST_TABLE VALUES (1, '1', '1');
INSERT INTO TEST_TABLE VALUES (2, '2', '2');
CREATE OR REPLACE TABLE vEmployee (
PersonID INT,
LastName VARCHAR(255),
FirstName VARCHAR(255)
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
;
CREATE OR REPLACE TABLE ResTable (
Column1 VARCHAR(255)
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
;
INSERT INTO vEmployee (PersonID, LastName, FirstName)
VALUES (1, 'Smith', 'Christian');
INSERT INTO vEmployee (PersonID, LastName, FirstName)
VALUES (2, 'Johnson', 'Jhon');
INSERT INTO vEmployee (PersonID, LastName, FirstName)
VALUES (3, 'Brown', 'William');
INSERT INTO vEmployee (PersonID, LastName, FirstName)
VALUES (4, 'Williams', 'Gracey');
INSERT INTO vEmployee (PersonID, LastName, FirstName)
VALUES (5, 'Garcia', 'Julia');
INSERT INTO vEmployee (PersonID, LastName, FirstName)
VALUES (6, 'Miller', 'Peter');
INSERT INTO vEmployee (PersonID, LastName, FirstName)
VALUES (7, 'Davis', 'Jannys');
CREATE OR REPLACE TABLE TEST_TABLE (
ColumnA NUMBER(38, 18),
ColumnB VARCHAR(8),
ColumnC VARCHAR(8))
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
;
SELECT
* FROM
TEST_TABLE;
INSERT INTO TEST_TABLE
VALUES (1, '1', '1');
INSERT INTO TEST_TABLE
VALUES (2, '2', '2');
Curseur de base¶
Teradata¶
REPLACE PROCEDURE CursorsTest()
BEGIN
DECLARE val1 VARCHAR(255);
DECLARE empcursor CURSOR FOR
SELECT LastName
FROM vEmployee
ORDER BY PersonID;
OPEN empcursor;
FETCH NEXT FROM empcursor INTO val1;
FETCH NEXT FROM empcursor INTO val1;
INSERT INTO ResTable(Column1) VALUES (val1);
CLOSE empcursor;
END;
CALL CursorsTest();
SELECT * FROM ResTable;
Johnson
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE CursorsTest ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "06/18/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
val1 VARCHAR(255);
BEGIN
LET empcursor CURSOR
FOR
SELECT
LastName
FROM
vEmployee
ORDER BY PersonID;
OPEN empcursor;
FETCH NEXT FROM empcursor INTO val1;
FETCH NEXT FROM empcursor INTO val1;
INSERT INTO ResTable (Column1)
VALUES (:val1);
CLOSE empcursor;
END;
$$;
CALL CursorsTest();
SELECT
* FROM
ResTable;
Johnson
Curseur à retour unique¶
La procédure suivante est destinée à renvoyer un jeu de résultats puisqu’elle a la propriété DYNAMIC RESULT SETS 1
dans l’en-tête, que le curseur a la propriété WITH RETURN
et qu’elle est ouverte dans le corps.
Teradata¶
REPLACE PROCEDURE spSimple ()
DYNAMIC RESULT SETS 1
BEGIN
DECLARE result_set CURSOR WITH RETURN ONLY FOR
SELECT *
FROM vEmployee;
OPEN result_set;
END;
CALL spSimple();
PersonID|LastName|FirstName|
--------+--------+---------+
7|Davis |Jannys |
5|Garcia |Julia |
3|Brown |William |
1|Smith |Christian|
6|Miller |Peter |
4|Williams|Gracey |
2|Johnson |Jhon |
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE spSimple ()
RETURNS TABLE (
)
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
LET result_set CURSOR FOR
SELECT * FROM vEmployee;
OPEN result_set;
RETURN TABLE(resultset_from_cursor(result_set));
END;
$$;
CALL spSimple();
PERSONID|LASTNAME|FIRSTNAME|
--------+--------+---------+
1|Smith |Christian|
2|Johnson |Jhon |
3|Brown |William |
4|Williams|Gracey |
5|Garcia |Julia |
6|Miller |Peter |
7|Davis |Jannys |
Curseurs à retour multiple¶
La procédure suivante est destinée à renvoyer des résultats multiples lorsque la propriété DYNAMIC RESULT SETS
de l’en-tête est supérieure à 1, que la procédure possède plusieurs curseurs avec la propriété WITH RETURN
et que ces mêmes curseurs sont ouverts dans le corps.
Teradata¶
REPLACE PROCEDURE spTwoOrMore()
DYNAMIC RESULT SETS 2
BEGIN
DECLARE result_set CURSOR WITH RETURN ONLY FOR
SELECT * FROM SampleTable2;
DECLARE result_set2 CURSOR WITH RETURN ONLY FOR
SELECT Column11 FROM SampleTable1;
OPEN result_set2;
OPEN result_set;
END;
CALL spTwoOrMore();
ColumnA|ColumnB|ColumnC|
-------+-------+-------+
2|2 |2 |
1|1 |1 |
PersonID|LastName|FirstName|
--------+--------+---------+
7|Davis |Jannys |
5|Garcia |Julia |
3|Brown |William |
1|Smith |Christian|
6|Miller |Peter |
4|Williams|Gracey |
2|Johnson |Jhon |
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE spTwoOrMore ()
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
DECLARE
tbl_result_set VARCHAR;
tbl_result_set2 VARCHAR;
return_arr ARRAY := array_construct();
BEGIN
tbl_result_set := 'RESULTSET_' || REPLACE(UPPER(UUID_STRING()), '-', '_');
CREATE OR REPLACE TEMPORARY TABLE IDENTIFIER(:tbl_result_set) AS
SELECT
* FROM
SampleTable2;
LET result_set CURSOR
FOR
SELECT
*
FROM
IDENTIFIER(?);
tbl_result_set2 := 'RESULTSET_' || REPLACE(UPPER(UUID_STRING()), '-', '_');
CREATE OR REPLACE TEMPORARY TABLE IDENTIFIER(:tbl_result_set2) AS
SELECT
Column11 FROM
SampleTable1;
LET result_set2 CURSOR
FOR
SELECT
*
FROM
IDENTIFIER(?);
OPEN result_set2 USING (tbl_result_set2);
return_arr := array_append(return_arr, :tbl_result_set2);
OPEN result_set USING (tbl_result_set);
return_arr := array_append(return_arr, :tbl_result_set);
--** SSC-FDM-0020 - MULTIPLE RESULT SETS ARE RETURNED IN TEMPORARY TABLES **
RETURN OBJECT_CONSTRUCT('SC_RET_VALUE', :return_arr);
END;
$$;
CALL spTwoOrMore();
[
"RESULTSET_B5B0005D_1602_48B7_9EE4_62E1A28B000C",
"RESULTSET_1371794D_7B77_4DA9_B42E_7981F35CEA9C"
]
ColumnA|ColumnB|ColumnC|
-------+-------+-------+
2|2 |2 |
1|1 |1 |
PersonID|LastName|FirstName|
--------+--------+---------+
7|Davis |Jannys |
5|Garcia |Julia |
3|Brown |William |
1|Smith |Christian|
6|Miller |Peter |
4|Williams|Gracey |
2|Johnson |Jhon |
Curseurs avec variables de liaison¶
Le curseur suivant utilise des variables de liaison comme condition d’exécution de la requête.
Teradata¶
REPLACE PROCEDURE TestProcedure (IN param1 NUMBER, param2 VARCHAR(8), param3 VARCHAR(8))
DYNAMIC RESULT SETS 1
BEGIN
DECLARE cursorExample CURSOR WITH RETURN ONLY FOR
SELECT * FROM TEST_TABLE
WHERE ColumnA = param1 AND ColumnB LIKE param2 and ColumnC LIKE param3;
OPEN cursorExample;
END;
CALL TestProcedure(2, '2', '2');
|ColumnA|ColumnB|ColumnC|
+-------+-------+-------+
| 2|2 |2 |
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE TestProcedure (PARAM1 NUMBER(38, 18), PARAM2 VARCHAR(8), PARAM3 VARCHAR(8))
RETURNS TABLE (
)
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
BEGIN
LET cursorExample CURSOR
FOR
SELECT
* FROM
TEST_TABLE
WHERE ColumnA = param1 AND ColumnB LIKE param2 and ColumnC LIKE param3;
OPEN cursorExample;
RETURN TABLE(resultset_from_cursor(cursorExample));
END;
$$;
CALL TestProcedure(2, '2', '2');
|ColumnA|ColumnB|ColumnC|
+-------+-------+-------+
| 2|2 |2 |
Curseur pour boucle¶
Il s’agit d’un type de boucle qui utilise un curseur pour récupérer les lignes d’une instruction SELECT et qui effectue ensuite un traitement sur chaque ligne.
Teradata¶
REPLACE PROCEDURE TestProcedure ()
DYNAMIC RESULT SETS 1
BEGIN
FOR fUsgClass AS cUsgClass CURSOR FOR
SELECT columnA FROM TEST_TABLE
DO
INSERT INTO ResTable(Column1) VALUES (fUsgClass.columnA);
END FOR;
END;
CALL TestProcedure();
SELECT * FROM ResTable;
|Column1|
+-------+
| 1|
| 2|
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE TestProcedure ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
LET cUsgClass CURSOR FOR
SELECT columnA FROM TEST_TABLE;
--** SSC-PRF-0004 - THIS STATEMENT HAS USAGES OF CURSOR FOR LOOP **
FOR fUsgClass IN cUsgClass DO
INSERT INTO ResTable (Column1) VALUES (:temp_fUsgClass_columnA);
END FOR;
END;
$$;
CALL TestProcedure();
SELECT * FROM ResTable;
|Column1|
+-------+
| 1|
| 2|
Récupération de curseur à l’intérieur d’une boucle¶
Permet de récupérer une à une les lignes d’un jeu de résultats et d’effectuer un traitement sur chaque ligne.
Teradata¶
REPLACE PROCEDURE teradata_fetch_inside_loop()
DYNAMIC RESULT SETS 1
BEGIN
DECLARE col_name VARCHAR(255);
DECLARE col_int INTEGER DEFAULT 1;
DECLARE cursor_var CURSOR FOR SELECT columnA FROM TEST_TABLE;
WHILE (col_int <> 0) DO
FETCH cursor_var INTO col_name;
INSERT INTO ResTable(Column1) VALUES (cursor_var.columnA);
SET col_int = 0;
END WHILE;
END;
CALL teradata_fetch_inside_loop();
SELECT * FROM ResTable;
|Column1|
+-------+
| 2|
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE teradata_fetch_inside_loop ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "06/18/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
col_name VARCHAR(255);
col_int INTEGER DEFAULT 1;
BEGIN
LET cursor_var CURSOR
FOR
SELECT
columnA FROM
TEST_TABLE;
WHILE (col_int <> 0) LOOP
--** SSC-PRF-0003 - FETCH INSIDE A LOOP IS CONSIDERED A COMPLEX PATTERN, THIS COULD DEGRADE SNOWFLAKE PERFORMANCE. **
FETCH cursor_var INTO col_name;
INSERT INTO ResTable (Column1)
VALUES (cursor_var.columnA);
col_int := 0;
END LOOP;
END;
$$;
CALL teradata_fetch_inside_loop();
SELECT
* FROM
ResTable;
|Column1|
+-------+
| 2|
Problèmes connus¶
Les paramètres suivants ne sont pas applicables dans Snowflake Scripting.
1. Declare¶
[ SCROLL/NO SCROLL ] Snowflake Scripting prend uniquement en charge FETCH NEXT.
[ READ-ONLY ] C’est la valeur par défaut dans Snowflake Scripting.
[ UPDATE ].
2. Fetch¶
[ NEXT ] Il s’agit du comportement par défaut dans Snowflake Scripting.
[ FIRST ].
EWIs connexes¶
SSC-FDM-0020 : Plusieurs jeux de résultats sont renvoyés dans des tables temporaires.
SSC-PRF-0003 : Fetch à l’intérieur d’une boucle est considéré comme un modèle complexe, ce qui pourrait dégrader les performances de Snowflake.
SSC-PRF-0004 : Cette instruction utilise le curseur for loop.
DECLARE CONTINUE HANDLER¶
Description ¶
Traiter les conditions d’achèvement et les conditions d’exception qui ne sont pas suffisamment graves pour affecter le flux de contrôle.
Pour plus d’informations sur le gestionnaire Teradata DECLARE CONTINUE, cliquez ici.
DECLARE CONTINUE HANDLER FOR
{
{ sqlstate_state_spec | condition_name } [,...] |
{ SQLEXCEPTION | SQLWARNING | NOT FOUND } [,...]
} handler_action_statement ;
Échantillons de modèles de sources ¶
DECLARE CONTINUE HANDLER¶
Teradata ¶
REPLACE PROCEDURE PURGING_ADD_TABLE
(
IN inDatabaseName VARCHAR(30),
IN inTableName VARCHAR(30)
)
BEGIN
DECLARE vCHAR_SQLSTATE CHAR(5);
DECLARE vSUCCESS CHAR(5);
DECLARE CONTINUE HANDLER FOR SQLSTATE 'T5628'
BEGIN
SET vCHAR_SQLSTATE = SQLCODE;
SET vSUCCESS = SQLCODE;
END;
SELECT 1;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE PURGING_ADD_TABLE
(INDATABASENAME VARCHAR(30), INTABLENAME VARCHAR(30)
)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "06/18/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
vCHAR_SQLSTATE CHAR(5);
vSUCCESS CHAR(5);
BEGIN
BEGIN
SELECT
1;
EXCEPTION
WHEN statement_error THEN
LET errcode := :sqlcode
LET sqlerrmsg := :sqlerrm
IF (errcode = '904'
AND contains(sqlerrmsg, 'invalid value')) THEN
BEGIN
vCHAR_SQLSTATE := SQLCODE;
vSUCCESS := SQLCODE;
END;
ELSE
RAISE
END IF
END
END;
$$;
Problèmes connus¶
DECLARE CONTINUE HANDLER FOR SQLSTATE¶
La déclaration des gestionnaires de continuation pour certaines valeurs de SQLSTATE n’est pas actuellement prise en charge par Snowflake Scripting.
Teradata ¶
CREATE PROCEDURE declareConditionExample2 ( )
BEGIN
DECLARE CONTINUE HANDLER FOR SQLSTATE 'UNSUPPORTED'
BEGIN
SET vCHAR_SQLSTATE = SQLCODE;
SET vSUCCESS = SQLCODE;
END;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE declareConditionExample2 ( )
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
!!!RESOLVE EWI!!! /*** SSC-EWI-TD0004 - NOT SUPPORTED SQL EXCEPTION ON CONTINUE HANDLER ***/!!!
DECLARE CONTINUE HANDLER FOR SQLSTATE 'UNSUPPORTED'
BEGIN
vCHAR_SQLSTATE := SQLCODE;
vSUCCESS := SQLCODE;
END;
END;
$$;
connexesEWIS¶
SSC-EWI-TD0004 : Exception SQL non prise en charge sur le gestionnaire de continuation.
DECLARE CONDITION HANDLER¶
Description ¶
Attribuez un nom à un code SQLSTATE ou déclarez une condition définie par l’utilisateur.
Pour plus d’informations sur le gestionnaire Teradata DECLARE CONDITION, cliquez ici.
DECLARE condition_name CONDITION
[ FOR SQLSTATE [ VALUE ] sqlstate_code ] ;
Échantillons de modèles de sources ¶
DECLARE CONDITION¶
Teradata ¶
CREATE PROCEDURE declareConditionExample ( )
BEGIN
DECLARE DB_ERROR CONDITION;
...
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE declareConditionExample ( )
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
DECLARE
DB_ERROR EXCEPTION;
BEGIN
END;
$$;
Problèmes connus¶
DECLARE CONDITION FOR SQLSTATE¶
La déclaration de conditions pour les valeurs SQLSTATE n’est pas actuellement prise en charge par Snowflake Scripting.
Teradata ¶
CREATE PROCEDURE declareConditionExample2 ( )
BEGIN
DECLARE ERROR_EXISTS CONDITION FOR SQLSTATE VALUE '42000';
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE declareConditionExample2 ( )
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
DECLARE
ERROR_EXISTS EXCEPTION;
BEGIN
-- !!!RESOLVE EWI!!! /*** SSC-EWI-0058 - FUNCTIONALITY FOR 'SET EXCEPTION DETAILS' IS NOT CURRENTLY SUPPORTED BY SNOWFLAKE SCRIPTING ***/!!!
-- ERROR_EXISTS CONDITION FOR SQLSTATE VALUE '42000';
END;
$$;
connexesEWIS¶
SSC-EWI-0058: La fonctionnalité n’est pas actuellement prise en charge par Snowflake Scripting.
DECLARE¶
Description ¶
Déclare une ou plusieurs variables locales.
Pour plus d’informations sur Teradata DECLARE, cliquez ici.
DECLARE variable_name [, variable_name ]... DATA_TYPE [ DEFAULT default_value]
Échantillons de modèles de sources ¶
Teradata ¶
CREATE PROCEDURE declareExample ( )
BEGIN
DECLARE COL_NAME, COL_TYPE VARCHAR(200) DEFAULT '' ;
DECLARE COL_COUNT, COL_LEN INTEGER;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE declareExample ( )
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "06/18/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
COL_NAME VARCHAR(200) DEFAULT '';
COL_TYPE VARCHAR(200) DEFAULT '';
COL_COUNT INTEGER;
COL_LEN INTEGER;
BEGIN
RETURN 1;
END;
$$;
Problèmes connus¶
Aucun problème n’a été constaté.
EWIs connexes¶
Pas d’EWIs connexes.
Objets DML et DDL¶
Description ¶
Les objets DML et DDL sont traduits de la même manière, qu’ils se trouvent ou non à l’intérieur de procédures stockées. Pour plus d’informations, consultez les liens suivants.
Références à la traduction¶
data-types.md : Comparez les types de données de Teradata et leurs équivalents dans Snowflake.
ddl : Explorez la traduction de la langue de définition des données.
dml : Explorez la traduction du langage de manipulation des données.
built-in-functions : Comparez les fonctions incluses dans l’environnement d’exécution des deux langues.
EXCEPTION HANDLERS¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description ¶
Les gestionnaires d’exceptions simples et multiples de Teradata sont remplacés par des gestionnaires équivalents dans Snowflake Scripting.
Pour plus d’informations sur Teradata EXCEPTION HANDLERS, cliquez ici.
DECLARE < handler_type > HANDLER
FOR < condition_value_list > < handler_action > ;
Échantillons de modèles de sources ¶
SQLEXCEPTION HANDLER¶
Teradata ¶
CREATE PROCEDURE handlerSample ()
BEGIN
DECLARE EXIT HANDLER FOR SQLEXCEPTION
INSERT INTO Proc_Error_Table ('procSample', 'Failed SqlException');
SELECT * FROM Proc_Error_Table;
END;
CREATE PROCEDURE handlerSample ()
BEGIN
DECLARE ConditionByUser1 CONDITION;
DECLARE EXIT HANDLER FOR SQLEXCEPTION
INSERT INTO Proc_Error_Table ('procSample', 'Failed SqlException');
DECLARE EXIT HANDLER FOR ConditionByUser1
INSERT INTO Proc_Error_Table ('procSample', 'Failed ConditionByUser1');
SELECT * FROM Proc_Error_Table;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE handlerSample ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
SELECT
* FROM
Proc_Error_Table;
EXCEPTION
WHEN other THEN
INSERT INTO Proc_Error_Table
VALUES ('procSample', 'Failed SqlException');
END;
$$;
CREATE OR REPLACE PROCEDURE handlerSample ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
DECLARE
ConditionByUser1 EXCEPTION;
BEGIN
SELECT
* FROM
Proc_Error_Table;
EXCEPTION
WHEN ConditionByUser1 THEN
INSERT INTO Proc_Error_Table
VALUES ('procSample', 'Failed ConditionByUser1');
WHEN other THEN
INSERT INTO Proc_Error_Table
VALUES ('procSample', 'Failed SqlException');
END;
$$;
Gestionnaires définis par l’utilisateur¶
Teradata ¶
CREATE PROCEDURE handlerSample ()
BEGIN
DECLARE EXIT HANDLER FOR Custom1, Custom2, Custom3
BEGIN
SET Message1 = 'custom1 and custom2 and custom3';
END;
SELECT * FROM Proc_Error_Table;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE handlerSample ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
SELECT
* FROM
Proc_Error_Table;
EXCEPTION
WHEN Custom1 OR Custom2 OR Custom3 THEN
BEGIN
Message1 := 'custom1 and custom2 and custom3';
END;
END;
$$;
Problèmes connus¶
Gestionnaire CONTINUE¶
Un gestionnaire d’erreur “CONTINUE” dans Teradata permet de reprendre l’exécution après l’exécution d’une instruction comportant des erreurs. Ce cas n’est pas pris en charge par les blocs d’exception dans Snowflake Scripting. Documentation de référence Gestionnaire de conditions Teradata.
Teradata
CREATE PROCEDURE handlerSample ()
BEGIN
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
INSERT INTO Proc_Error_Table ('spSample4', 'Failed SqlException');
SELECT * FROM Proc_Error_Table;
END;
Snowflake Scripting
CREATE OR REPLACE PROCEDURE handlerSample ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
!!!RESOLVE EWI!!! /*** SSC-EWI-TD0004 - NOT SUPPORTED SQL EXCEPTION ON CONTINUE HANDLER ***/!!!
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
INSERT INTO Proc_Error_Table
VALUES ('spSample4', 'Failed SqlException');
SELECT
* FROM
Proc_Error_Table;
END;
$$;
Autres gestionnaires non pris en charge
Les gestionnaires pour SQLSTATE, SQLWARNING et NOT FOUND ne sont pas pris en charge
Teradata ¶
CREATE PROCEDURE handlerSample ()
BEGIN
DECLARE EXIT HANDLER FOR SQLSTATE '42002', SQLWARNING, NOT FOUND
INSERT INTO Proc_Error_Table ('procSample', 'Failed SqlState or SqlWarning or Not Found');
SELECT * FROM Proc_Error_Table;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE handlerSample ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/04/2024" }}'
EXECUTE AS CALLER
AS
$$
BEGIN
-- !!!RESOLVE EWI!!! /*** SSC-EWI-0058 - FUNCTIONALITY FOR 'SQLSTATE, SQLWARNING, NOT-FOUND TYPES HANDLER' IS NOT CURRENTLY SUPPORTED BY SNOWFLAKE SCRIPTING ***/!!!
-- DECLARE EXIT HANDLER FOR SQLSTATE '42002', SQLWARNING, NOT FOUND
-- INSERT INTO Proc_Error_Table ('procSample', 'Failed SqlState or SqlWarning or Not Found');
SELECT
* FROM
Proc_Error_Table;
END;
$$;
connexesEWIS¶
SSC-EWI-0058 : La fonctionnalité n’est pas prise en charge actuellement par Snowflake Scripting.
SSC-EWI-TD0004 : Exception SQL non prise en charge sur le gestionnaire de continuation.
EXECUTE/EXEC¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description ¶
L’instruction Teradata EXECUTE
permet l’exécution de SQL dynamique préparée ou de macros, tandis qu’exec n’autorise que les macros.
Pour plus d’informations sur Teradata EXECUTE/EXEC, consultez Macro Form et Dynamic SQL Form
-- EXECUTE macro syntax
{EXECUTE | EXEC } macro_identifier [ (<parameter_definition>[, ...n] ) ] [;]
<parameter_definition>:= {parameter_name = constant_expression | constant_expresion}
-- EXECUTE prepared dynamic SQL syntax
EXECUTE prepare_indentifier [<using>|<usingDescriptor>]
<using>:= USING < host_variable >[, ...n]
<host_variable>:= [:] host_variable_name [[INDICATOR] :host_indicator_name]
<usingDescriptor>:= USING DESCRIPTOR [:] descript_area
Échantillons de modèles de sources ¶
Données de configuration¶
Le code suivant est nécessaire à l’exécution des modèles d’échantillons présentés dans cette section.
-- Additional Params: -t JavaScript
CREATE TABLE inventory (
product_name VARCHAR(50),
price INTEGER
);
CREATE MACRO dummyMacro AS(
SELECT * FROM INVENTORY;
);
CREATE OR REPLACE TABLE inventory (
product_name VARCHAR(50),
price INTEGER
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
CREATE OR REPLACE PROCEDURE dummyMacro ()
RETURNS STRING
LANGUAGE JAVASCRIPT
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
// SnowConvert Helpers Code section is omitted.
INSERT_TEMP(`SELECT
*
FROM
INVENTORY`,[]);
return tablelist;
$$;
Exécution d’une instruction préparée¶
Teradata¶
CREATE PROCEDURE InsertProductInInventory(IN productName VARCHAR(50), IN price INTEGER)
BEGIN
DECLARE dynamicSql CHAR(200);
SET dynamicSql = 'INSERT INTO INVENTORY VALUES( ?, ?)';
PREPARE preparedSql FROM dynamicSql;
EXECUTE preparedSql USING productName, price;
END;
CALL InsertProductInInventory('''Chocolate''', 75);
CALL InsertProductInInventory('''Sugar''', 65);
CALL InsertProductInInventory('''Rice''', 100);
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE InsertProductInInventory (PRODUCTNAME VARCHAR(50), PRICE INTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
dynamicSql CHAR(200);
BEGIN
dynamicSql := 'INSERT INTO INVENTORY
VALUES (?, ?)';
!!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'PREPARE STATEMENT' NODE ***/!!!
PREPARE preparedSql FROM dynamicSql;
!!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
EXECUTE IMMEDIATE dynamicSql;
END;
$$;
CALL InsertProductInInventory('''Chocolate''', 75);
CALL InsertProductInInventory('''Sugar''', 65);
CALL InsertProductInInventory('''Rice''', 100);
Exécution d’une instruction macro¶
Teradata¶
EXECUTE dummyMacro;
+---------------+-------+
| product_name | price |
+---------------+-------+
| 'Chocolate' | 75 |
+---------------+-------+
| 'Sugar' | 65 |
+---------------+-------+
| 'Rice' | 100 |
+---------------+-------+
Snowflake Scripting ¶
!!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
EXECUTE IMMEDIATE dummyMacro;
EWIs connexes¶
SSC-EWI-0030: L’instruction ci-dessous a des utilisations de SQL dynamique.
SSC-EWI-0073 : En attente de l’examen de l’équivalence fonctionnelle.
EXECUTE IMMEDIATE¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description ¶
L’instruction Teradata EXECUTE IMMEDIATE
permet l’exécution de SQL dynamique contenu dans des variables ou des chaînes littérales.
Pour plus d’informations sur EXECUTE IMMEDIATE
, cliquez ici.
-- EXECUTE IMMEDIATE syntax
EXECUTE IMMEDIATE <dynamic_statement>
<dynamic_statement> := {string_literal | string_variable}
Échantillons de modèles de sources ¶
Données de configuration¶
Le code suivant est nécessaire à l’exécution des modèles d’échantillons présentés dans cette section.
CREATE TABLE inventory (
product_name VARCHAR(50),
price INTEGER
);
CREATE OR REPLACE TABLE inventory (
product_name VARCHAR(50),
price INTEGER
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
Exécuter l’exemple ¶
Teradata ¶
REPLACE PROCEDURE InsertProductInInventory(IN productName VARCHAR(50), IN price INTEGER)
BEGIN
DECLARE insertStatement VARCHAR(100);
SET insertStatement = 'INSERT INTO INVENTORY VALUES(' || productName || ', ' || price || ')';
EXECUTE IMMEDIATE insertStatement;
END;
CALL InsertProductInInventory('''Chocolate''', 75);
CALL InsertProductInInventory('''Sugar''', 65);
CALL InsertProductInInventory('''Rice''', 100);
SELECT product_name, price FROM inventory;
+--------------+-------+
| product_name | price |
+--------------+-------+
| Chocolate | 75 |
+--------------+-------+
| Sugar | 65 |
+--------------+-------+
| Rice | 100 |
+--------------+-------+
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE InsertProductInInventory (PRODUCTNAME VARCHAR(50), PRICE INTEGER)
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
insertStatement VARCHAR(100);
BEGIN
insertStatement := 'INSERT INTO INVENTORY
VALUES (' || productName || ', ' || price || ')';
!!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
EXECUTE IMMEDIATE insertStatement;
END;
$$;
CALL InsertProductInInventory('''Chocolate''', 75);
CALL InsertProductInInventory('''Sugar''', 65);
CALL InsertProductInInventory('''Rice''', 100);
SELECT
product_name,
price FROM
inventory;
+--------------+-------+
| PRODUCT_NAME | PRICE |
+--------------+-------+
| Chocolate | 75 |
+--------------+-------+
| Sugar | 65 |
+--------------+-------+
| Rice | 100 |
+--------------+-------+
column1|column2 |column3|
-------+-------------------------+-------+
3|Mundo3 | 3.3|
connexesEWIS¶
SSC-EWI-0030 : L’instruction ci-dessous a des utilisations de SQL dynamique.
FUNCTION OPTIONS OR DATA ACCESS¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Note
Instruction non pertinente.
Avertissement
Remarquez que cette instruction est retirée de la migration parce qu’il s’agit d’une syntaxe non pertinente. Cela signifie qu’elle n’est pas exigée dans Snowflake.
Description¶
Les options de fonctions ou options d’accès aux données sont des instructions utilisées dans les fonctions de la partie déclaration pour spécifier certaines caractéristiques. Il peut s’agir de :
CONTAINS SQL
SQL SECURITY DEFINER
COLLATION INVOKER
SPECIFIC FUNCTION_NAME
Modèles d’échantillons de sources¶
Options de fonction¶
Notez que dans cet exemple, les options de fonction ont été supprimées parce qu’elles ne sont pas requises dans Snowflake.
CREATE FUNCTION sumValues(A INTEGER, B INTEGER)
RETURNS INTEGER
LANGUAGE SQL
CONTAINS SQL
SQL SECURITY DEFINER
SPECIFIC sumTwoValues
COLLATION INVOKER
INLINE TYPE 1
RETURN A + B;
CREATE OR REPLACE FUNCTION sumValues (A INTEGER, B INTEGER)
RETURNS INTEGER
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
AS
$$
A + B
$$;
Problèmes connus ¶
Aucun problème n’a été constaté.
EWIs connexes ¶
Pas d’EWIs connexes.
GET DIAGNOSTICS EXCEPTION¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description ¶
GET DIAGNOSTICS récupère des informations sur les conditions de réussite, d’exception ou d’achèvement dans la zone de diagnostic.
Pour plus d’informations sur Teradata GET DIAGNOSTICS, cliquez ici.
GET DIAGNOSTICS
{
[ EXCEPTION < condition_number >
[ < parameter_name | variable_name > = < information_item > ]...
]
|
[ < parameter_name | variable_name > = < information_item > ]...
}
Échantillons de modèles de sources ¶
Teradata ¶
CREATE PROCEDURE getDiagnosticsSample ()
BEGIN
DECLARE V_MESSAGE, V_CODE VARCHAR(200);
DECLARE V_Result INTEGER;
SELECT c1 INTO V_Result FROM tab1;
GET DIAGNOSTICS EXCEPTION 1
V_MESSAGE = Message_Text,
V_CODE = RETURNED_SQLSTATE;
END;
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE getDiagnosticsSample ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "06/18/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
V_MESSAGE VARCHAR(200);
V_CODE VARCHAR(200);
V_Result INTEGER;
BEGIN
SELECT
c1 INTO
:V_Result
FROM
tab1;
V_MESSAGE := SQLERRM;
V_CODE := SQLSTATE;
END;
$$;
Problèmes connus¶
CLASS_ORIGIN, CONDITION_NUMBER¶
L’utilisation de GET DIAGNOSTICS pour CLASS_ORIGIN, CONDITION_NUMBER n’est pas autorisée
Teradata
CREATE PROCEDURE getDiagnosticsSample ()
BEGIN
DECLARE V_MESSAGE, V_CODE VARCHAR(200);
DECLARE V_Result INTEGER;
SELECT c1 INTO V_Result FROM tab1;
GET DIAGNOSTICS EXCEPTION 5
V_CLASS = CLASS_ORIGIN,
V_COND = CONDITION_NUMBER;
END;
Snowflake Scripting
CREATE OR REPLACE PROCEDURE getDiagnosticsSample ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "06/18/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
V_MESSAGE VARCHAR(200);
V_CODE VARCHAR(200);
V_Result INTEGER;
BEGIN
SELECT
c1 INTO
:V_Result
FROM
tab1;
-- V_CLASS = CLASS_ORIGIN
!!!RESOLVE EWI!!! /*** SSC-EWI-0058 - FUNCTIONALITY FOR 'GET DIAGNOSTICS DETAIL FOR CLASS_ORIGIN' IS NOT CURRENTLY SUPPORTED BY SNOWFLAKE SCRIPTING ***/!!!
-- V_COND = CONDITION_NUMBER
!!!RESOLVE EWI!!! /*** SSC-EWI-0058 - FUNCTIONALITY FOR 'GET DIAGNOSTICS DETAIL FOR CONDITION_NUMBER' IS NOT CURRENTLY SUPPORTED BY SNOWFLAKE SCRIPTING ***/!!!
END;
$$;
Related EWIS
SSC-EWI-0058 : La fonctionnalité n’est pas prise en charge actuellement par Snowflake Scripting.
IF
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description ¶
Fournit une exécution conditionnelle basée sur la valeur de vérité d’une condition.
Pour plus d’informations sur Teradata IF, cliquez ici.
IF conditional_expression THEN
statement
[ statement ]...
[ ELSEIF conditional_expression THEN
statement
[ statement ]... ]...
[ ELSE
statement
[ statement ]... ]
END IF;
Échantillons de modèles de sources ¶
Échantillon de table auxiliaire¶
CREATE TABLE if_table(col1 varchar(30));
CREATE OR REPLACE TABLE if_table (
col1 varchar(30))
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
Variantes possibles de IF¶
Teradata ¶
CREATE PROCEDURE ifExample1 ( flag NUMBER )
BEGIN
IF flag = 1 THEN
INSERT INTO if_table(col1) VALUES ('one');
END IF;
END;
CALL ifExample1(1);
SELECT * FROM if_table;
CREATE PROCEDURE ifExample2 ( flag NUMBER )
BEGIN
IF flag = 1 THEN
INSERT INTO if_table(col1) VALUES ('one');
ELSE
INSERT INTO if_table(col1) VALUES ('Unexpected input.');
END IF;
END;
CALL ifExample2(2);
SELECT * FROM if_table;
CREATE PROCEDURE ifExample3 ( flag NUMBER )
BEGIN
IF flag = 1 THEN
INSERT INTO if_table(col1) VALUES ('one');
ELSEIF flag = 2 THEN
INSERT INTO if_table(col1) VALUES ('two');
ELSEIF flag = 3 THEN
INSERT INTO if_table(col1) VALUES ('three');
END IF;
END;
CALL ifExample3(3);
SELECT * FROM if_table;
CREATE PROCEDURE ifExample4 ( flag NUMBER )
BEGIN
IF flag = 1 THEN
INSERT INTO if_table(col1) VALUES ('one');
ELSEIF flag = 2 THEN
INSERT INTO if_table(col1) VALUES ('two');
ELSEIF flag = 3 THEN
INSERT INTO if_table(col1) VALUES ('three');
ELSE
INSERT INTO if_table(col1) VALUES ('Unexpected input.');
END IF;
END;
CALL ifExample4(4);
SELECT * FROM if_table;
|COL1|
|----|
|one |
|COL1 |
|-----------------|
|Unexpected input.|
|COL1 |
|-----|
|three|
|COL1 |
|-----------------|
|Unexpected input.|
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE ifExample1 (FLAG NUMBER(38, 18))
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
IF (flag = 1) THEN
INSERT INTO if_table (col1)
VALUES ('one');
END IF;
END;
$$;
CALL ifExample1(1);
SELECT
* FROM
if_table;
CREATE OR REPLACE PROCEDURE ifExample2 (FLAG NUMBER(38, 18))
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
IF (flag = 1) THEN
INSERT INTO if_table (col1)
VALUES ('one');
ELSE
INSERT INTO if_table (col1)
VALUES ('Unexpected input.');
END IF;
END;
$$;
CALL ifExample2(2);
SELECT
* FROM
if_table;
CREATE OR REPLACE PROCEDURE ifExample3 (FLAG NUMBER(38, 18))
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
IF (flag = 1) THEN
INSERT INTO if_table (col1)
VALUES ('one');
ELSEIF (flag = 2) THEN
INSERT INTO if_table (col1)
VALUES ('two');
ELSEIF (flag = 3) THEN
INSERT INTO if_table (col1)
VALUES ('three');
END IF;
END;
$$;
CALL ifExample3(3);
SELECT
* FROM
if_table;
CREATE OR REPLACE PROCEDURE ifExample4 (FLAG NUMBER(38, 18))
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
IF (flag = 1) THEN
INSERT INTO if_table (col1)
VALUES ('one');
ELSEIF (flag = 2) THEN
INSERT INTO if_table (col1)
VALUES ('two');
ELSEIF (flag = 3) THEN
INSERT INTO if_table (col1)
VALUES ('three');
ELSE
INSERT INTO if_table (col1)
VALUES ('Unexpected input.');
END IF;
END;
$$;
CALL ifExample4(4);
SELECT
* FROM
if_table;
|COL1|
|----|
|one |
|COL1 |
|-----------------|
|Unexpected input.|
|COL1 |
|-----|
|three|
|COL1 |
|-----------------|
|Unexpected input.|
Problèmes connus ¶
Aucun problème n’a été constaté.
EWIs connexes ¶
Pas d’EWIs connexes.
LOCKING FOR ACCESS¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Note
Instruction non pertinente.
Avertissement
Remarquez que cette instruction est retirée de la migration parce qu’il s’agit d’une syntaxe non pertinente. Cela signifie qu’elle n’est pas exigée dans Snowflake.
Description¶
La fonctionnalité de verrouillage d’une ligne dans Teradata est liée à l’accès et aux privilèges. Consultez la documentation suivante pour en savoir plus.
Modèles d’échantillons de sources¶
Ligne verrouillée¶
Notez que dans cet exemple, LOCKING ROW FOR ACCESS
a été supprimé. En effet, Snowflake gère les accès en fonction des rôles et des privilèges. L’instruction n’est pas une exigence.
REPLACE VIEW SCHEMA2.VIEW1
AS
LOCKING ROW FOR ACCESS
SELECT * FROM SCHEMA1.TABLE1;
--** SSC-FDM-0007 - MISSING DEPENDENT OBJECT "SCHEMA1.TABLE1" **
CREATE OR REPLACE VIEW SCHEMA2.VIEW1
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
AS
--** SSC-FDM-0001 - VIEWS SELECTING ALL COLUMNS FROM A SINGLE TABLE ARE NOT REQUIRED IN SNOWFLAKE AND MAY IMPACT PERFORMANCE. **
SELECT
* FROM
SCHEMA1.TABLE1;
Problèmes connus ¶
Aucun problème n’a été constaté.
EWIs connexes¶
SSC-FDM-0001 : Les vues sélectionnant toutes les colonnes d’une même table ne sont pas exigées dans Snowflake.
SSC-FDM-0007 : Élément avec des dépendances manquantes.
LOOP¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description ¶
L’instruction LOOP
de Teradata est traduite dans la syntaxe de Snowflake Scripting LOOP
.
Pour plus d’informations sur Teradata Loop, cliquez ici.
[label_name:] LOOP
{ sql_statement }
END LOOP [label_name];
Échantillons de modèles de sources ¶
Teradata ¶
CREATE PROCEDURE loopProcedure(OUT resultCounter INTEGER)
BEGIN
DECLARE counter INTEGER DEFAULT 0;
customeLabel: LOOP
SET counter = counter + 1;
IF counter = 10 THEN
LEAVE customeLabel;
END IF;
END LOOP customeLabel;
SET resultCounter = counter;
END;
CALL loopProcedure(:?);
|resultCounter|
|-------------|
|10 |
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE loopProcedure (
-- OUT
RESULTCOUNTER INTEGER)
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
counter INTEGER DEFAULT 0;
BEGIN
LOOP
counter := counter + 1;
IF (counter = 10) THEN
BREAK CUSTOMELABEL;
END IF;
END LOOP CUSTOMELABEL;
resultCounter := counter;
RETURN resultCounter;
END;
$$;
CALL loopProcedure(:?);
|LOOPPROCEDURE|
|-------------|
|10 |
Problèmes connus ¶
Aucun problème n’a été constaté.
EWIs connexes ¶
Pas d’EWIs connexes.
OUTPUT PARAMETERS¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description¶
Un paramètre de sortie est un paramètre dont la valeur est transmise à l’extérieur de la procédure stockée, en retour à l’instruction appelante. Les paramètres de sortie n’étant pas pris en charge par le support Snowflake Scripting, une solution a été mise en œuvre afin d’émuler leur fonctionnalité.
Modèles d’échantillons de sources¶
Échantillon de table auxiliaire¶
CREATE TABLE table20 ( col1 NUMBER, col2 NUMBER );
CREATE OR REPLACE TABLE table20 (
col1 NUMBER(38, 18),
col2 NUMBER(38, 18)
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;
Dans la déclaration, les mots-clés OUT
ou IN OUT
sont supprimés. L’affectation est émise de la même manière que l’entrée, mais pour émuler la fonctionnalité du paramètre de sortie, certaines instructions sont ajoutées.
Lorsqu’une procédure avec des paramètres de sortie est appelée dans une autre procédure, certaines instructions sont ajoutées pour obtenir et attribuer la ou les valeurs à l’argument ou aux arguments respectifs.
Paramètre unique Out¶
CREATE PROCEDURE demo.proc_with_single_output_parameters(OUT param1 NUMBER)
BEGIN
SET param1 = 100;
END;
REPLACE PROCEDURE demo.proc_calling_proc_with_single_output_parameters ()
BEGIN
DECLARE mytestvar NUMBER;
CALL demo.proc_with_single_output_parameters(mytestvar);
INSERT INTO demo.TABLE20 VALUES(mytestvar,432);
END;
CREATE OR REPLACE PROCEDURE demo.proc_with_single_output_parameters (
-- OUT
PARAM1 NUMBER(38, 18))
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
BEGIN
param1 := 100;
RETURN null;
END;
$$;
CREATE OR REPLACE PROCEDURE demo.proc_calling_proc_with_single_output_parameters ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
mytestvar NUMBER(38, 18);
BEGIN
CALL demo.proc_with_single_output_parameters(:mytestvar);
INSERT INTO demo.TABLE20
VALUES (:mytestvar,432);
END;
$$;
Plusieurs paramètres Out¶
CREATE PROCEDURE demo.proc_with_multiple_output_parameters(OUT param1 NUMBER, INOUT param2 NUMBER)
BEGIN
SET param1 = param2;
SET param2 = 32;
END;
CREATE PROCEDURE demo.proc_calling_proc_with_multiple_output_parameters ()
BEGIN
DECLARE var1 NUMBER;
DECLARE var2 NUMBER;
SET var2 = 34;
CALL demo.proc_with_multiple_output_parameters(var1, var2);
INSERT INTO demo.TABLE20 VALUES(var1,var2);
END;
CREATE OR REPLACE PROCEDURE demo.proc_with_multiple_output_parameters (
-- OUT
PARAM1 NUMBER(38, 18),
-- INOUT
PARAM2 NUMBER(38, 18))
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
BEGIN
param1 := param2;
param2 := 32;
RETURN null;
END;
$$;
CREATE OR REPLACE PROCEDURE demo.proc_calling_proc_with_multiple_output_parameters ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
var1 NUMBER(38, 18);
var2 NUMBER(38, 18);
BEGIN
var2 := 34;
CALL demo.proc_with_multiple_output_parameters(:var1, :var2);
INSERT INTO demo.TABLE20
VALUES (:var1, :var2);
END;
$$;
Paramètres OUT du type de données de client¶
lorsque le paramètre de sortie est un type de client, le processus est similaire à celui d’un type de données ordinaire.
CREATE OR REPLACE PROCEDURE GetEmployeeInfo (
OUT EmpInfo EmployeeType
)
BEGIN
SET EmpInfo.EmployeeID = 1001;
SET EmpInfo.FirstName = 'John';
END;
CREATE OR REPLACE PROCEDURE GetEmployeeInfo (
-- OUT
EMPINFO EmployeeType
)
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
BEGIN
EmpInfo.EmployeeID := 1001;
EmpInfo.FirstName := 'John';
RETURN EmpInfo;
END;
$$;
Problèmes connus¶
1. Some data types may not work properly¶
Comme le montre la transformation, lorsqu’on récupère la valeur à partir des procédures appelées, une conversion implicite est effectuée de VARIANT vers le type spécifié par la variable. Comme il existe de nombreux types de données possibles, certaines transformations peuvent échouer ou contenir des données différentes.
EWIs connexes ¶
Pas d’EWIs connexes.
PREPARE¶
Description ¶
Prépare l’instruction dynamique DECLARE CURSOR pour permettre la création de différents jeux de résultats. Permet d’utiliser des marqueurs de paramètre dynamiques.
Pour plus d’informations, veuillez consulter la documentation suivante.
Syntaxe Tedarata :
PREPARE statement_name FROM { 'statement_string' | statement_string_variable } ;
Où :
statement_name est le même identificateur que
statement_name
dans une instruction DECLARE CURSOR.statement_string est le texte SQL qui doit être exécuté de manière dynamique.
statement_string_variable est le nom d’une variable locale SQL, ou d’un paramètre SQL ou d’une variable de chaîne, qui contient la chaîne de texte SQL à exécuter dynamiquement.
Note
Informations importantes
Pour cette transformation, les curseurs sont renommés car ils ne peuvent pas être mis à jour dynamiquement.
Échantillons de modèles de sources ¶
Paramètre de données pour les exemples¶
Pour cet exemple, veuillez utiliser les requêtes complémentaires suivantes dans le cas où vous souhaitez exécuter chaque cas.
CREATE TABLE MyTemporaryTable(
Col1 INTEGER
);
INSERT INTO MyTemporaryTable(col1) VALUES (1);
SELECT * FROM databaseTest.MyTemporaryTable;
CREATE TABLE MyStatusTable (
Col1 VARCHAR(2)
);
SELECT * FROM MyStatusTable;
CREATE TABLE MyTemporaryTable (
Col1 INTEGER
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
;
INSERT INTO MyTemporaryTable (col1) VALUES (1);
SELECT * FROM MyTemporaryTable;
CREATE TABLE MyStatusTable (
Col1 VARCHAR(2)
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
;
SELECT * FROM MyStatusTable;
Scénario simple¶
Cet exemple passe en revue la fonctionnalité pour les cas où un seul curseur est utilisé une seule fois.
Teradata ¶
REPLACE PROCEDURE simple_scenario()
BEGIN
--Variables for the example's procedure_results
DECLARE SQL_string_sel VARCHAR(200) DEFAULT 'SELECT * FROM MyTemporaryTable';
DECLARE procedure_result INTEGER DEFAULT 0;
-- Actual Cursor usage
DECLARE C1 CURSOR FOR S1;
PREPARE S1 FROM SQL_string_sel;
OPEN C1;
FETCH C1 INTO procedure_result;
INSERT INTO databaseTest.MyStatusTable(Col1) VALUES (procedure_result);
CLOSE C1;
END;
CALL databaseTest.simple_scenario();
SELECT * FROM MyStatusTable;
Col1 |
---|
1 |
Snowflake Scripting ¶
Note
Les utilisations des curseurs doivent être renommées et déclarées à nouveau.
CREATE OR REPLACE PROCEDURE simple_scenario ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ ""origin"": ""sf_sc"", ""name"": ""snowconvert"", ""version"": { ""major"": 0, ""minor"": 0, ""patch"": ""0"" }, ""attributes"": { ""component"": ""none"", ""convertedOn"": ""01/01/0001"" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
--Variables for the example's procedure_results
SQL_string_sel VARCHAR(200) DEFAULT 'SELECT
* FROM
MyTemporaryTable';
procedure_result INTEGER DEFAULT 0;
S1 RESULTSET;
prepareQuery_aux_sql VARCHAR;
BEGIN
-- Actual Cursor usage
prepareQuery_aux_sql := SQL_string_sel;
S1 := (
EXECUTE IMMEDIATE prepareQuery_aux_sql
);
LET CURSOR_S1_INSTANCE_V0 CURSOR
FOR
S1;
OPEN CURSOR_S1_INSTANCE_V0;
FETCH
CURSOR_S1_INSTANCE_V0
INTO
procedure_result;
INSERT INTO databaseTest.MyStatusTable (Col1)
VALUES (procedure_result);
CLOSE CURSOR_S1_INSTANCE_V0;
END;
$$;
CALL databaseTest.simple_scenario();
SELECT * FROM MyStatusTable;
Col1 |
---|
1 |
Scénario simple avec RETURN ONLY¶
Teradata ¶
REPLACE PROCEDURE simple_scenario()
DYNAMIC RESULT SETS 1
BEGIN
DECLARE SQL_string_sel VARCHAR(200) DEFAULT 'SELECT * FROM MyTemporaryTable';
DECLARE procedure_result VARCHAR(100);
DECLARE C1 CURSOR WITH RETURN ONLY FOR S1;
SET procedure_result = '';
PREPARE S1 FROM SQL_string_sel;
OPEN C1;
END;
CALL databaseTest.simple_scenario();
SELECT * FROM MyStatusTable;
Col1 |
---|
1 |
Snowflake Scripting ¶
Note
Les utilisations des curseurs doivent être renommées et déclarées à nouveau.
CREATE OR REPLACE PROCEDURE simple_scenario ()
RETURNS TABLE (
)
LANGUAGE SQL
COMMENT = '{ ""origin"": ""sf_sc"", ""name"": ""snowconvert"", ""version"": { ""major"": 0, ""minor"": 0, ""patch"": ""0"" }, ""attributes"": { ""component"": ""none"", ""convertedOn"": ""01/01/0001"" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
SQL_string_sel VARCHAR(200) DEFAULT 'SELECT
* FROM
MyTemporaryTable';
procedure_result VARCHAR(100);
S1 RESULTSET;
prepareQuery_aux_sql VARCHAR;
BEGIN
procedure_result := '';
prepareQuery_aux_sql := SQL_string_sel;
S1 := (
EXECUTE IMMEDIATE prepareQuery_aux_sql
);
LET CURSOR_S1_INSTANCE_V0 CURSOR
FOR
S1;
OPEN CURSOR_S1_INSTANCE_V0;
RETURN TABLE(resultset_from_cursor(CURSOR_S1_INSTANCE_V0));
END;
$$;
CALL databaseTest.simple_scenario();
SELECT * FROM MyStatusTable;
Col1 |
---|
1 |
Cas de curseur réutilisé¶
Teradata ¶
CREATE PROCEDURE fetch_simple_reused_cursor(OUT procedure_result INTEGER)
BEGIN
DECLARE SQL_string_sel VARCHAR(200) DEFAULT 'SELECT col1 FROM MyTemporaryTable WHERE col1 = 1';
DECLARE C1 CURSOR FOR S1;
PREPARE S1 FROM SQL_string_sel;
OPEN C1;
FETCH C1 INTO procedure_result;
CLOSE C1;
PREPARE S1 FROM SQL_string_sel;
OPEN C1;
FETCH C1 INTO procedure_result;
CLOSE C1;
END;
No returning information.
Snowflake Scripting ¶
Note
Les utilisations des curseurs doivent être renommées et déclarées à nouveau.
CREATE OR REPLACE PROCEDURE fetch_simple_reused_cursor (
-- OUT
PROCEDURE_RESULT INTEGER)
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
SQL_string_sel VARCHAR(200) DEFAULT 'SELECT
col1 FROM
MyTemporaryTable
WHERE col1 = 1';
S1 RESULTSET;
prepareQuery_aux_sql VARCHAR;
BEGIN
prepareQuery_aux_sql := SQL_string_sel;
S1 := (
EXECUTE IMMEDIATE prepareQuery_aux_sql
);
LET CURSOR_S1_INSTANCE_V0 CURSOR
FOR
S1;
OPEN CURSOR_S1_INSTANCE_V0;
FETCH
CURSOR_S1_INSTANCE_V0
INTO procedure_result;
CLOSE CURSOR_S1_INSTANCE_V0;
prepareQuery_aux_sql := SQL_string_sel;
S1 := (
EXECUTE IMMEDIATE prepareQuery_aux_sql
);
LET CURSOR_S1_INSTANCE_V1 CURSOR
FOR
S1;
OPEN CURSOR_S1_INSTANCE_V1;
FETCH
CURSOR_S1_INSTANCE_V1
INTO procedure_result;
CLOSE CURSOR_S1_INSTANCE_V1;
RETURN procedure_result;
END;
$$;
No returning information.
Requête modifiée avant utilisation¶
Teradata ¶
REPLACE PROCEDURE fetch_modified_query_cursor()
BEGIN
--Variables for the example's procedure_results
DECLARE SQL_string_sel VARCHAR(200) DEFAULT 'SELECT col1 FROM MyTemporaryTable WHERE col1 = 1';
DECLARE procedure_result INTEGER DEFAULT 0;
-- Actual Cursor usages
DECLARE C1 CURSOR FOR S1;
PREPARE S1 FROM SQL_string_sel;
-- This modification does not take effect since S1 is already staged for the Cursor
SET SQL_string_sel = 'SELECT col1 FROM MyTemporaryTable WHERE col1 = 0';
OPEN C1;
FETCH C1 INTO procedure_result;
INSERT INTO databaseTest.MyStatusTable(Col1) VALUES (procedure_result);
CLOSE C1;
END;
CALL databaseTest.simple_scenario();
SELECT * FROM MyStatusTable;
Col1 |
---|
1 |
Snowflake Scripting ¶
Note
Les utilisations des curseurs doivent être renommées et déclarées à nouveau.
CREATE OR REPLACE PROCEDURE fetch_modified_query_cursor ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ ""origin"": ""sf_sc"", ""name"": ""snowconvert"", ""version"": { ""major"": 0, ""minor"": 0, ""patch"": ""0"" }, ""attributes"": { ""component"": ""none"", ""convertedOn"": ""01/01/0001"" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
--Variables for the example's procedure_results
SQL_string_sel VARCHAR(200) DEFAULT 'SELECT
col1 FROM
MyTemporaryTable
WHERE col1 = 1';
procedure_result INTEGER DEFAULT 0;
S1 RESULTSET;
prepareQuery_aux_sql VARCHAR;
BEGIN
-- Actual Cursor usages
prepareQuery_aux_sql := SQL_string_sel;
S1 := (
EXECUTE IMMEDIATE prepareQuery_aux_sql
);
LET CURSOR_S1_INSTANCE_V0 CURSOR
FOR
S1;
-- This modification does not take effect since S1 is already staged for the Cursor
SQL_string_sel := 'SELECT
col1 FROM
MyTemporaryTable
WHERE col1 = 0';
OPEN CURSOR_S1_INSTANCE_V0;
FETCH
CURSOR_S1_INSTANCE_V0
INTO
procedure_result;
INSERT INTO databaseTest.MyStatusTable (Col1)
VALUES (procedure_result);
CLOSE CURSOR_S1_INSTANCE_V0;
END;
$$;
CALL databaseTest.simple_scenario();
SELECT * FROM MyStatusTable;
Col1 |
---|
1 |
Curseur simple combiné à l’absence de modèle PREPARE¶
Teradata ¶
REPLACE PROCEDURE fetch_cursor_ignored_query_cursor()
BEGIN
--Variables for the example's procedure_results
DECLARE SQL_string_sel VARCHAR(200) DEFAULT 'SELECT * FROM MyTemporaryTable WHERE col1 = 1';
DECLARE intermediate_result INTEGER;
DECLARE procedure_result INTEGER DEFAULT 0;
DECLARE C2 CURSOR FOR SELECT col1 FROM MyTemporaryTable WHERE col1 = 1;
-- Actual Cursor usage
DECLARE C1 CURSOR FOR S1;
PREPARE S1 FROM SQL_string_sel;
OPEN C1;
FETCH C1 INTO intermediate_result;
CLOSE C1;
SET procedure_result = intermediate_result;
INSERT INTO databaseTest.MyStatusTable(Col1) VALUES (procedure_result);
OPEN C2;
FETCH C2 INTO intermediate_result;
CLOSE C2;
SET procedure_result = procedure_result + intermediate_result;
END;
CALL databaseTest.simple_scenario();
SELECT * FROM MyStatusTable;
Col1 |
---|
1 |
Snowflake Scripting ¶
Note
Les utilisations des curseurs doivent être renommées et déclarées à nouveau.
CREATE OR REPLACE PROCEDURE fetch_cursor_ignored_query_cursor ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ ""origin"": ""sf_sc"", ""name"": ""snowconvert"", ""version"": { ""major"": 0, ""minor"": 0, ""patch"": ""0"" }, ""attributes"": { ""component"": ""none"", ""convertedOn"": ""01/01/0001"" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
--Variables for the example's procedure_results
SQL_string_sel VARCHAR(200) DEFAULT 'SELECT
* FROM
MyTemporaryTable
WHERE col1 = 1';
intermediate_result INTEGER;
procedure_result INTEGER DEFAULT 0;
S1 RESULTSET;
prepareQuery_aux_sql VARCHAR;
BEGIN
-- Actual Cursor usage
LET C2 CURSOR
FOR
SELECT
col1
FROM
MyTemporaryTable
WHERE
col1 = 1;
prepareQuery_aux_sql := SQL_string_sel;
S1 := (
EXECUTE IMMEDIATE prepareQuery_aux_sql
);
LET CURSOR_S1_INSTANCE_V0 CURSOR
FOR
S1;
OPEN CURSOR_S1_INSTANCE_V0;
FETCH
CURSOR_S1_INSTANCE_V0
INTO
intermediate_result;
CLOSE CURSOR_S1_INSTANCE_V0;
procedure_result := intermediate_result;
INSERT INTO databaseTest.MyStatusTable (Col1)
VALUES (procedure_result);
OPEN C2;
FETCH
C2
INTO
intermediate_result;
CLOSE C2;
procedure_result := procedure_result + intermediate_result;
END;
$$;
CALL databaseTest.simple_scenario();
SELECT * FROM MyStatusTable;
Col1 |
---|
1 |
Préparation combinée avec des curseurs imbriqués¶
Teradata ¶
REPLACE PROCEDURE fetch_nested_cursor()
BEGIN
--Variables for the example's procedure_results
DECLARE SQL_string_sel VARCHAR(200) DEFAULT 'SELECT col1 FROM MyTemporaryTable WHERE col1 = 1';
DECLARE intermediate_result INTEGER;
DECLARE C2 CURSOR FOR SELECT col1 FROM MyTemporaryTable WHERE col1 = 1;
-- Actual Cursor usage
DECLARE C1 CURSOR FOR S1;
PREPARE S1 FROM SQL_string_sel;
OPEN C1;
OPEN C2;
FETCH C2 INTO intermediate_result;
CLOSE C2;
FETCH C1 INTO intermediate_result;
CLOSE C1;
END;
No returning information.
Snowflake Scripting ¶
Note
Les utilisations des curseurs doivent être renommées et déclarées à nouveau.
CREATE OR REPLACE PROCEDURE fetch_nested_cursor ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ ""origin"": ""sf_sc"", ""name"": ""snowconvert"", ""version"": { ""major"": 0, ""minor"": 0, ""patch"": ""0"" }, ""attributes"": { ""component"": ""none"", ""convertedOn"": ""01/01/0001"" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
--Variables for the example's procedure_results
SQL_string_sel VARCHAR(200) DEFAULT 'SELECT
col1 FROM
MyTemporaryTable
WHERE col1 = 1';
intermediate_result INTEGER;
S1 RESULTSET;
prepareQuery_aux_sql VARCHAR;
BEGIN
-- Actual Cursor usage
LET C2 CURSOR
FOR
SELECT
col1
FROM
MyTemporaryTable
WHERE
col1 = 1;
prepareQuery_aux_sql := SQL_string_sel;
S1 := (
EXECUTE IMMEDIATE prepareQuery_aux_sql
);
LET CURSOR_S1_INSTANCE_V0 CURSOR
FOR
S1;
OPEN CURSOR_S1_INSTANCE_V0;
OPEN C2;
FETCH
C2
INTO
intermediate_result;
CLOSE C2;
FETCH
CURSOR_S1_INSTANCE_V0
INTO
intermediate_result;
CLOSE CURSOR_S1_INSTANCE_V0;
END;
$$;
No returning information.
Marqueurs variables sans réorganisation des variables¶
Avertissement
Ce cas n’est pas encore pris en charge.
Teradata ¶
CREATE PROCEDURE PREPARE_ST_TEST()
BEGIN
DECLARE ctry_list VARCHAR(100);
DECLARE SQL_string_sel VARCHAR(255);
DECLARE col_value NUMBER;
DECLARE C1 CURSOR FOR S1;
SET ctry_list = '';
SET col_value = 1;
SET SQL_string_sel = 'SELECT * FROM databaseTest.MyTemporaryTable where Col1 = ?';
PREPARE S1 FROM SQL_string_sel;
OPEN C1 USING col_value;
FETCH C1 INTO ctry_list;
IF (ctry_list <> '') THEN
INSERT INTO databaseTest.MyStatusTable(col1) VALUES ('ok');
END IF;
CLOSE C1;
END;
CALL PREPARE_ST_TEST();
SELECT * FROM MyStatusTable;
Col1 |
---|
ok |
Snowflake Scripting ¶
Note
Les utilisations des curseurs doivent être renommées et déclarées à nouveau.
CREATE OR REPLACE PROCEDURE PREPARE_ST_TEST_MARKERS ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
DECLARE
p1 RESULTSET;
p1_sql VARCHAR DEFAULT '';
BEGIN
LET ctry_list VARCHAR(100);
LET SQL_string_sel VARCHAR(255);
LET col_value NUMBER(38, 18);
LET S1 RESULTSET;
ctry_list := '';
col_value := 1;
SQL_string_sel := 'SELECT * FROM MyTemporaryTable WHERE Col1 = ?';
p1_sql := SQL_string_sel;
S1 := (
EXECUTE IMMEDIATE p1_sql USING (col_value)
);
LET C1 CURSOR FOR S1;
OPEN C1;
FETCH C1 INTO ctry_list;
IF (RTRIM(ctry_list) <> '') THEN
INSERT INTO MyStatusTable (col1)
VALUES ('ok');
END IF;
CLOSE C1;
END;
$$;
Col1 |
---|
ok |
Marqueurs variables avec réorganisation des variables¶
Avertissement
Ce cas n’est pas encore pris en charge.
Note
Lorsqu’il y a des variables définissant des valeurs différentes entre l’instruction PREPARE
et le curseur OPEN
dans Teradata, il est nécessaire de déplacer cette variable avant EXECUTE IMMEDIATE
dans Snowflake. Ainsi, les informations sur les variables dynamiques sont mises à jour au moment de l’exécution de la requête dynamique.
Teradata ¶
CREATE PROCEDURE PREPARE_ST_TEST()
BEGIN
DECLARE ctry_list VARCHAR(100);
DECLARE SQL_string_sel VARCHAR(255);
DECLARE col_name NUMBER;
DECLARE C1 CURSOR FOR S1;
SET ctry_list = '';
SET col_name = 1;
SET SQL_string_sel = 'SELECT * FROM databaseTest.MyTemporaryTable where Col1 = ?';
PREPARE S1 FROM SQL_string_sel;
SET col_name = 2; // change value before open cursor
OPEN C1 USING col_name;
FETCH C1 INTO ctry_list;
IF (ctry_list <> '') THEN
INSERT INTO databaseTest.MyStatusTable(col1) VALUES ('ok');
END IF;
CLOSE C1;
END;
CALL PREPARE_ST_TEST();
SELECT * FROM MyStatusTable;
"MyStatusTable" should be empty.
Snowflake Scripting ¶
Note
Les utilisations des curseurs doivent être renommées et déclarées à nouveau.
CREATE OR REPLACE PROCEDURE PREPARE_ST_TEST_MARKERS ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"teradata"}}'
EXECUTE AS CALLER
AS
$$
DECLARE
p1 RESULTSET;
p1_sql VARCHAR DEFAULT '';
BEGIN
LET ctry_list VARCHAR(100);
LET SQL_string_sel VARCHAR(255);
LET col_value NUMBER(38, 18);
LET S1 RESULTSET;
ctry_list := '';
col_value := 1;
SQL_string_sel := 'SELECT * FROM MyTemporaryTable WHERE Col1 = ?';
p1_sql := SQL_string_sel;
col_value:= 2; // Move variable setting before the EXECUTE IMMEDIATE
S1 := (
EXECUTE IMMEDIATE p1_sql USING (col_value)
);
LET C1 CURSOR FOR S1;
OPEN C1;
FETCH C1 INTO ctry_list;
IF (RTRIM(ctry_list) <> '') THEN
INSERT INTO MyStatusTable (col1)
VALUES ('ok');
END IF;
CLOSE C1;
END;
$$;
CALL PREPARE_ST_TEST();
SELECT * FROM MyStatusTable;
"MyStatusTable" should be empty.
Blocs anonymes - Déclaration en dehors du bloc¶
Avertissement
Ce cas n’est pas encore pris en charge.
Teradata ¶
REPLACE PROCEDURE anonymous_blocks_case(OUT procedure_result INTEGER)
BEGIN
--Variables for the example's procedure_results
DECLARE SQL_string_sel VARCHAR(200) DEFAULT 'SELECT col1 FROM MyTemporaryTable WHERE col1 = 1';
-- Actual Cursor usage
DECLARE C1 CURSOR FOR S1;
DECLARE C2 CURSOR FOR S2;
PREPARE S1 FROM SQL_string_sel;
OPEN C1;
FETCH C1 INTO procedure_result;
CLOSE C1;
BEGIN
PREPARE S2 FROM SQL_string_sel;
OPEN C2;
FETCH C2 INTO procedure_result;
CLOSE C2;
END;
OPEN C1;
CLOSE C1;
END;
No returning information.
CREATE OR REPLACE PROCEDURE anonymous_blocks_case (
-- OUT
PROCEDURE_RESULT INTEGER)
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "none", "convertedOn": "01/01/0001" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
--Variables for the example's procedure_results
SQL_string_sel VARCHAR(200) DEFAULT 'SELECT
col1 FROM
MyTemporaryTable
WHERE col1 = 1';
S1 RESULTSET;
prepareQuery_aux_sql VARCHAR;
S2 RESULTSET;
BEGIN
-- Actual Cursor usage
prepareQuery_aux_sql := SQL_string_sel
S1 := (
EXECUTE IMMEDIATE prepareQuery_aux_sql
);
LET CURSOR_S1_INSTANCE_V0 CURSOR
FOR
S1;
OPEN CURSOR_S1_INSTANCE_V0;
FETCH
CURSOR_S1_INSTANCE_V0
INTO
procedure_result;
CLOSE CURSOR_S1_INSTANCE_V0;
BEGIN
prepareQuery_aux_sql := SQL_string_sel
S2 := (
EXECUTE IMMEDIATE prepareQuery_aux_sql
);
LET CURSOR_S2_INSTANCE_V# CURSOR
FOR
S1;
OPEN CURSOR_S2_INSTANCE_V#;
FETCH
CURSOR_S2_INSTANCE_V#
INTO
procedure_result;
CLOSE CURSOR_S2_INSTANCE_V#;
END;
OPEN CURSOR_S1_INSTANCE_V0; -- NAME REMAINS AS NEEDED IN LOGIC
CLOSE CURSOR_S1_INSTANCE_V0;
RETURN null;
END;
$$;
No returning information.
Problèmes connus¶
Examinez attentivement les curseurs imbriqués et les conditionnelles, si tel est le cas.
EWIs connexes ¶
Pas d’EWIs connexes.
REPEAT¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description ¶
L’instruction REPEAT
de Teradata est traduite dans la syntaxe de Snowflake Scripting REPEAT
.
Pour plus d’informations sur Teradata Repeat, cliquez ici.
[label_name:] REPEAT
{ sql_statement }
UNTIL conditional_expression
END REPEAT [label_name];
Échantillons de modèles de sources ¶
Teradata ¶
CREATE PROCEDURE repeatProcedure(OUT resultCounter INTEGER)
BEGIN
DECLARE counter INTEGER DEFAULT 0;
customeLabel: REPEAT
SET counter = counter + 1;
UNTIL 10 < counter
END REPEAT customeLabel;
SET resultCounter = counter;
END;
CALL repeatProcedure(:?);
|resultCounter|
|-------------|
|11 |
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE repeatProcedure (
-- OUT
RESULTCOUNTER INTEGER)
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
counter INTEGER DEFAULT 0;
BEGIN
REPEAT
counter := counter + 1;
UNTIL (10 < counter)
END REPEAT CUSTOMELABEL;
resultCounter := counter;
RETURN resultCounter;
END;
$$;
CALL repeatProcedure(:?);
|REPEATPROCEDURE|
|---------------|
|1 |
Problèmes connus ¶
Aucun problème n’a été constaté.
EWIs connexes ¶
Pas d’EWIs connexes.
SET¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description ¶
Affecte une valeur à une variable locale ou à un paramètre d’une procédure stockée.
Pour plus d’informations sur Teradata SET, cliquez ici.
SET assigment_target = assigment_source ;
Échantillons de modèles de sources ¶
Teradata ¶
CREATE PROCEDURE setExample ( OUT PARAM1 INTEGER )
BEGIN
DECLARE COL_COUNT INTEGER;
SET COL_COUNT = 3;
SET PARAM1 = COL_COUNT + 1;
END;
|PARAM1 |
|-------|
|4 |
Exécution de scripts Snowflake¶
CREATE OR REPLACE PROCEDURE setExample (
-- OUT
PARAM1 INTEGER )
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
COL_COUNT INTEGER;
BEGIN
COL_COUNT := 3;
PARAM1 := COL_COUNT + 1;
RETURN PARAM1;
END;
$$;
|PARAM1 |
|-------|
|4 |
Problèmes connus ¶
Aucun problème n’a été constaté.
EWIs connexes ¶
Pas d’EWIs connexes.
SYSTEM_DEFINED¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Note
Instruction non pertinente.
Avertissement
Remarquez que cette instruction est retirée de la migration parce qu’il s’agit d’une syntaxe non pertinente. Cela signifie qu’elle n’est pas exigée dans Snowflake.
Description¶
Propriété dans Teradata qui peut être après une instruction CREATE
dans des cas tels que JOIN INDEX
.
Modèles d’échantillons de sources¶
Notez que SYSTEM\_DEFINED a été supprimé du code source car il s’agit d’une syntaxe non pertinente dans Snowflake.
CREATE SYSTEM_DEFINED JOIN INDEX MY_TESTS.MYPARTS_TJI004 ,FALLBACK ,CHECKSUM = DEFAULT, MAP = TD_MAP1 AS
CURRENT TRANSACTIONTIME
SELECT
MY_TESTS.myParts.ROWID,
MY_TESTS.myParts.part_id,
MY_TESTS.part_duration
FROM MY_TESTS.myParts
UNIQUE PRIMARY INDEX (part_id);
--** SSC-FDM-0007 - MISSING DEPENDENT OBJECT "MY_TESTS.myParts" **
CREATE OR REPLACE DYNAMIC TABLE MY_TESTS.MYPARTS_TJI004
--** SSC-FDM-0031 - DYNAMIC TABLE REQUIRED PARAMETERS SET BY DEFAULT **
TARGET_LAG='1 day'
WAREHOUSE=UPDATE_DUMMY_WAREHOUSE
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/01/2024" }}'
AS
-- --** SSC-FDM-TD0025 - TEMPORAL FORMS ARE NOT SUPPORTED IN SNOWFLAKE **
-- CURRENT TRANSACTIONTIME
SELECT
MY_TESTS.myParts.ROWID,
MY_TESTS.myParts.part_id,
MY_TESTS.part_duration
FROM
MY_TESTS.myParts;
Problèmes connus ¶
Aucun problème n’a été constaté.
EWIs connexes¶
SSC-FDM-0007 : Élément avec des dépendances manquantes.
SSC-FDM-TD0025 : La table temporelle de la base de données Teradata n’est pas prise en charge par Snowflake.
SSC-FDM-0031 : Paramètres requis de la table dynamique définis par défaut
WHILE¶
Note
Certaines parties du code de sortie sont omises pour des raisons de clarté.
Description ¶
L’instruction WHILE
de Teradata est traduite dans la syntaxe de Snowflake ScriptingWHILE
.
Pour plus d’informations sur Teradata While, cliquez ici.
[label_name:] WHILE conditional_expression DO
{ sql_statement }
END WHILE [label_name];
Modèles d’échantillons de sources¶
Teradata¶
REPLACE PROCEDURE whileProcedure(OUT resultCounter INTEGER)
BEGIN
DECLARE counter INTEGER DEFAULT 0;
customeLabel: WHILE counter < 10 DO
SET counter = counter + 1;
END WHILE customeLabel;
SET resultCounter = counter;
END;
CALL whileProcedure(:?);
|resultCounter|
|-------------|
|10 |
Snowflake Scripting ¶
CREATE OR REPLACE PROCEDURE whileProcedure (
-- OUT
RESULTCOUNTER INTEGER)
RETURNS VARIANT
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "teradata", "convertedOn": "07/24/2024" }}'
EXECUTE AS CALLER
AS
$$
DECLARE
counter INTEGER DEFAULT 0;
BEGIN
WHILE ( counter < 10) LOOP
counter := counter + 1;
END LOOP CUSTOMELABEL;
resultCounter := counter;
RETURN resultCounter;
END;
$$;
CALL whileProcedure(:?);
|WHILEPROCEDURE|
|--------------|
|10 |
Problèmes connus ¶
Aucun problème n’a été constaté.
EWIs connexes ¶
Pas d’EWIs connexes.