SnowConvert AI – SQL Server – Azure Synapse – Allgemeine Sprachelemente¶

In diesem Abschnitt finden Sie Informationen über allgemeine Anweisungen von Transact-SQL.

COLLATE¶

Applies to

SQL Server
Azure Synapse Analytics

Die Transformation von Collate hängt von seinem Wert ab, da er unterstützt oder nicht unterstützt werden kann.

Derzeit sind dies die Sprachen, die für die Transformation unterstützt werden. Wenn sie in der Zusammenstellung gefunden werden, werden sie in ihre Snowflake-Entsprechung umgewandelt.


SQL Server	Snowflake
Latin1_General	EN
Modern_Spanish	ES
Französisch	FR

Wenn die Sprache nicht eine der oben genannten ist, wird die Sortierung (Collate) kommentiert.

The collate in SQL Server comes with additional specifications, such as CI, CS, AI, and AS. If there are additional specifications that are unsupported, they will be commented in the result.

Quelle¶

SELECT 'a' COLLATE Latin1_General_CI_AS;

SELECT 'a' COLLATE Modern_Spanish_CI_AS;

SELECT 'a' COLLATE French_CI_AS;

SELECT 'a' COLLATE Albanian_BIN;

SELECT 'a' COLLATE Latin1_General_CI_AS_WS;

SELECT 'a' COLLATE Latin1_General_CI_AS_KS_WS;

SELECT 'a' COLLATE Albanian_CI_AI;

Erwartet¶

SELECT 'a' COLLATE 'EN-CI-AS';

SELECT 'a' COLLATE 'ES-CI-AS';

SELECT 'a' COLLATE 'FR-CI-AS';

SELECT 'a'
--           !!!RESOLVE EWI!!! /*** SSC-EWI-TS0077 - COLLATION Albanian_BIN NOT SUPPORTED ***/!!!
-- COLLATE Albanian_BIN
                     ;

SELECT 'a' COLLATE 'EN-CI-AS' /*** SSC-FDM-TS0002 - COLLATION FOR VALUE WS NOT SUPPORTED ***/;

SELECT 'a' COLLATE 'EN-CI-AS' /*** SSC-FDM-TS0002 - COLLATION FOR VALUES KS,WS NOT SUPPORTED ***/;

SELECT 'a'
--           !!!RESOLVE EWI!!! /*** SSC-EWI-TS0077 - COLLATION Albanian_CI_AI NOT SUPPORTED ***/!!!
-- COLLATE Albanian_CI_AI
                       ;

Sehen wir uns ein Collate-Beispiel in einem Create Table an

Quelle¶

CREATE TABLE TABLECOLLATE
(
    COL1 VARCHAR COLLATE Latin1_General_CI_AS
);

Erwartet¶

CREATE OR REPLACE TABLE TABLECOLLATE
(
    COL1 VARCHAR COLLATE 'EN-CI-AS' /*** SSC-PRF-0002 - CASE INSENSITIVE COLUMNS CAN DECREASE THE PERFORMANCE OF QUERIES ***/
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"transact"}}'
;

Wie Sie sehen können, ist die Transformation von Collate innerhalb eines Selects oder einer Tabelle dieselbe.

COMPUTED COLUMN¶

Der berechnete Ausdruck konnte nicht transformiert werden.

Applies to

SQL Server
Azure Synapse Analytics

Beschreibung¶

Der Ausdruck einer berechneten Spalte konnte nicht umgewandelt werden.

Codebeispiel¶
Eingabecode:¶
CREATE TABLE [TestTable](
    [Col1] AS (CONVERT ([REAL], ExpressionValue))
);

Ausgabecode:¶
CREATE OR REPLACE TABLE TestTable (
    Col1 REAL AS (CAST(ExpressionValue AS REAL)) /*** SSC-FDM-TS0014 - COMPUTED COLUMN WAS TRANSFORMED TO ITS SNOWFLAKE EQUIVALENT, FUNCTIONAL EQUIVALENCE VERIFICATION PENDING. ***/
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"transact"}}'
;

Empfehlungen¶

Fügen Sie manuelle Änderungen an dem nicht transformierten Ausdruck hinzu.
Wenn Sie weitere Unterstützung benötigen, können Sie uns eine E-Mail an snowconvert-support@snowflake.com senden.

Zugehörige EWIs¶

[SSC-FDM-TS0014](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/sqlServerFDM. md#ssc-fdm-ts0014): Berechnete Spalte transformiert.

OUTER APPLY¶

Äquivalenzübersetzung der OUT APPLY-Anweisung.

Applies to

SQL Server
Azure Synapse Analytics

Bemerkung

Einige Teile des Ausgabecodes wurden aus Gründen der Übersichtlichkeit weggelassen.

Beschreibung¶

Wenn OUTER APPLY angegeben ist, wird für jede Zeile des linken Rowsets eine Zeile erzeugt, auch wenn der rechtsseitige Rowset-Ausdruck für diese Zeile ein leeres Rowset liefert. (OUTER APPLY-Definition)

Syntax¶

   Apply_Operator :=                                                                                   
       'CROSS' 'APPLY'
  |    'OUTER' 'APPLY'.

Snowflake-Äquivalenz¶

Trotz der nicht unterstützten Anweisung OUTER APPLY in Snowflake gibt es eine gleichwertige Anweisung, die LATERAL lautet. Daher wird die Übersetzung für die Anweisung durchgeführt, um die gleiche Funktionalität durch die Verwendung von alternativen Lösungen zu erhalten.

Dennoch gibt es für die Anweisung LATERAL in Snowflake zwei Varianten der Syntax. In der Tat wird in dieser speziellen Übersetzung die Variante INNER JOIN LATERAL verwendet.

Die INNER JOIN LATERAL Grammatik von Snowflake lautet wie folgt:

 SELECT ...
FROM <left_hand_table_expression> INNER JOIN LATERAL ( <inline_view> )
...

Bemerkung

<inline\view> darf kein Tabellenname sein.

Und die einzelne LATERAL-Anweisung wird unten angezeigt:

 SELECT ...
FROM <left_hand_table_expression>, LATERAL ( <inline_view> )
...

Beispielhafte Quelle¶

Das folgende Beispiel zeigt eine allgemeine Übersetzung zwischen OUTER APPLY und INNER JOIN LATERAL:

SQL Server¶

SELECT  p.ProjectName, e.ProjectName, e.FirstName
FROM Project p
OUTER APPLY (
    SELECT
        ProjectName,
        FirstName,
        LastName
    FROM Employees e
) e;

Ausgabe¶


p.ProjectName	e.ProjectName	FirstName
Projekt A	Projekt A	John
Projekt A	Projekt A	Jane
Projekt A	Projekt B	Michael
Projekt B	Projekt A	John
Projekt B	Projekt A	Jane
Projekt B	Projekt B	Michael
Projekt C	Projekt A	John
Projekt C	Projekt A	Jane
Projekt C	Projekt B	Michael

Snowflake¶

 SELECT
    p.ProjectName,
    e.ProjectName,
    e.FirstName
FROM
    Project p
    INNER JOIN
        LATERAL (
                   SELECT
                       ProjectName,
                       FirstName,
                       LastName
                   FROM
                       Employees e
               ) e;

Ausgabe¶


PROJECTNAME	PROJECTNAME_2	FIRSTNAME
Projekt A	Projekt A	John
Projekt A	Projekt A	Jane
Projekt A	Projekt B	Michael
Projekt B	Projekt A	John
Projekt B	Projekt A	Jane
Projekt B	Projekt B	Michael
Projekt C	Projekt A	John
Projekt C	Projekt A	Jane
Projekt C	Projekt B	Michael

Bekannte Probleme¶

Da die Übersetzung eine Äquivalenz aus der Eingabe ist, gibt es einige Beschränkungen.

TOP- und WHERE-Anweisungen lassen sich auf eine optimale Verhaltensweise überprüfen.
Ein Korrelationsname am Ende der Anweisung kann erforderlich sein. In Snowflake stellt die Abfrage kein Problem dar, wenn der Korrelationsname nicht in der Abfrage enthalten ist, aber die Funktionalität kann sich ändern und ist nicht Teil des akzeptierten Musters in SQL Server.

SQL Server¶

SELECT
    SATT.UNIVERSAL_NAME
FROM
SAMPLE_ATLAS AS SATT
OUTER APPLY (
    SELECT
        TOP 1 UNIVERSAL_NAME,
        INTERNATIONAL_NAME,
        CODE_IDENTIFIER
    FROM
        SAMPLE_GLOBE AS SG
    WHERE
        SG.GLOBE_KEY = SATT.MbrPersGenKey
    ORDER BY
        GLOBE_KEY
);

Übersetzungsausgabe¶

SELECT
            UNIVERSAL_NAME
FROM
            SAMPLE_ATLAS
            AS SATT
            OUTER APPLY
                        /*** MSC-ERROR - MSCCP0001 - THE FOLLOWING SUBQUERY MATCHES AT LEAST ONE OF THE PATTERNS CONSIDERED INVALID AND MAY PRODUCE COMPILATION ERRORS ***/ (SELECT TOP 1
                                                UNIVERSAL_NAME,
                                                INTERNATIONAL_NAME,
                                                CODE_IDENTIFIER
                                    FROM
                                                SAMPLE_GLOBE AS SG
                                    WHERE
                                                SG.GLOBE_KEY = SATT.MbrPersGenKey
                                    ORDER BY GLOBE_KEY
                        );

Bei bestimmten Anweisungen, die nicht unterstützt werden, kann der gesamte Blockcode auskommentiert werden (Beispiel aus: JSON-Beispiel).

SQL Server¶

SELECT
    SATT.UNIVERSAL_NAME
FROM
SAMPLE_ATLAS AS SATT
INNER JOIN LATERAL (
    SELECT
        TOP 1 UNIVERSAL_NAME,
        INTERNATIONAL_NAME,
        CODE_IDENTIFIER
    FROM
        SAMPLE_GLOBE AS SG
    WHERE
        SG.GLOBE_KEY = SATT.MbrPersGenKey
    ORDER BY
        GLOBE_KEY
);

Übersetzungsausgabe¶

SELECT
	familyName,
	c.givenName AS childGivenName,
	c.firstName AS childFirstName,
	p.givenName AS petName
FROM
	Families f
	LEFT OUTER JOIN
		OPENJSON(f.doc) /*** MSC-WARNING - MSCEWI4030 - Equivalence from CROSS APPLY to LEFT OUTER JOIN must be checked. ***/;
-- ** MSC-ERROR - MSCEWI1001 - UNRECOGNIZED TOKEN ON LINE 7 OF THE SOURCE CODE. **
--		WITH (familyName nvarchar(100), children nvarchar(max) AS JSON)
--		CROSS APPLY OPENJSON(children)
--		WITH (givenName nvarchar(100), firstName nvarchar(100), pets nvarchar(max) AS JSON) as c
--			OUTER APPLY OPENJSON (pets)
--			WITH (givenName nvarchar(100))  as p

Zugehörige EWIs¶

Keine zugehörigen EWIs.

USE¶

Snowflake-Äquivalenz der USE-Anweisung von Transact-SQL

Applies to

SQL Server

USE-Anweisung hat ihre eigene Entsprechung in Snowflake. Die Anweisung wird in die USE DATABASE-Anweisung in Snowflake übersetzt.

Beispiele für Übersetzungen¶

Quelle¶

USE [MY DATABASE]

Ausgabe¶

USE DATABASE "MY DATABASE";

Name der Datenbank¶

Der database name, der in der Anweisung USE angegeben ist, kann sich ändern, wenn er innerhalb von eckigen Klammern ([ ]) steht. Die erste und die letzte Klammer werden durch Anführungszeichen ersetzt. Beispiel:

Quelle¶

[MYDATABASE]
[[[MYDATABASE]]

Ausgabe¶

"MYDATABASE"
"[[MYDATABASE]"

Benutzerdefinierte Datenbank¶

Wenn ein Benutzer dem Konvertierungstool mit dem Parameter -d einen benutzerdefinierten Datenbanknamen angibt, der auf alle Objekte angewendet werden soll, und möchte, dass die USE Anweisungen transformiert werden, sollte der Datenbankname nur auf die USE-Anweisung und nicht auf die Objekte angewendet werden. Dadurch wird die in der USE-Anweisung angegebene Datenbank außer Kraft gesetzt. Beispiel:

Quelle¶

-- Additional Params: -d MYCUSTOMDB
USE [MY DATABASE]

CREATE TABLE [TableName1].[TableName2](
	[ColumnName1] varchar NULL
);

Ausgabe¶

-- Additional Params: -d MYCUSTOMDB
USE DATABASE MYCUSTOMDB;

CREATE OR REPLACE TABLE MYCUSTOMDB.TableName1.TableName2 (
	ColumnName1 VARCHAR NULL
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"transact"}}'
;

Bekannte Probleme¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

Keine zugehörigen EWIs.

EXECUTE¶

Applies to

SQL Server
Azure Synapse Analytics

Die Übersetzung für EXEC- oder EXECUTE-Anweisungen wird in Snowflake nicht unterstützt, aber sie wird in CALL-Anweisung übersetzt.

Bemerkung

Einige Teile des Ausgabecodes wurden aus Gründen der Übersichtlichkeit weggelassen.

Eingabe¶

Exec db.sp1

Ausgabe¶

CALL db.sp1();

Weitere Informationen zu EXECUTE finden Sie unter: EXECUTE in Prozeduren

PRINT¶

Applies to

SQL Server
Azure Synapse Analytics

Die Anweisung Print wird in Snowflake nicht direkt unterstützt, wird aber in ihr ähnlichstes Äquivalent übersetzt, die integrierte Funktion SYSTEM$LOG_INFO.

Eingabe¶

PRINT 'My message';

Ausgabe (innerhalb von SnowScript)¶

SYSTEM$LOG_INFO('My message');

Ausgabe (außerhalb von SnowScript)¶

Wenn die Anweisung Print außerhalb einer gespeicherten Prozedur verwendet wird, muss sie von einer SnowConvert AI UDP aus aufgerufen werden.

CALL PUBLIC.LOG_INFO_UDP('My message');

Bevor Sie mit der Protokollierung von Meldungen beginnen können, müssen Sie eine Ereignistabelle einrichten. Weitere Informationen finden Sie unter: Protokollierung von Meldungen in Snowflake Scripting

Gespeicherte Systemprozeduren¶

SP_EXECUTESQL¶

Übersetzungsspezifikation für die Systemprozedur SP_EXECUTESQL.

Applies to

SQL Server
Azure Synapse Analytics

Beschreibung¶

Die systemgespeicherte Prozedur SP_EXECUTESQL wird verwendet, um eine Transact-SQL-Anweisung oder einen Batch auszuführen, die bzw. der mehrmals wiederverwendet werden kann oder dynamisch erstellt wird. Die Anweisung oder der Batch kann eingebettete Parameter enthalten.

Diese Funktionalität kann in Snowflake über die EXECUTE IMMEDIATE-Anweisung und mit einer benutzerdefinierten Funktion (UDF) für eingebettete Parameter emuliert werden.#x20;

Weitere Informationen zu der benutzerdefinierten Funktion (UDF), die für diese Übersetzung verwendet werden, finden S ie unter TRANSFORM_SP_EXECUTE_SQL_STRING_UDF(STRING, STRING, ARRAY, ARRAY).

Syntax¶

Transact¶

 sp_executesql [ @stmt = ] N'statement'
[
    [ , [ @params = ] N'@parameter_name data_type [ { OUT | OUTPUT } ] [ , ...n ]' ]
    [ , [ @param1 = ] 'value1' [ , ...n ] ]
]

Beispielhafte Quellcode-Muster¶

Alle Muster wandeln SP_EXECUTESQL in die Anweisung EXECUTE IMMEDIATE von Snowflake um und ändern die auszuführende Zeichenfolge SQL nur, wenn Sie eingebettete Parameter verwenden.

Warnung

[SSC-EWI-0030](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/generalEWI. md#ssc-ewi-0030) (Verwendung von dynamischem SQL) wird für alle Muster hinzugefügt. Auch wenn die Übersetzung für SP_EXECUTESQL mit Snowflake übereinstimmt, zeigt EWI in diesem Zusammenhang an, dass die Zeichenfolge SQL möglicherweise manuell korrigiert werden muss, damit die Übersetzung wie vorgesehen ausgeführt werden kann.

Datenkonfiguration¶

Transact¶

 CREATE TABLE PERSONS(
  NAME VARCHAR(25),
  ID INT,
  AGE INT
);

-- DATA
INSERT INTO PERSONS VALUES ('John Smith', 1, 24);
INSERT INTO PERSONS VALUES ('John Doe', 2, 21);
INSERT INTO PERSONS VALUES ('Mary Keller', 3, 32);
INSERT INTO PERSONS VALUES ('Mundane Man', 4, 18);

Snowflake¶

 CREATE OR REPLACE TABLE PERSONS (
  NAME VARCHAR(25),
  ID INT,
  AGE INT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
;

-- DATA
INSERT INTO PERSONS VALUES ('John Smith', 1, 24);
INSERT INTO PERSONS VALUES ('John Doe', 2, 21);
INSERT INTO PERSONS VALUES ('Mary Keller', 3, 32);
INSERT INTO PERSONS VALUES ('Mundane Man', 4, 18);

Ohne eingebettete Parameter¶

Wenn keine eingebetteten Parameter verwendet werden, wird SP_EXECUTESQL in eine EXECUTE IMMEDIATE-Anweisung umgewandelt und die SQL-Zeichenfolge ohne Änderungen verwendet.

Transact¶

 CREATE PROCEDURE SIMPLE_SINGLE_QUERY
AS
BEGIN
    DECLARE @SQLString NVARCHAR(500);
    SET @SQLString = N'SELECT * FROM PERSONS';
    EXECUTE sp_executesql @SQLString;
END

GO

EXEC SIMPLE_SINGLE_QUERY;

Ergebnisse¶


Name	ID	AGE
John Smith	1	24
John Doe	2	21
Maria Keller	3	32
Mundane Mann	4	18

Snowflake¶

CREATE OR REPLACE PROCEDURE SIMPLE_SINGLE_QUERY ()
RETURNS TABLE()
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    SQLSTRING VARCHAR(500);
    ProcedureResultSet RESULTSET;
  BEGIN
     
    SQLSTRING := 'SELECT
   *
FROM
   PERSONS;';
    ProcedureResultSet := (
      !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
      EXECUTE IMMEDIATE :SQLSTRING
    );
    RETURN TABLE(ProcedureResultSet);
  END;
$$;

CALL SIMPLE_SINGLE_QUERY();

Ergebnisse¶


Name	ID	AGE
John Smith	1	24
John Doe	2	21
Maria Keller	3	32
Mundane Mann	4	18

Mit eingebetteten Parametern für die Datenbindung¶

Bei eingebetteten Parametern für die Datenbindung wird SP_EXECUTESQL in eine EXECUTE IMMEDIATE-Anweisung umgewandelt und die SQL-Zeichenfolge wird über die TRANSFORM_SP_EXECUTE_SQL_STRING_UDF geändert.#x20;

Das Ergebnis von EXECUTE IMMEDIATE wird der Variablen ProcedureResultSet zugewiesen und später als TABLE(ProcedureResultSet) zurückgegeben.

Transact¶

 CREATE PROCEDURE QUERY_WITH_DATA_BINDING_PARAMS
AS
BEGIN
    DECLARE @IntVariable INT;
    DECLARE @SQLString NVARCHAR(500);
    DECLARE @ParmDefinition NVARCHAR(500);

    SET @IntVariable = 21;
    SET @SQLString = N'SELECT * FROM PERSONS WHERE AGE = @age';
    SET @ParmDefinition = N'@age INT';
    EXECUTE sp_executesql @SQLString, @ParmDefinition, @age = @IntVariable;
END

GO

EXEC QUERY_WITH_DATA_BINDING_PARAMS;

Ergebnisse¶


Name	ID	AGE
John Doe	2	21

Snowflake¶

CREATE OR REPLACE PROCEDURE QUERY_WITH_DATA_BINDING_PARAMS ()
RETURNS TABLE()
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    INTVARIABLE INT;
    SQLSTRING VARCHAR(500);
    PARMDEFINITION VARCHAR(500);
    ProcedureResultSet RESULTSET;
  BEGIN
     
     
     
    INTVARIABLE := 21;
    SQLSTRING := 'SELECT
   *
FROM
   PERSONS
WHERE
   AGE = @age;';
    PARMDEFINITION := '@age INT';
    ProcedureResultSet := (
      !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
      EXECUTE IMMEDIATE TRANSFORM_SP_EXECUTE_SQL_STRING_UDF(:SQLSTRING, :PARMDEFINITION, ARRAY_CONSTRUCT('AGE'), ARRAY_CONSTRUCT(:INTVARIABLE))
    );
    RETURN TABLE(ProcedureResultSet);
  END;
$$;

CALL QUERY_WITH_DATA_BINDING_PARAMS();

Ergebnisse¶


Name	ID	AGE
John Doe	2	21

Mit eingebetteten OUTPUT-Parametern¶

Bei eingebetteten OUTPUT-Parametern wird SP_EXECUTESQL in eine EXECUTE IMMEDIATE-Anweisung umgewandelt, und die SQL-Zeichenfolge wird durch TRANSFORM_SP_EXECUTE_SQL_STRING_UDF geändert.

Zusätzlich wird ein SELECT $1, ..., $n INTO: outputParam1, ..., :outputParamN FROM TABLE(RESULT_SCAN(LAST_QUERY_ID())) zu dem Ergebnis jeder Spalte zu dem entsprechenden OUTPUT-Parameter hinzugefügt.

Warnung

SSC-FDM-TS0028 wird der Anweisung SELECT INTO hinzugefügt. Es ist wichtig, dass die Parameter in der INTO-Klausel in der gleichen Reihenfolge erscheinen, wie sie in der ursprünglichen SQL -Zeichenfolge zugewiesen wurden.

Andernfalls sind manuelle Änderungen erforderlich, um diese Anforderung zu erfüllen.

Transact¶

CREATE PROCEDURE QUERY_WITH_OUTPUT_PARAMS
AS
BEGIN
    DECLARE @SQLString NVARCHAR(500);
    DECLARE @ParamDefinition NVARCHAR(500);
    DECLARE @MaxAge INT;

    SET @SQLString = N'SELECT @MaxAgeOUT = max(AGE) FROM PERSONS';
    SET @ParamDefinition = N'@MaxAgeOUT INT OUTPUT';
    EXECUTE sp_executesql @SQLString, @ParamDefinition, @MaxAgeOUT = @MaxAge OUTPUT;

    SELECT @MaxAge;
END

GO

EXEC QUERY_WITH_OUTPUT_PARAMS;

Ergebnisse¶


<anonymous>
32

Snowflake¶

CREATE OR REPLACE PROCEDURE QUERY_WITH_OUTPUT_PARAMS ()
RETURNS TABLE()
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "11/27/2024",  "domain": "test" }}'
EXECUTE AS CALLER
AS
$$
    DECLARE
        SQLSTRING VARCHAR(500);
        PARAMDEFINITION VARCHAR(500);
        MAXAGE INT;
        ProcedureResultSet RESULTSET;
    BEGIN
         
         
         
        SQLSTRING := 'SELECT
   MAX(AGE) FROM
   PERSONS;';
        PARAMDEFINITION := '@MaxAgeOUT INT OUTPUT';
        !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
        EXECUTE IMMEDIATE TRANSFORM_SP_EXECUTE_SQL_STRING_UDF(:SQLSTRING, :PARAMDEFINITION, ARRAY_CONSTRUCT('MAXAGEOUT'), ARRAY_CONSTRUCT(:MAXAGE));
        --** SSC-FDM-TS0028 - OUTPUT PARAMETERS MUST HAVE THE SAME ORDER AS THEY APPEAR IN THE EXECUTED CODE **
        SELECT
            $1
        INTO
            :MAXAGE
        FROM
            TABLE(RESULT_SCAN(LAST_QUERY_ID()));
        ProcedureResultSet := (
        SELECT
            :MAXAGE);
        RETURN TABLE(ProcedureResultSet);
    END;
$$;

CALL QUERY_WITH_OUTPUT_PARAMS();

Ergebnisse¶


:MAXAGE::NUMBER(38,0)
32

Sowohl mit eingebetteten OUTPUT-Parametern als auch mit Datenbindung¶

Die Übersetzung ist dieselbe wie bei den OUTPUT-Parametern.

Transact¶

CREATE PROCEDURE QUERY_WITH_BOTH_PARAMS
AS
BEGIN
    DECLARE @AgeVariable INT;
    DECLARE @IdVariable INT;
    DECLARE @SQLString NVARCHAR(500);
    DECLARE @ParmDefinition NVARCHAR(500);
    DECLARE @MaxAge INT;
    DECLARE @MaxId INT;

    SET @AgeVariable = 30;
    SET @IdVariable = 100;
    SET @SQLString = N'SELECT @MaxAgeOUT = max(AGE), @MaxIdOut = max(ID) FROM PERSONS WHERE AGE < @age AND ID < @id;';
    SET @ParmDefinition = N'@age INT, @id INT, @MaxAgeOUT INT OUTPUT, @MaxIdOUT INT OUTPUT';
    EXECUTE sp_executesql @SQLString, @ParmDefinition, @age = @AgeVariable, @id = @IdVariable, @MaxAgeOUT = @MaxAge OUTPUT, @MaxIdOUT = @MaxId OUTPUT;

    SELECT @MaxAge, @MaxId;
END

GO

EXEC QUERY_WITH_BOTH_PARAMS;

Ergebnisse¶


<anonymous>	<anonymous>
24	4

Snowflake¶

CREATE OR REPLACE PROCEDURE QUERY_WITH_BOTH_PARAMS ()
RETURNS TABLE()
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    AGEVARIABLE INT;
    IDVARIABLE INT;
    SQLSTRING VARCHAR(500);
    PARMDEFINITION VARCHAR(500);
    MAXAGE INT;
    MAXID INT;
    ProcedureResultSet RESULTSET;
  BEGIN
     
     
     
     
     
     
    AGEVARIABLE := 30;
    IDVARIABLE := 100;
    SQLSTRING := 'SELECT
   MAX(AGE),
   MAX(ID) FROM
   PERSONS
WHERE
   AGE < @age AND ID < @id;';
    PARMDEFINITION := '@age INT, @id INT, @MaxAgeOUT INT OUTPUT, @MaxIdOUT INT OUTPUT';
    !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
    EXECUTE IMMEDIATE TRANSFORM_SP_EXECUTE_SQL_STRING_UDF(:SQLSTRING, :PARMDEFINITION, ARRAY_CONSTRUCT('AGE', 'ID', 'MAXAGEOUT', 'MAXIDOUT'), ARRAY_CONSTRUCT(:AGEVARIABLE, :IDVARIABLE, :MAXAGE, :MAXID));
    --** SSC-FDM-TS0028 - OUTPUT PARAMETERS MUST HAVE THE SAME ORDER AS THEY APPEAR IN THE EXECUTED CODE **
    SELECT
      $1,
      $2
    INTO
      :MAXAGE,
      :MAXID
    FROM
      TABLE(RESULT_SCAN(LAST_QUERY_ID()));
    ProcedureResultSet := (
    SELECT
      :MAXAGE,
      :MAXID);
    RETURN TABLE(ProcedureResultSet);
  END;
$$;

CALL QUERY_WITH_BOTH_PARAMS();

Ergebnisse¶


:MAXAGE::NUMBER(38,0)	:MAXID::NUMBER(38,0)
24	4

Parameter nicht in der Reihenfolge der Definition¶

Dieses Muster folgt den gleichen Regeln wie die vorherigen Muster. TRANSFORM_SP_EXECUTE_SQL_STRING_UDF ersetzt die Parameterwerte in der richtigen Reihenfolge.

Transact¶

CREATE PROCEDURE QUERY_PARAMS_NOT_IN_ORDER_OF_DEF
AS
BEGIN
    DECLARE @AgeVariable INT;
    DECLARE @IdVariable INT;
    DECLARE @SQLString NVARCHAR(500);
    DECLARE @ParmDefinition NVARCHAR(500);
    DECLARE @MaxAge INT;
    DECLARE @MaxId INT;

    SET @AgeVariable = 30;
    SET @IdVariable = 100;
    SET @SQLString = N'SELECT @MaxAgeOUT = max(AGE), @MaxIdOut = max(ID) FROM PERSONS WHERE AGE < @age AND ID < @id;';
    SET @ParmDefinition = N'@age INT, @id INT, @MaxAgeOUT INT OUTPUT, @MaxIdOUT INT OUTPUT';
    EXECUTE sp_executesql @SQLString, @ParmDefinition, @id = @IdVariable, @MaxAgeOUT = @MaxAge OUTPUT, @age = @AgeVariable, @MaxIdOUT = @MaxId OUTPUT;

    SELECT @MaxAge, @MaxId;
END

GO

EXEC QUERY_PARAMS_NOT_IN_ORDER_OF_DEF;

CREATE PROCEDURE QUERY_PARAMS_NOT_IN_ORDER_OF_DEF_2
AS
BEGIN
    DECLARE @AgeVariable INT;
    DECLARE @IdVariable INT;
    DECLARE @SQLString NVARCHAR(500);
    DECLARE @ParmDefinition NVARCHAR(500);
    DECLARE @MaxAge INT;
    DECLARE @MaxId INT;

    SET @AgeVariable = 30;
    SET @IdVariable = 100;
    SET @SQLString = N'SELECT @MaxAgeOUT = max(AGE), @MaxIdOut = max(ID) FROM PERSONS WHERE AGE < @age AND ID < @id;';
    SET @ParmDefinition = N'@age INT, @id INT, @MaxAgeOUT INT OUTPUT, @MaxIdOUT INT OUTPUT';
    EXECUTE sp_executesql @SQLString, @ParmDefinition, @AgeVariable, @MaxAgeOUT = @MaxAge OUTPUT, @id = @IdVariable, @MaxIdOUT = @MaxId OUTPUT;

    SELECT @MaxAge, @MaxId;
END

GO

EXEC QUERY_PARAMS_NOT_IN_ORDER_OF_DEF_2;

Ergebnisse¶


<anonymous>	<anonymous>
24	4


<anonymous>	<anonymous>
24	4

Snowflake¶

CREATE OR REPLACE PROCEDURE QUERY_PARAMS_NOT_IN_ORDER_OF_DEF ()
RETURNS TABLE()
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    AGEVARIABLE INT;
    IDVARIABLE INT;
    SQLSTRING VARCHAR(500);
    PARMDEFINITION VARCHAR(500);
    MAXAGE INT;
    MAXID INT;
    ProcedureResultSet RESULTSET;
  BEGIN
     
    AGEVARIABLE := 30;
    IDVARIABLE := 100;
    SQLSTRING := 'SELECT
   MAX(AGE),
   MAX(ID) FROM
   PERSONS
WHERE
   AGE < @age AND ID < @id;';
    PARMDEFINITION := '@age INT, @id INT, @MaxAgeOUT INT OUTPUT, @MaxIdOUT INT OUTPUT';
    !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
    EXECUTE IMMEDIATE TRANSFORM_SP_EXECUTE_SQL_STRING_UDF(:SQLSTRING, :PARMDEFINITION, ARRAY_CONSTRUCT('ID', 'MAXAGEOUT', 'AGE', 'MAXIDOUT'), ARRAY_CONSTRUCT(:IDVARIABLE, :MAXAGE, :AGEVARIABLE, :MAXID));
    --** SSC-FDM-TS0028 - OUTPUT PARAMETERS MUST HAVE THE SAME ORDER AS THEY APPEAR IN THE EXECUTED CODE **
    SELECT
      $1,
      $2
    INTO
      :MAXAGE,
      :MAXID
    FROM
      TABLE(RESULT_SCAN(LAST_QUERY_ID()));
    ProcedureResultSet := (
    SELECT
      :MAXAGE,
      :MAXID);
    RETURN TABLE(ProcedureResultSet);
  END;
$$;

CALL QUERY_PARAMS_NOT_IN_ORDER_OF_DEF();

CREATE OR REPLACE PROCEDURE QUERY_PARAMS_NOT_IN_ORDER_OF_DEF_2 ()
RETURNS TABLE()
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    AGEVARIABLE INT;
    IDVARIABLE INT;
    SQLSTRING VARCHAR(500);
    PARMDEFINITION VARCHAR(500);
    MAXAGE INT;
    MAXID INT;
    ProcedureResultSet RESULTSET;
  BEGIN
     
     
     
     
     
     
    AGEVARIABLE := 30;
    IDVARIABLE := 100;
    SQLSTRING := 'SELECT
   MAX(AGE),
   MAX(ID) FROM
   PERSONS
WHERE
   AGE < @age AND ID < @id;';
    PARMDEFINITION := '@age INT, @id INT, @MaxAgeOUT INT OUTPUT, @MaxIdOUT INT OUTPUT';
    !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
    EXECUTE IMMEDIATE TRANSFORM_SP_EXECUTE_SQL_STRING_UDF(:SQLSTRING, :PARMDEFINITION, ARRAY_CONSTRUCT('', 'MAXAGEOUT', 'ID', 'MAXIDOUT'), ARRAY_CONSTRUCT(:AGEVARIABLE, :MAXAGE, :IDVARIABLE, :MAXID));
    --** SSC-FDM-TS0028 - OUTPUT PARAMETERS MUST HAVE THE SAME ORDER AS THEY APPEAR IN THE EXECUTED CODE **
    SELECT
      $1,
      $2
    INTO
      :MAXAGE,
      :MAXID
    FROM
      TABLE(RESULT_SCAN(LAST_QUERY_ID()));
    ProcedureResultSet := (
    SELECT
      :MAXAGE,
      :MAXID);
    RETURN TABLE(ProcedureResultSet);
  END;
$$;

CALL QUERY_PARAMS_NOT_IN_ORDER_OF_DEF_2();

Ergebnisse¶


:MAXAGE::NUMBER(38,0)	:MAXID::NUMBER(38,0)
24	4


:MAXAGE::NUMBER(38,0)	:MAXID::NUMBER(38,0)
24	4

Direkte Werte ausführen¶

This translation also handles the cases where the values are directly assigned instead of using variables.

Transact¶

CREATE PROCEDURE QUERY_WITH_DIRECT_PARAMS_VALUES_ALL
AS
BEGIN
    DECLARE @MaxAge INT;
    DECLARE @MaxId INT;

    EXECUTE sp_executesql
        N'SELECT @MaxAgeOUT = max(AGE), @MaxIdOut = max(ID) FROM PERSONS WHERE ID < @id AND AGE < @age;',
        N'@age INT, @id INT, @MaxAgeOUT INT OUTPUT, @MaxIdOUT INT OUTPUT',
        30,
        100,
        @MaxAge OUTPUT,
        @MaxId OUTPUT;

    SELECT @MaxAge, @MaxId;
END

GO

EXEC QUERY_WITH_DIRECT_PARAMS_VALUES_ALL;

Ergebnisse¶


<anonymous>	<anonymous>
24	4

Snowflake¶

CREATE OR REPLACE PROCEDURE QUERY_WITH_DIRECT_PARAMS_VALUES_ALL ()
RETURNS TABLE()
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/07/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    MAXAGE INT;
    MAXID INT;
    ProcedureResultSet RESULTSET;
  BEGIN
     
     
    !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
    EXECUTE IMMEDIATE TRANSFORM_SP_EXECUTE_SQL_STRING_UDF('SELECT
   MAX(AGE),
   MAX(ID) FROM
   PERSONS
WHERE
   ID < @id AND AGE < @age;', '@age INT, @id INT, @MaxAgeOUT INT OUTPUT, @MaxIdOUT INT OUTPUT', ARRAY_CONSTRUCT('', '', '', ''), ARRAY_CONSTRUCT(
    30,
    100, :MAXAGE, :MAXID));
    --** SSC-FDM-TS0028 - OUTPUT PARAMETERS MUST HAVE THE SAME ORDER AS THEY APPEAR IN THE EXECUTED CODE **
    SELECT
      $1,
      $2
    INTO
      :MAXAGE,
      :MAXID
    FROM
      TABLE(RESULT_SCAN(LAST_QUERY_ID()));
    ProcedureResultSet := (
    SELECT
      :MAXAGE,
      :MAXID);
    RETURN TABLE(ProcedureResultSet);
  END;
$$;

CALL QUERY_WITH_DIRECT_PARAMS_VALUES_ALL();

Ergebnisse¶


:MAXAGE::NUMBER(38,0)	:MAXID::NUMBER(38,0)
24	4

SQL-Zeichenfolge dynamisch aufgebaut¶

Dieses Muster folgt den gleichen Regeln wie die vorherigen Muster. Die Zuweisung des Ergebnisses der EXECUTE IMMEDIATE-Anweisung wird jedoch möglicherweise nicht hinzugefügt, wenn es sich bei der Zeichenfolge SQL nicht um eine einfache Abfrage mit oder ohne eingebettete Parameter handelt.

Darüber hinaus muss die SQL-Zeichenfolge mit dem Literalwert 'SELECT' beginnen, damit SnowConvert AI korrekt identifizieren kann, dass eine SELECT-Anweisung ausgeführt wird.

Transact¶

CREATE PROCEDURE DYNAMIC_WITH_PARAMS
AS
BEGIN
    DECLARE @IntVariable INT;
    DECLARE @SQLString NVARCHAR(500);
    DECLARE @ParmDefinition NVARCHAR(500);
    DECLARE  @where_clause nvarchar(100);

    SET @where_clause = 'WHERE AGE = @age';
    SET @IntVariable = 21;
    SET @SQLString = N'SELECT * FROM PERSONS ' + @where_clause;
    SET @ParmDefinition = N'@age INT';
    EXECUTE sp_executesql @SQLString, @ParmDefinition, @age = @IntVariable;
END

GO

EXEC DYNAMIC_WITH_PARAMS;

Ergebnisse¶


Name	ID	AGE
John Doe	2	21

Snowflake¶

CREATE OR REPLACE PROCEDURE DYNAMIC_WITH_PARAMS ()
RETURNS TABLE()
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    INTVARIABLE INT;
    SQLSTRING VARCHAR(500);
    PARMDEFINITION VARCHAR(500);
    WHERE_CLAUSE VARCHAR(100);
    ProcedureResultSet RESULTSET;
  BEGIN
     
     
     
     
    WHERE_CLAUSE := 'WHERE AGE = @age';
    INTVARIABLE := 21;
    SQLSTRING := 'SELECT
   *
FROM
   PERSONS ' || :WHERE_CLAUSE || ';';
    PARMDEFINITION := '@age INT';
    ProcedureResultSet := (
      !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
      EXECUTE IMMEDIATE TRANSFORM_SP_EXECUTE_SQL_STRING_UDF(:SQLSTRING, :PARMDEFINITION, ARRAY_CONSTRUCT('AGE'), ARRAY_CONSTRUCT(:INTVARIABLE))
    );
    RETURN TABLE(ProcedureResultSet);
  END;
$$;

CALL DYNAMIC_WITH_PARAMS();

Ergebnisse¶


Name	ID	AGE
John Doe	2	21

Mehrere Resultsets zurückgeben¶

Bei Snowflake Scripting-Prozeduren kann nur ein Resultset pro Prozedur zurückgegeben werden.

Um die Verhaltensweise von Transact-SQL zu replizieren, werden zwei oder mehr Resultsets, die zurückgegeben werden sollen, in temporären Tabellen gespeichert. Die Snowflake Scripting-Prozedur gibt ein Array mit den Namen der temporären Tabellen zurück. Weitere Informationen finden Sie unter [SSC-FDM-0020](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0020).

Transact¶

CREATE PROCEDURE WITH_MULTIPLE_RETURNS
AS
BEGIN
    DECLARE @SQLString NVARCHAR(500);
    DECLARE @ParmDefinition NVARCHAR(500);

    SET @SQLString = N'SELECT * FROM PERSONS WHERE AGE = @age';
    SET @ParmDefinition = N'@age INT';
    EXECUTE sp_executesql @SQLString, @ParmDefinition, @age = 21;

    SET @SQLString = N'INSERT INTO PERSONS VALUES (''INSERT FIRST'', 1200, 230);';
    EXECUTE sp_executesql @SQLString;

    SET @SQLString = N'SELECT * FROM PERSONS';
    EXECUTE sp_executesql @SQLString;
END

GO

EXECUTE WITH_MULTIPLE_RETURNS;

Ergebnisse¶


Name	ID	AGE
John Doe	2	21


Name	ID	AGE
John Smith	1	24
John Doe	2	21
Maria Keller	3	32
Mundane Mann	4	18
INSERT FIRST	1200	230

Snowflake¶

CREATE OR REPLACE PROCEDURE WITH_MULTIPLE_RETURNS ()
RETURNS ARRAY
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/07/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    SQLSTRING VARCHAR(500);
    PARMDEFINITION VARCHAR(500);
    ProcedureResultSet1 VARCHAR;
    ProcedureResultSet2 VARCHAR;
    return_arr ARRAY := array_construct();
  BEGIN
     
     
    SQLSTRING := 'SELECT
   *
FROM
   PERSONS
WHERE
   AGE = @age;';
    PARMDEFINITION := '@age INT';
    ProcedureResultSet1 := 'RESULTSET_' || REPLACE(UPPER(UUID_STRING()), '-', '_');
    !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
    EXECUTE IMMEDIATE TRANSFORM_SP_EXECUTE_SQL_STRING_UDF(:SQLSTRING, :PARMDEFINITION, ARRAY_CONSTRUCT('AGE'), ARRAY_CONSTRUCT(21));
    CREATE OR REPLACE TEMPORARY TABLE IDENTIFIER(:ProcedureResultSet1) AS
      SELECT
        *
      FROM
        TABLE(RESULT_SCAN(LAST_QUERY_ID()));
    return_arr := array_append(return_arr, :ProcedureResultSet1);
    SQLSTRING := 'INSERT INTO PERSONS VALUES ('INSERT FIRST', 1200, 230);';
    !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
    EXECUTE IMMEDIATE :SQLSTRING;
    SQLSTRING := 'SELECT
   *
FROM
   PERSONS;';
    ProcedureResultSet2 := 'RESULTSET_' || REPLACE(UPPER(UUID_STRING()), '-', '_');
    !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
    EXECUTE IMMEDIATE :SQLSTRING;
    CREATE OR REPLACE TEMPORARY TABLE IDENTIFIER(:ProcedureResultSet2) AS
      SELECT
        *
      FROM
        TABLE(RESULT_SCAN(LAST_QUERY_ID()));
    return_arr := array_append(return_arr, :ProcedureResultSet2);
    --** SSC-FDM-0020 - MULTIPLE RESULT SETS ARE RETURNED IN TEMPORARY TABLES **
    RETURN return_arr;
  END;
$$;

CALL WITH_MULTIPLE_RETURNS();

Ergebnisse¶


WITH_MULTIPLE_RETURNS
[ „RESULTSET_88C35D7A_1E5B_455D_97A4_247806E583A5“, „RESULTSET_B2345B61_A015_43CB_BA11_6D3E013EF262“ ]

Bekannte Probleme¶

1. Invalid code is detected¶

SP_EXECUTESQL kann mehr als eine SQL-Anweisung innerhalb der SQL-Zeichenfolge ausführen. Snowflake unterstützt auch die Ausführung mehrerer SQL-Anweisungen, die aber in einen BEGIN ... END-Block eingeschlossen sein müssen. Außerdem gibt EXECUTE IMMEDIATE bei der Ausführung mehrerer Anweisungen von einem BEGIN ... END-Block kein Resultset zurück. Die Übersetzung für diese Fälle wird momentan noch nicht von SnowConvert AI unterstützt. Weitere Informationen dazu finden Sie unter SSC-EWI-0030.

Wenn also dieser Fall erkannt wird, wird im übersetzten Code EXECUTE IMMEDIATE nicht ProcedureResultSet zugewiesen.

Transact¶

CREATE PROCEDURE WITH_INVALID_CODE_DETECTED
AS
BEGIN
    DECLARE @SQLString NVARCHAR(500);
    SET @SQLString = N'INSERT INTO PERSONS VALUES (''INSERT FIRST'', 1200, 230); SELECT * FROM PERSONS;';
    EXECUTE sp_executesql @SQLString;
END

GO

EXEC WITH_INVALID_CODE_DETECTED;

Ergebnisse¶


Name	ID	AGE
John Smith	1	24
John Doe	2	21
Maria Keller	3	32
Mundane Mann	4	18
INSERT FIRST	1200	230

Snowflake¶

CREATE OR REPLACE PROCEDURE WITH_INVALID_CODE_DETECTED ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    SQLSTRING VARCHAR(500);
  BEGIN
     
    SQLSTRING := 'INSERT INTO PERSONS VALUES ('INSERT FIRST', 1200, 230); SELECT
   *
FROM
   PERSONS;';
    !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
    EXECUTE IMMEDIATE :SQLSTRING;
  END;
$$;

CALL WITH_INVALID_CODE_DETECTED();

Ergebnisse¶

000006 (0A000): Uncaught exception of type 'STATEMENT_ERROR' on line 10 at position 4 : Multiple SQL statements in a single API call are not supported; use one API call per statement instead.

2. Valid or Invalid code is not detected¶

Wenn die SQL-Zeichenfolge dynamisch durch Verkettungen erstellt wird, erkennt SnowConvert AI möglicherweise nicht, welche Anweisung ausgeführt werden soll. Daher wird EXECUTE IMMEDIATE im übersetzten Code nicht dem ProcedureResultSet zugewiesen.

Transact¶

CREATE PROCEDURE WITH_INVALID_CODE_NOT_DETECTED
AS
BEGIN
    DECLARE @SQLString NVARCHAR(500);
    DECLARE @SQLInsert NVARCHAR(500);
    SET @SQLInsert = N'INSERT INTO PERSONS VALUES (''INSERT FIRST'', 1200, 230)';
    SET @SQLString = @SQLInsert + N'SELECT * FROM PERSONS;';
    EXECUTE sp_executesql @SQLString;
END

GO

EXEC WITH_INVALID_CODE_NOT_DETECTED;

Ergebnisse¶


Name	ID	AGE
John Smith	1	24
John Doe	2	21
Maria Keller	3	32
Mundane Mann	4	18
INSERT FIRST	1200	230

Snowflake¶

CREATE OR REPLACE PROCEDURE WITH_INVALID_CODE_NOT_DETECTED ()
RETURNS VARCHAR
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    SQLSTRING VARCHAR(500);
    SQLINSERT VARCHAR(500);
  BEGIN
     
     
    SQLINSERT := 'INSERT INTO PERSONS VALUES ('INSERT FIRST', 1200, 230);';
    SQLSTRING := :SQLINSERT || 'SELECT * FROM PERSONS;';
    !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
    EXECUTE IMMEDIATE :SQLSTRING;
  END;
$$;

CALL WITH_INVALID_CODE_NOT_DETECTED();

Ergebnisse¶

000006 (0A000): Uncaught exception of type 'STATEMENT_ERROR' on line 10 at position 4 : Multiple SQL statements in a single API call are not supported; use one API call per statement instead.

3. Invalid code is mistaken as valid¶

Wenn der SQL-Zeichenfolge mit einer SELECT-Anweisung beginnt und weitere Anweisungen folgen, erkennt SnowConvert AI dies als gültigen Code und versucht, das Ergebnis von EXECUTE IMMEDIATE zum ProcedureResultSet zuzuordnen. Dies führt zu einem Kompilierungsfehler. Weitere Informationen dazu finden Sie unter SSC-EWI-0030.

Transact¶

CREATE PROCEDURE WITH_INVALID_CODE_MISTAKEN_AS_VALID
AS
BEGIN
    DECLARE @SQLString NVARCHAR(500);
    SET @SQLString = N'SELECT * FROM PERSONS; SELECT * FROM PERSONS;';
    EXECUTE sp_executesql @SQLString;
END

GO

EXEC WITH_INVALID_CODE_MISTAKEN_AS_VALID;

Ergebnisse¶


Name	ID	AGE
John Smith	1	24
John Doe	2	21
Maria Keller	3	32
Mundane Mann	4	18


Name	ID	AGE
John Smith	1	24
John Doe	2	21
Maria Keller	3	32
Mundane Mann	4	18

Snowflake¶

CREATE OR REPLACE PROCEDURE WITH_INVALID_CODE_MISTAKEN_AS_VALID ()
RETURNS TABLE()
LANGUAGE SQL
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "transact",  "convertedOn": "10/04/2024" }}'
EXECUTE AS CALLER
AS
$$
  DECLARE
    SQLSTRING VARCHAR(500);
    ProcedureResultSet RESULTSET;
  BEGIN
     
    SQLSTRING := 'SELECT
   *
FROM
   PERSONS; SELECT
   *
FROM
   PERSONS;';
    ProcedureResultSet := (
      !!!RESOLVE EWI!!! /*** SSC-EWI-0030 - THE STATEMENT BELOW HAS USAGES OF DYNAMIC SQL. ***/!!!
      EXECUTE IMMEDIATE :SQLSTRING
    );
    RETURN TABLE(ProcedureResultSet);
  END;
$$;

CALL WITH_INVALID_CODE_MISTAKEN_AS_VALID();

Ergebnisse¶

000006 (0A000): Uncaught exception of type 'STATEMENT_ERROR' on line 10 at position 4 : Multiple SQL statements in a single API call are not supported; use one API call per statement instead.

Zugehörige EWIs¶

[SSC-EWI-0030](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/generalEWI. md#ssc-ewi-0030): Die folgende Anweisung enthält dynamische SQL-Verwendungen
[SSC-FDM-TS0028](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/sqlServerFDM. md#ssc-fdm-ts0028): Die Ausgabeparameter müssen die gleiche Reihenfolge haben, wie sie im ausgeführten Code erscheinen.
[SSC-FDM-0020](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0020): Mehrere Resultsets werden in temporären Tabellen zurückgegeben.

SP_RENAME¶

Stored Procedure to Rename certain objects in SQL Server

Applies to

SQL Server
Azure Synapse Analytics

Die SP_RENAME-Speicherprozedur des Systems kann in bestimmten Szenarien in Snowflake emuliert werden. Im Allgemeinen ist das Äquivalent EXECUTE IMMEDIATE unter Verwendung einer dynamischen Anweisung mit ALTER TABLE und den ursprünglichen Parametern.

Übersetzungsbeispiele für Tabellen¶

Quelle¶

EXEC sp_rename 'TABLE1', 'TABLENEW1'

Ausgabe¶

EXECUTE IMMEDIATE 'ALTER TABLE TABLE1 RENAME TO TABLENEW1';

Quelle¶

DECLARE @varname1 nvarchar(50) = 'previous_name'
DECLARE @varname2 nvarchar(50) = 'newer_name'
EXEC sp_rename @varname1, @varname2

Ausgabe¶

DECLARE
VARNAME1 VARCHAR(50) := 'previous_name';
VARNAME2 VARCHAR(50) := 'newer_name';
BEGIN
EXECUTE IMMEDIATE 'ALTER TABLE ' || :VARNAME1 || ' RENAME TO ' || :VARNAME2;
END;

Übersetzungsbeispiele für Spalten¶

Quelle¶

EXEC sp_rename 'sample_BACKUP_2.column_old', 'column_new', 'COLUMN'
EXEC sp_rename 'database1.sample_BACKUP_3.column_old', 'column_new', 'COLUMN'

Ausgabe¶

EXECUTE IMMEDIATE 'ALTER TABLE sample_BACKUP_2 RENAME COLUMN column_old TO column_new';

EXECUTE IMMEDIATE 'ALTER TABLE database1.sample_BACKUP_3 RENAME COLUMN column_old TO column_new';

Quelle¶

DECLARE @oldColumnName nvarchar(50) = 'previous_name'
DECLARE @newColumnName nvarchar(50) = 'newer_name'
DECLARE @tableName nvarchar(50) = 'TABLE'
EXEC sp_rename @objname = @tableName + '.' + @oldColumnName, @newname = @newColumnName, @objtype = 'COLUMN';

Ausgabe¶

DECLARE
OLDCOLUMNNAME VARCHAR(50) := 'previous_name';
NEWCOLUMNNAME VARCHAR(50) := 'newer_name';
TABLENAME VARCHAR(50) := 'TABLE';
BEGIN
!!!RESOLVE EWI!!! /*** SSC-EWI-TS0075 - TRANSLATION FOR BUILT-IN PROCEDURE 'SP_RENAME' IS NOT CURRENTLY SUPPORTED. ***/!!!
EXEC sp_rename OBJNAME = :TABLENAME || '.' || :OLDCOLUMNNAME, NEWNAME = :NEWCOLUMNNAME, OBJTYPE = 'COLUMN';
END;

Zugehörige EWIs¶

[SSC-EWI-TS0075](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/sqlServerEWI. md#ssc-ewi-ts0075): Übersetzung für integrierte Prozedur wird derzeit nicht unterstützt.

WAITFOR DELAY¶

Applies to

SQL Server
Azure Synapse Analytics

Beschreibung¶

In SQL Server, WAITFOR DELAY pauses execution for a specified duration. SnowConvert AI transforms WAITFOR DELAY statements to Snowflake’s CALL SYSTEM$WAIT() function, which provides equivalent delay functionality.

The time string is parsed and converted to seconds (or milliseconds for sub-second precision). Variables and parameters are passed through directly with an EWI warning, since SYSTEM$WAIT expects a numeric value rather than a time string.

Bemerkung

WAITFOR TIME (which pauses until a specific time of day) has no Snowflake equivalent and remains flagged with SSC-EWI-0073.

Beispiele für Übersetzungen¶

WAITFOR DELAY with literal time¶

Eingabecode:¶

 CREATE PROCEDURE proc1()
AS
BEGIN
  WAITFOR DELAY '00:00:30';
END

Generated Code:¶

 CREATE OR REPLACE PROCEDURE proc1 ()
RETURNS VARCHAR
LANGUAGE SQL
EXECUTE AS CALLER
AS
$$
  BEGIN
    CALL SYSTEM$WAIT(30);
  END;
$$;

WAITFOR DELAY with sub-second precision¶

Eingabecode:¶

 CREATE PROCEDURE proc1()
AS
BEGIN
  WAITFOR DELAY '00:00:00.500';
END

Generated Code:¶

 CREATE OR REPLACE PROCEDURE proc1 ()
RETURNS VARCHAR
LANGUAGE SQL
EXECUTE AS CALLER
AS
$$
  BEGIN
    CALL SYSTEM$WAIT(500, 'MILLISECONDS');
  END;
$$;

WAITFOR DELAY with variable¶

Eingabecode:¶

 CREATE PROCEDURE proc1(@WaitTime INT)
AS
BEGIN
  WAITFOR DELAY @WaitTime;
END

Generated Code:¶

 CREATE OR REPLACE PROCEDURE proc1 (WAITTIME INT)
RETURNS VARCHAR
LANGUAGE SQL
EXECUTE AS CALLER
AS
$$
  BEGIN
    !!!RESOLVE EWI!!! /*** SSC-EWI-TS0094 - WAITFOR DELAY WITH VARIABLE ':WAITTIME' WAS CONVERTED TO SYSTEM$WAIT, BUT THE VARIABLE MAY CONTAIN A TIME STRING IN 'HH:MM:SS' FORMAT. SYSTEM$WAIT EXPECTS A NUMERIC VALUE IN SECONDS. ***/!!!
    CALL SYSTEM$WAIT(:WAITTIME);
  END;
$$;

WAITFOR DELAY at script level¶

Eingabecode:¶

 WAITFOR DELAY '00:00:30';

Generated Code:¶

 CALL SYSTEM$WAIT(30);

Known Limitations¶

WAITFOR TIME (pause until a specific time of day) has no Snowflake equivalent and is flagged with SSC-EWI-0073.
When a variable is used, SSC-EWI-TS0094 is emitted because SYSTEM$WAIT expects a numeric value but the variable may contain a time string in 'HH:MM:SS' format.

Zugehörige EWIs¶

SSC-EWI-TS0094: WAITFOR DELAY variable may contain a time string incompatible with SYSTEM$WAIT.
SSC-EWI-0073: Pending functional equivalence review (emitted for WAITFOR TIME).

CREATE STATISTICS¶

Applies to

SQL Server
Azure Synapse Analytics

Beschreibung¶

SnowConvert AI comments out CREATE STATISTICS statements because Snowflake automatically collects optimizer statistics and does not require this statement.

Translation Example¶

Eingabecode:¶

CREATE STATISTICS Stats1 ON dbo.Table1(col1);

Generated Code:¶

----** SSC-FDM-0037 - CREATE STATISTICS NOT NEEDED. SNOWFLAKE AUTOMATICALLY COLLECTS STATISTICS. **
--CREATE STATISTICS Stats1 ON dbo.Table1 (
--  col1
--);

Additional Example¶

Eingabecode:¶

CREATE STATISTICS NamePurchase ON AdventureWorks2022.Person.Person(BusinessEntityID, EmailPromotion) WITH FULLSCAN, NORECOMPUTE;

Generated Code:¶

----** SSC-FDM-0037 - CREATE STATISTICS NOT NEEDED. SNOWFLAKE AUTOMATICALLY COLLECTS STATISTICS. **
--CREATE STATISTICS NamePurchase ON AdventureWorks2022.Person.Person (
--  BusinessEntityID,
--  EmailPromotion
--) WITH FULLSCAN, NORECOMPUTE ;

Known Limitations¶

Any operational process that explicitly creates or refreshes statistics in SQL Server should be reviewed, because Snowflake manages optimizer statistics automatically.