SnowConvert AI - Teradata - Fonctions intégrées¶

Différences d’architecture entre Teradata et Snowflake¶

Teradata utilise une architecture sans partage avec des AMP (Access Module Processors) où chaque AMP gère sa propre part de stockage sur disque et est accessible par hachage lors des requêtes. Pour tirer parti du parallélisme, les informations stockées doivent être réparties uniformément entre les AMPs. Pour ce faire, Teradata propose un groupe de fonctions liées au hachage qui peuvent être utilisées pour déterminer la qualité des index primaires actuels.

En revanche, l’architecture de Snowflake est différente et gère elle-même la manière dont les données sont stockées, ce qui signifie que les utilisateurs n’ont pas à se préoccuper de l’optimisation de la distribution de leurs données.

Constantes de bornes de fin (UNTIL_CHANGED et UNTIL_CLOSED)¶

UNTIL_CHANGED et UNTIL_CLOSED sont des constantes Teradata qui représentent une borne de fin non définie pour les périodes. En interne, ces constantes sont représentées par la valeur maximale que peut avoir un horodatage, c’est-à-dire « 9999-12-31 23:59:59.999999 ». Lors de la migration de la fonction PERIOD, la borne de fin est vérifiée pour déterminer s’il s’agit de l’une de ces constantes et pour la remplacer par un varchar de valeur « 9999-12-31 23:59:59.999999 ». Si c’est le cas, Snowflake convertit le varchar en date ou en horodatage, selon le type de la borne de début, lors de l’appel de la fonction PERIOD___UDF.

Conversion implicite¶

Certaines fonctions de chaîne de Teradata comme INDEX ou POSITION acceptent des types de données autres que des chaînes et les convertissent implicitement en chaînes, ce qui peut entraîner des incohérences dans les résultats de ces fonctions entre Teradata et Snowflake. Par exemple, regardez le code Teradata suivant :

 SELECT INDEX(35, '5');

Renvoie 4, tandis que l’équivalent CHARINDEX dans Snowflake :

 SELECT CHARINDEX('5', 35);

Renvoie 2, cela se produit parce que Teradata a ses propres formats par défaut qui sont utilisés lors de la conversion implicite. Dans l’exemple ci-dessus, Teradata interprète la constante numérique 35 comme BYTEINT et utilise le format par défaut BYTEINT'-999' pour la conversion implicite en chaîne, ce qui donne la valeur convertie ' 35'. D’autre part, Snowflake utilise ses propres formats par défaut, ce qui crée des incohérences dans le résultat.

Pour résoudre ce problème, les modifications suivantes sont apportées aux paramètres de ces fonctions :

• Si le paramètre n’a pas de lien avec le format, une fonction SnowflakeTO_VARCHARavec l’équivalent du format Teradata par défaut dans Snowflake est ajoutée à la place.

• Si le paramètre est associé à un format, le format est converti en son équivalent Snowflake et la fonctionTO_VARCHARest ajoutée.

  • Par ailleurs, Teradata ignore le signe d’un nombre s’il n’est pas explicitement placé dans un format, alors que Snowflake ajoute toujours des espaces pour insérer le signe même s’il n’est pas spécifié. Dans ces cas, une vérification est effectuée pour voir si le signe a été spécifié et pour le supprimer de la chaîne de Snowflake s’il ne l’a pas été.

Après ces modifications, le code résultant serait le suivant :

 SELECT CHARINDEX( '5', TO_VARCHAR(35, 'MI999'));

Ce qui donne 4, le même résultat que le code Teradata.

Description¶

La fonction coalesce est utilisée pour renvoyer le premier élément non null d’une liste. Pour plus d’informations, voir COALESCE.

COALESCE(element_1, element_2 [, element_3, ..., element_n])

Les fonctions de Teradata et de Snowflake COALESCE permettent de mélanger des paramètres numériques avec des chaînes et des paramètres de date avec des horodatages. Cependant, ils traitent ces deux cas différemment :

• Paramètres numériques et paramètres de type chaîne : Teradata convertit tous les paramètres numériques en varchar alors que Snowflake fait l’inverse

• Horodatage et paramètres de date : Teradata convertit tous les horodatages en date alors que Snowflake fait l’inverse

Pour garantir l’équivalence fonctionnelle dans le premier cas, tous les paramètres numériques sont convertis en string à l’aide de la fonction to_varchar, qui prend en compte le format des nombres. Dans le second cas, tous les horodatages sont convertis en date à l’aide de to_date, Teradata ignore le format des horodatages lorsqu’il les convertit, de sorte qu’il est supprimé lors de la transformation.

Modèles d’échantillons de sources¶

 SELECT COALESCE(125, 'hello', cast(850 as format '-999'));

COLUMN1|
-------+
125    |

SELECT
 COALESCE(TO_VARCHAR(125), 'hello', TO_VARCHAR(850, '9000'));

COLUMN1|
-------+
125    |

 SELECT COALESCE(cast(TIMESTAMP '2021-09-14 10:14:59' as format 'HH:MI:SSBDD-MM-YYYY'), current_date);

COLUMN1    |
-----------+
2021-09-14 |

SELECT
 COALESCE(TO_DATE(TIMESTAMP '2021-09-14 10:14:59' !!!RESOLVE EWI!!! /*** SSC-EWI-TD0025 - OUTPUT FORMAT 'HH:MI:SSBDD-MM-YYYY' NOT SUPPORTED. ***/!!!), CURRENT_DATE());

COLUMN1    |
-----------+
2021-09-14 |

Problèmes connus¶

Aucun problème connu_._

EWIs connexes¶

• SSC-EWI-TD0025: Format de sortie non pris en charge.

Gravité¶

Faible

Description¶

Les fractions de seconde ne sont affichées que si elles sont explicitement définies dans le paramètre de session TIME_OUTPUT_FORMAT.

SELECT current_timestamp(4) at local;

SELECT
CURRENT_TIMESTAMP(4);

Recommandations¶

• Vérifiez si le paramètre de session TIME_OUTPUT___FORMAT est défini pour obtenir le comportement que vous souhaitez.

• Si vous avez besoin de plus d’assistance, vous pouvez nous envoyer un e-mail à snowconvert-support@snowflake.com.

Problèmes connus ¶

Aucun problème n’a été constaté.

EWIs connexes ¶

Pas d’EWIs connexes.

Description¶

Renvoie le nombre de jours écoulés entre le début du mois et la date donnée. Pour plus d’informations, consultez DAYNUMBER_OF_MONTH.

DAYNUMBER_OF_MONTH(expression [, calendar_name])

Teradata et Snowflake traitent tous deux la fonction DAYNUMBER_OF_MONTH de la même manière, sauf dans un cas :

• Le calendrier ISO : Un mois ISO compte 4 ou 5 semaines complètes. Pour plus d’informations, consultez À propos du calcul ISO.

Pour assurer l’équivalence fonctionnelle, une fonction définie par l’utilisateur (UDF) est ajoutée pour le cas du calendrier ISO.

Modèles d’échantillons de sources¶

SELECT
    DAYNUMBER_OF_MONTH (DATE'2022-12-22'),
    DAYNUMBER_OF_MONTH (DATE'2022-12-22', NULL),
    DAYNUMBER_OF_MONTH (DATE'2022-12-22', 'Teradata'),
    DAYNUMBER_OF_MONTH (DATE'2022-12-22', 'COMPATIBLE');

COLUMN1|COLUMN2|COLUMN3|COLUMN4|
-------+-------+-------+-------+
22     |22     |22     |22     |

SELECT
    DAYOFMONTH(DATE'2022-12-22'),
    DAYOFMONTH(DATE'2022-12-22'),
    DAYOFMONTH(DATE'2022-12-22'),
    DAYOFMONTH(DATE'2022-12-22');

COLUMN1|COLUMN2|COLUMN3|COLUMN4|
-------+-------+-------+-------+
22     |22     |22     |22     |

SELECT DAYNUMBER_OF_MONTH (DATE'2022-12-22', 'ISO');

COLUMN1|
-------+
25     |

SELECT
PUBLIC.DAYNUMBER_OF_MONTH_UDF(DATE'2022-12-22');

COLUMN1|
-------+
25     |

Problèmes connus ¶

Aucun problème n’a été constaté.

EWIs connexes ¶

Pas d’EWIs connexes.

Description¶

La fonction FROM_BYTES encode une séquence de bits en une séquence de caractères représentant son codage. Pour plus d’informations, consultez FROM_BYTES(Encodage).

Snowflake ne prend pas en charge la fonction FROM_BYTES, cependant, certains contournements peuvent être faits pour les occurrences les plus courantes de cette fonction.

Modèles d’échantillons de sources¶

 SELECT 
FROM_BYTES('5A1B'XB, 'base10'), --returns '23067'
FROM_BYTES('5A3F'XB, 'ASCII'), --returns 'Z\ESC '
FROM_BYTES('5A1B'XB, 'base16'); -- returns '5A1B'

COLUMN1    | COLUMN2    | COLUMN3 |
-----------+------------+---------+
23067      |  Z\ESC     | 5A1B    |

 SELECT
--returns '23067'
TO_NUMBER('5A1B', 'XXXX'),
--returns 'Z\ESC '
!!!RESOLVE EWI!!! /*** SSC-EWI-0031 - FROM_BYTES FUNCTION NOT SUPPORTED ***/!!!
FROM_BYTES(TO_BINARY('5A3F'), 'ASCII'),
TO_BINARY('5A1B', 'HEX'); -- returns '5A1B'

COLUMN1    | COLUMN2    | COLUMN3 |
-----------+------------+---------+
23067      |  Z\ESC     | 5A1B    |

Problèmes connus¶

1. Le paramètre de format TO\NUMBER doit correspondre aux chiffres de la chaîne d’entrée.

2. Il n’existe pas de fonction intégrée équivalente sur le plan fonctionnel pour FROM_BYTES lors de l’encodage en ANSI

EWIs connexes¶

1. SSC-EWI-0031: FUNCTION NOT SUPPORTED

Description¶

La fonction GetQueryBandValue recherche une clé de nom à l’intérieur de la bande de requête et renvoie sa valeur associée si elle est présente. Elle peut être utilisée pour effectuer une recherche dans la transaction, la session, le profil ou toute autre paire clé-valeur de la bande de requête.

Pour plus d’informations sur cette fonction, consultez GetQueryBandValue dans la documentation Teradata.

[SYSLIB.]GetQueryBandValue([QueryBandIn,] SearchType, Name);

Modèles d’échantillons de sources¶

 SET QUERY_BAND = 'hola=hello;adios=bye;' FOR SESSION;

 ALTER SESSION SET QUERY_TAG = 'hola=hello;adios=bye;';

 SELECT
GETQUERYBANDVALUE('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 0, 'account') as Example1,
GETQUERYBANDVALUE('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 1, 'account') as Example2,
GETQUERYBANDVALUE('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 2, 'account') as Example3,
GETQUERYBANDVALUE('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 3, 'account') as Example4,
GETQUERYBANDVALUE('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 0, 'role') as Example5,
GETQUERYBANDVALUE('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 1, 'role') as Example6;

+----------+----------+----------+----------+----------+----------+
| EXAMPLE1 | EXAMPLE2 | EXAMPLE3 | EXAMPLE4 | EXAMPLE5 | EXAMPLE6 |
+----------+----------+----------+----------+----------+----------+
| Mark200  | Mark200  | SaraDB   | Peter3   | DbAdmin  |          |
+----------+----------+----------+----------+----------+----------+

 SELECT
GETQUERYBANDVALUE_UDF('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 0, 'account') as Example1,
GETQUERYBANDVALUE_UDF('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 1, 'account') as Example2,
GETQUERYBANDVALUE_UDF('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 2, 'account') as Example3,
GETQUERYBANDVALUE_UDF('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 3, 'account') as Example4,
GETQUERYBANDVALUE_UDF('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 0, 'role') as Example5,
GETQUERYBANDVALUE_UDF('=T> user=Mark;account=Mark200; =S> user=Sara;account=SaraDB;role=DbAdmin =P> user=Peter;account=Peter3;', 1, 'role') as Example6;

+----------+----------+----------+----------+----------+----------+
| EXAMPLE1 | EXAMPLE2 | EXAMPLE3 | EXAMPLE4 | EXAMPLE5 | EXAMPLE6 |
+----------+----------+----------+----------+----------+----------+
| Mark200  | Mark200  | SaraDB   | Peter3   | DbAdmin  |          |
+----------+----------+----------+----------+----------+----------+

 SELECT
GETQUERYBANDVALUE(2, 'hola') as Example1,
GETQUERYBANDVALUE(2, 'adios') as Example2;

+----------+----------+
| EXAMPLE1 | EXAMPLE2 |
+----------+----------+
| hello    | bye      |
+----------+----------+

 SELECT
GETQUERYBANDVALUE_UDF('hola') as Example1,
GETQUERYBANDVALUE_UDF('adios') as Example2;

+----------+----------+
| EXAMPLE1 | EXAMPLE2 |
+----------+----------+
| hello    | bye      |
+----------+----------+

Problèmes connus¶

1. GetQueryBandValue sans le paramètre QueryBandIn uniquement pris en charge pour la session

Teradata permet de définir des bandes de requête au niveau de la transaction, de la session ou du profil. Si GetQueryBandValue est appelé sans spécifier de bande de requête d’entrée, Teradata vérifiera automatiquement les bandes de requête de transaction, de session ou de profil en fonction de la valeur du paramètre SearchType.

Dans Snowflake, l’équivalent le plus proche des bandes de requête sont les balises de requête, qui peuvent être spécifiées pour la session, l’utilisateur et le compte.

En raison de ces différences, la mise en œuvre de GetQueryBandValue sans le paramètre QueryBandIn ne prend en compte que la balise de requête de session et peut ne pas fonctionner comme prévu pour d’autres types de recherche.

EWIs connexes¶

Pas d’EWIs connexes.

Description¶

La fonction JSON_CHECK vérifie la validité d’une chaîne JSON.

Pour plus d’informations sur Teradata JSON_CHECK, cliquez ici.

[TD_SYSFNLIB.]JSON_CHECK(string_expr);

Modèle de source d’échantillon¶

SELECT JSON_CHECK('{"key": "value"}');

SELECT
IFNULL(CHECK_JSON('{"key": "value"}'), 'OK');

SELECT CASE WHEN JSON_CHECK('{}') = 'OK' then 'OKK' ELSE 'NOT OK' END;

SELECT
CASE
WHEN UPPER(RTRIM(IFNULL(CHECK_JSON('{}'), 'OK'))) = UPPER(RTRIM('OK'))
THEN 'OKK' ELSE 'NOT OK'
END;

Problèmes connus ¶

Aucun problème n’a été constaté.

EWIs connexes ¶

Pas d’EWIs connexes.

Description¶

Conformément à la documentation de Teradata, ces fonctions utilisent la syntaxe de requête JSONPath pour demander des informations sur une partie d’une instance JSON. L’entité souhaitée peut être n’importe quelle partie d’une instance JSON, comme une paire nom/valeur, un objet, un tableau, un élément de tableau ou une valeur.

Pour plus d’informations sur Teradata JSONExtractValue, JSONExtractLargeValue et JSONExtract, cliquez ici.

 JSON_expr.JSONExtractValue(JSONPath_expr)

JSON_expr.JSONExtractLargeValue(JSONPath_expr)

JSON_expr.JSONExtract(JSONPath_expr)

Le site JSON_EXTRACT_UDF est une implémentation Snowflake de la spécification JSONPath qui utilise une version modifiée de l’implémentation originale JavaScript développée par Stefan Goessner.

 SELECT
    Store.JSONExtract('$..author') as AllAuthors,
    Store.JSONExtractValue('$..book[2].title') as ThirdBookTitle,
    Store.JSONExtractLargeValue('$..book[2].price') as ThirdBookPrice
FROM BookStores;

 SELECT
    JSON_EXTRACT_UDF(Store, '$..author', FALSE) as AllAuthors,
    JSON_EXTRACT_UDF(Store, '$..book[2].title', TRUE) as ThirdBookTitle,
    JSON_EXTRACT_UDF(Store, '$..book[2].price', TRUE) as ThirdBookPrice
    FROM
    BookStores;

Problèmes connus¶

 { 
   "firstName":"Peter",
   "lastName":"Andre",
   "age":31,
   "cities": ["Los Angeles", "Lima", "Buenos Aires"]
}

 { 
   "age": 31,
   "cities": ["Los Angeles", "Lima", "Buenos Aires"],
   "firstName": "Peter",
   "lastName": "Andre" 
}

EWIs connexes¶

Pas d’EWIs connexes.

Description¶

Crée une table à partir du contenu d’un document JSON. Voir Documentation JSON_TABLE.

[TD_SYSFNLIB.]JSON_TABLE(
  ON (json_documents_retrieving_expr)
  USING 
      ROWEXPR (row_expr_literal) 
      COLEXPR (column_expr_literal)
  [AS] correlation_name [(column_name [,...])]
)

La conversion de JSON_TABLE a les considérations indiquées ci-dessous :

• ROW\NUMBER() est un équivalent des colonnes ordinales dans Snowflake.

• Dans Teradata, la deuxième colonne de JSON_TABLE doit être de type JSON, car les colonnes générées remplacent la deuxième colonne. Pour cette raison, SnowConvert AI suppose que la colonne a le bon type et l’utilise pour la transformation.

Modèles d’échantillons de sources¶

 create table myJsonTable(
 col1 integer,
 col2 JSON(1000)
 );
 
 
insert into myJsonTable values(1, 
new json('{
"name": "Matt",
"age" : 30,
"songs" : [
	{"name" : "Late night", "genre" : "Jazz"},
	{"name" : "Wake up", "genre" : "Rock"},
	{"name" : "Who am I", "genre" : "Rock"},
	{"name" : "Raining", "genre" : "Blues"}
]
}'));

 CREATE OR REPLACE TABLE myJsonTable (
 col1 integer,
 col2 VARIANT
 )
 COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;

INSERT INTO myJsonTable
VALUES (1, TO_JSON(PARSE_JSON('{
"name": "Matt",
"age" : 30,
"songs" : [
	{"name" : "Late night", "genre" : "Jazz"},
	{"name" : "Wake up", "genre" : "Rock"},
	{"name" : "Who am I", "genre" : "Rock"},
	{"name" : "Raining", "genre" : "Blues"}
]
}')));

 SELECT * FROM
JSON_TABLE(ON (SELECT COL1, COL2 FROM myJsonTable WHERE col1 = 1)
USING rowexpr('$.songs[*]')
colexpr('[ {"jsonpath" : "$.name",
            "type" : "CHAR(20)"},
            {"jsonpath" : "$.genre",
             "type" : "VARCHAR(20)"}]')) AS JT(ID, "Song name", Genre);

ID | Song name  | Genre |
---+------------+-------+
1  | Late night | Jazz  |
---+------------+-------+
1  | Wake up    | Rock  |
---+------------+-------+
1  | Who am I   | Rock  |
---+------------+-------+
1  | Raining    | Blues |

 SELECT
* FROM
(
SELECT
COL1 AS ID,
rowexpr.value:name :: CHAR(20) AS "Song name",
rowexpr.value:genre :: VARCHAR(20) AS Genre
FROM
myJsonTable,
TABLE(FLATTEN(INPUT => COL2:songs)) rowexpr
WHERE col1 = 1
) JT;

ID | Song name  | Genre |
---+------------+-------+
1  | Late night | Jazz  |
---+------------+-------+
1  | Wake up    | Rock  |
---+------------+-------+
1  | Who am I   | Rock  |
---+------------+-------+
1  | Raining    | Blues |

Problèmes connus¶

1. Le chemin JSON dans COLEXPR ne peut pas avoir plusieurs accès à l’astérisque

Les colonnes JSON chemin ne peuvent pas avoir plusieurs listes avec accès par astérisque, par exemple : $.Names[*].FullNames[*]. En revanche, le chemin JSON de ROWEXP peut l’avoir.

2. La structure JSON définie dans le littéral COLEXPR doit être une structure de JSON

Si ce n’est pas le cas, l’utilisateur est averti que le site JSON est mal formé.

EWIs connexes¶

Pas d’EWIs connexes.

Description¶

Alloue une nouvelle instance d’un type de données JSON. Pour plus d’informations, consultez NEW JSON Constructor Expression.

NEW JSON ( [ JSON_string_spec | JSON_binary_data_spec ] )

JSON_string_spec := JSON_String_literal [, { LATIN | UNICODE | BSON | UBJSON } ]

JSON_binary_data_spec := JSON_binary_literal [, { BSON | UBJSON } ]

Le deuxième paramètre de la fonction NEW JSON est toujours ignoré par SnowConvert AI puisque Snowflake ne fonctionne qu’avec UTF-8.

Modèles d’échantillons de sources¶

SELECT NEW JSON ('{"name" : "cameron", "age" : 24}'),
NEW JSON ('{"name" : "cameron", "age" : 24}', LATIN);

SELECT
TO_JSON(PARSE_JSON('{"name" : "cameron", "age" : 24}')),
!!!RESOLVE EWI!!! /*** SSC-EWI-TD0039 - INPUT FORMAT 'LATIN' NOT SUPPORTED ***/!!!
TO_JSON(PARSE_JSON('{"name" : "cameron", "age" : 24}'));

Problèmes connus¶

1. Le deuxième paramètre n’est pas pris en charge

Le deuxième paramètre de la fonction utilisé pour spécifier le format du résultat JSON n’est pas pris en charge car Snowflake ne supporte que UTF-8, ce qui peut entraîner des différences de fonctionnalité pour certaines utilisations de la fonction.

2. JSON avec les données BINARY n’est pas pris en charge

Snowflake ne prend pas en charge l’analyse des données binaires pour créer une valeur JSON ; l’utilisateur sera averti lorsque SnowConvert AI trouvera un NEW JSON avec des données binaires.

EWIs connexes¶

1. SSC-EWI-TD0039 : Format d’entrée non pris en charge.

Description¶

Extrait la valeur de la paire clé-valeur où la clé correspond à la énième occurrence du nom spécifié à rechercher. Voir NVP.

[TD_SYSFNLIB.] NVP (
in_string,
name_to_search
[, name_delimiters ]
[, value_delimiters ]
[, occurrence ]
)

Modèles d’échantillons de sources¶

SELECT
NVP('entree=-orange chicken&entree+.honey salmon', 'entree', '&', '=- +.', 1),
NVP('Hello=bye|name=Lucas|Hello=world!', 'Hello', '|', '=', 2),
NVP('Player=Mario$Game&Tenis%Player/Susana$Game=Chess', 'Player', '% $', '= & /', 2);

COLUMN1        | COLUMN2 | COLUMN3 |
---------------+---------+---------+
orange chicken | world!  | Susana  |

SELECT
PUBLIC.NVP_UDF('entree=-orange chicken&entree+.honey salmon', 'entree', '&', '=- +.', 1),
PUBLIC.NVP_UDF('Hello=bye|name=Lucas|Hello=world!', 'Hello', '|', '=', 2),
PUBLIC.NVP_UDF('Player=Mario$Game&Tenis%Player/Susana$Game=Chess', 'Player', '% $', '= & /', 2);

COLUMN1        | COLUMN2 | COLUMN3 |
---------------+---------+---------+
orange chicken | world!  | Susana  |

SELECT
NVP('City=Los Angeles&Color=Green&Color=Blue&City=San Jose', 'Color'),
NVP('City=Los Angeles&Color=Green&Color=Blue&City=San Jose', 'Color', 2),
NVP('City=Los Angeles#Color=Green#Color=Blue#City=San Jose', 'City', '#', '=');

COLUMN1 | COLUMN2 | COLUMN3     |
--------+---------+-------------+
Green   | Blue    | Los Angeles |

SELECT
    PUBLIC.NVP_UDF('City=Los Angeles&Color=Green&Color=Blue&City=San Jose', 'Color', '&', '=', 1),
    PUBLIC.NVP_UDF('City=Los Angeles&Color=Green&Color=Blue&City=San Jose', 'Color', '&', '=', 2),
    PUBLIC.NVP_UDF('City=Los Angeles#Color=Green#Color=Blue#City=San Jose', 'City', '#', '=', 1);

COLUMN1 | COLUMN2 | COLUMN3     |
--------+---------+-------------+
Green   | Blue    | Los Angeles |

SELECT
NVP('store = whole foods&&store: ?Bristol farms','store', '&&', '\ =\  :\ ?', 2),
NVP('Hello = bye|name = Lucas|Hello = world!', 'Hello', '|', '\ =\ ', 2);

COLUMN1       | COLUMN2 |
--------------+---------+
Bristol farms | world!  |

SELECT
PUBLIC.NVP_UDF('store = whole foods&&store: ?Bristol farms', 'store', '&&', '\\ =\\  :\\ ?', 2),
PUBLIC.NVP_UDF('Hello = bye|name = Lucas|Hello = world!', 'Hello', '|', '\\ =\\ ', 2);

COLUMN1       | COLUMN2 |
--------------+---------+
Bristol farms | world!  |

SELECT NVP('store = whole foods&&store: ?Bristol farms','store', '&&', valueDelimiter, 2);

SELECT
PUBLIC.NVP_UDF('store = whole foods&&store: ?Bristol farms', 'store', '&&', valueDelimiter, 2) /*** SSC-FDM-TD0008 - WHEN NVP_UDF FOURTH PARAMETER IS NON-LITERAL AND IT CONTAINS A BACKSLASH, THAT BACKSLASH NEEDS TO BE ESCAPED ***/;

Problèmes connus¶

1. Les délimiteurs contenant des espaces (\ ) doivent avoir leur antislash échappé dans Snowflake

Dans Teradata, les délimiteurs comprenant des espaces les spécifient en utilisant « \ » (voir NVP avec des espaces dans les délimiteurs), comme indiqué dans les exemples. Dans Teradata, il n’est pas nécessaire d’effectuer un échappement de la barre oblique inverse, alors que cela est nécessaire dans Snowflake. L’échappement des barres obliques inverses dans le délimiteur peut être effectué automatiquement par SnowConvert AI mais uniquement si les valeurs des délimiteurs sont des chaînes littérales, sinon l’utilisateur sera averti qu’aucun échappement ne peut être effectué sur les barres obliques inverses et que cela peut entraîner des résultats différents dans Snowflake.

EWIs connexes¶

1. SSC-FDM-TD0008 : Les délimiteurs non littéraux comportant des espaces ont besoin qu’un échappement de leur barre oblique inverse soit effectué dans Snowflake.

Description¶

Selon la documentation de Teradata, l’opérateur OVERLAPS compare deux ou plusieurs expressions de période. Si elles se chevauchent, il renvoie la valeur true.

Pour plus d’informations sur les OVERLAPS de Teradata, cliquez ici.

period_expression
OVERLAPS
period_expression

L’opérateur PERIOD_OVERLAPS_UDF est une implémentation Snowflake de l’opérateur OVERLAPS dans Teradata.

Modèle de source d’échantillon¶

SELECT 
    PERIOD(DATE '2009-01-01', DATE '2010-09-24') 
    OVERLAPS
    PERIOD(DATE '2009-02-01', DATE '2009-06-24');

SELECT
    PUBLIC.PERIOD_OVERLAPS_UDF(ARRAY_CONSTRUCT(PUBLIC.PERIOD_UDF(DATE '2009-01-01', DATE '2010-09-24') !!!RESOLVE EWI!!! /*** SSC-EWI-TD0053 - SNOWFLAKE DOES NOT SUPPORT THE PERIOD DATATYPE, ALL PERIODS ARE HANDLED AS VARCHAR INSTEAD ***/!!!, PUBLIC.PERIOD_UDF(DATE '2009-02-01', DATE '2009-06-24') !!!RESOLVE EWI!!! /*** SSC-EWI-TD0053 - SNOWFLAKE DOES NOT SUPPORT THE PERIOD DATATYPE, ALL PERIODS ARE HANDLED AS VARCHAR INSTEAD ***/!!!)) !!!RESOLVE EWI!!! /*** SSC-EWI-TD0053 - SNOWFLAKE DOES NOT SUPPORT THE PERIOD DATATYPE, ALL PERIODS ARE HANDLED AS VARCHAR INSTEAD ***/!!!;

Problèmes connus¶

EWIs connexes¶

1. SSC-EWI-TD0053 : Snowflake ne prend pas en charge le type de données Period. Toutes les périodes sont traitées en tant que varchar à la place.

Description¶

Selon la documentation de Teradata, l’opérateur P_INTERSECT compare deux ou plusieurs expressions de période. En cas de chevauchement, il renvoie la partie commune des expressions de la période.

Pour plus d’informations le P_INTERSECT de Teradata, [cliquez ici] (https://docs.teradata.com/r/kmuOwjp1zEYg98JsB8fu_A/iW6iefgeyOypFOMY2qGG_A).

period_expression
P_INTERSECT
period_expression

PERIOD_INTERSECT_-UDF est une implémentation Snowflake de l’opérateur P_INTERSECT dans Teradata.

Modèle de source d’échantillon¶

SELECT 
    PERIOD(DATE '2009-01-01', DATE '2010-09-24') 
    P_INTERSECT 
    PERIOD(DATE '2009-02-01', DATE '2009-06-24');

SELECT
    PUBLIC.PERIOD_INTERSECT_UDF(ARRAY_CONSTRUCT(PUBLIC.PERIOD_UDF(DATE '2009-01-01', DATE '2010-09-24') !!!RESOLVE EWI!!! /*** SSC-EWI-TD0053 - SNOWFLAKE DOES NOT SUPPORT THE PERIOD DATATYPE, ALL PERIODS ARE HANDLED AS VARCHAR INSTEAD ***/!!!, PUBLIC.PERIOD_UDF(DATE '2009-02-01', DATE '2009-06-24') !!!RESOLVE EWI!!! /*** SSC-EWI-TD0053 - SNOWFLAKE DOES NOT SUPPORT THE PERIOD DATATYPE, ALL PERIODS ARE HANDLED AS VARCHAR INSTEAD ***/!!!)) !!!RESOLVE EWI!!! /*** SSC-EWI-TD0053 - SNOWFLAKE DOES NOT SUPPORT THE PERIOD DATATYPE, ALL PERIODS ARE HANDLED AS VARCHAR INSTEAD ***/!!!;

Problèmes connus¶

EWIs connexes¶

1. SSC-EWI-TD0053 : Snowflake ne prend pas en charge le type de données Period. Toutes les périodes sont traitées en tant que varchar à la place.

Description¶

La fonction de table pivot est utilisée pour transformer les lignes d’une table en colonnes. Pour plus d’informations, consultez la documentation de PIVOT Teradata.

PIVOT ( pivot_spec )
  [ WITH with_spec [,...] ]
  [AS] derived_table_name [ ( cname [,...] ) ]
  
pivot_spec := aggr_fn_spec [,...] FOR for_spec

aggr_fn_spec := aggr_fn ( cname ) [ [AS] pvt_aggr_alias ]

for_spec := { cname IN ( expr_spec_1 [,...] ) |
( cname [,...] ) IN ( expr_spec_2 [,...] ) |
cname IN ( subquery )
}

expr_spec_1 := expr [ [AS] expr_alias_name ]

expr_spec_2 := ( expr [,...] ) [ [AS] expr_alias_name ]

with_spec := aggr_fn ( { cname [,...] | * } ) [AS] aggr_alias

Modèles d’échantillons de sources¶

 CREATE TABLE star1(
	country VARCHAR(20),
	state VARCHAR(10), 
	yr INTEGER,
	qtr VARCHAR(3),
	sales INTEGER,
	cogs INTEGER
);

insert into star1 values ('USA', 'CA', 2001, 'Q1', 30, 15);
insert into star1 values ('Canada', 'ON', 2001, 'Q2', 10, 0);
insert into star1 values ('Canada', 'BC', 2001, 'Q3', 10, 0);
insert into star1 values ('USA', 'NY', 2001, 'Q1', 45, 25);
insert into star1 values ('USA', 'CA', 2001, 'Q2', 50, 20);

 CREATE OR REPLACE TABLE star1 (
	country VARCHAR(20),
	state VARCHAR(10),
	yr INTEGER,
	qtr VARCHAR(3),
	sales INTEGER,
	cogs INTEGER
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;

INSERT INTO star1
VALUES ('USA', 'CA', 2001, 'Q1', 30, 15);

INSERT INTO star1
VALUES ('Canada', 'ON', 2001, 'Q2', 10, 0);

INSERT INTO star1
VALUES ('Canada', 'BC', 2001, 'Q3', 10, 0);

INSERT INTO star1
VALUES ('USA', 'NY', 2001, 'Q1', 45, 25);

INSERT INTO star1
VALUES ('USA', 'CA', 2001, 'Q2', 50, 20);

 SELECT *
FROM star1 PIVOT (
	SUM(sales) FOR qtr                                                                                               
    IN ('Q1',                                                                                                     
    	'Q2', 
        'Q3')
)Tmp;

Country | State | yr   | cogs | 'Q1' | 'Q2' | 'Q3' |
--------+-------+------+------+------+------+------+
Canada	| BC	| 2001 | 0    | null | null | 10   |
--------+-------+------+------+------+------+------+
USA 	| NY	| 2001 | 25   | 45   | null | null |
--------+-------+------+------+------+------+------+
Canada 	| ON 	| 2001 | 0    | null | 10   | null |
--------+-------+------+------+------+------+------+
USA 	| CA 	| 2001 | 20   | null | 50   | null |
--------+-------+------+------+------+------+------+
USA 	| CA 	| 2001 | 15   | 30   | null | null |
--------+-------+------+------+------+------+------+

 SELECT
	*
FROM
	star1 PIVOT(
	SUM(sales) FOR qtr IN ('Q1',
	   	'Q2',
	       'Q3'))Tmp;

Country | State | yr   | cogs | 'Q1' | 'Q2' | 'Q3' |
--------+-------+------+------+------+------+------+
Canada	| BC	| 2001 | 0    | null | null | 10   |
--------+-------+------+------+------+------+------+
USA 	| NY	| 2001 | 25   | 45   | null | null |
--------+-------+------+------+------+------+------+
Canada 	| ON 	| 2001 | 0    | null | 10   | null |
--------+-------+------+------+------+------+------+
USA 	| CA 	| 2001 | 20   | null | 50   | null |
--------+-------+------+------+------+------+------+
USA 	| CA 	| 2001 | 15   | 30   | null | null |
--------+-------+------+------+------+------+------+

 SELECT *
FROM star1 PIVOT (
	SUM(sales) as ss1 FOR qtr                                                                                               
    IN ('Q1' AS Quarter1,                                                                                                     
    	'Q2' AS Quarter2, 
        'Q3' AS Quarter3)
)Tmp;

Country | State | yr   | cogs | Quarter1_ss1 | Quarter2_ss1 | Quarter3_ss1 |
--------+-------+------+------+--------------+--------------+--------------+
Canada	| BC	| 2001 | 0    | null 	     | null         | 10           |
--------+-------+------+------+--------------+--------------+--------------+
USA 	| NY	| 2001 | 25   | 45 	     | null 	    | null         |
--------+-------+------+------+--------------+--------------+--------------+
Canada 	| ON 	| 2001 | 0    | null 	     | 10 	    | null 	   |
--------+-------+------+------+--------------+--------------+--------------+
USA 	| CA 	| 2001 | 20   | null         | 50           | null         |
--------+-------+------+------+--------------+--------------+--------------+
USA 	| CA 	| 2001 | 15   | 30           | null         | null         |
--------+-------+------+------+--------------+--------------+--------------+

 SELECT
	*
FROM
	!!!RESOLVE EWI!!! /*** SSC-EWI-0015 - PIVOT/UNPIVOT RENAME COLUMN NOT SUPPORTED ***/!!!
	star1 PIVOT(
	SUM(sales) FOR qtr IN (
	                       !!!RESOLVE EWI!!! /*** SSC-EWI-0015 - PIVOT/UNPIVOT RENAME COLUMN NOT SUPPORTED ***/!!!
	                       'Q1',
	!!!RESOLVE EWI!!! /*** SSC-EWI-0015 - PIVOT/UNPIVOT RENAME COLUMN NOT SUPPORTED ***/!!!
	   	'Q2',
	!!!RESOLVE EWI!!! /*** SSC-EWI-0015 - PIVOT/UNPIVOT RENAME COLUMN NOT SUPPORTED ***/!!!
	       'Q3'))Tmp;

 Country | State | yr   | cogs | Quarter1_ss1 | Quarter2_ss1 | Quarter3_ss1 |
--------+-------+------+------+--------------+--------------+--------------+
Canada	| BC	| 2001 | 0    | null 	     | null         | 10           |
--------+-------+------+------+--------------+--------------+--------------+
USA 	| NY	| 2001 | 25   | 45 	     | null 	    | null         |
--------+-------+------+------+--------------+--------------+--------------+
Canada 	| ON 	| 2001 | 0    | null 	     | 10 	    | null 	   |
--------+-------+------+------+--------------+--------------+--------------+
USA 	| CA 	| 2001 | 20   | null         | 50           | null         |
--------+-------+------+------+--------------+--------------+--------------+
USA 	| CA 	| 2001 | 15   | 30           | null         | null         |
--------+-------+------+------+--------------+--------------+--------------+

Problèmes connus¶

1. La clause WITH n’est pas prise en charge

L’utilisation de la clause WITH n’est pas prise en charge actuellement.

2. Le pivot sur plusieurs colonnes pivot n’est pas pris en charge

SnowConvert AI transforme la fonction PIVOT en fonction PIVOT dans Snowflake, qui ne prend en charge l’application de la fonction que sur une seule colonne.

3. Le pivot avec plusieurs fonctions d’agrégation n’est pas pris en charge

La fonction PIVOT de Snowflake ne permet d’appliquer qu’une seule fonction d’agrégation aux données.

4. La sous-requête dans la clause IN n’est pas prise en charge

La clause IN de la fonction PIVOT de Snowflake n’accepte pas les sous-requêtes.

5. Les alias ne sont pris en charge que si tous les éléments de la clause IN en sont pourvus et que la spécification de la table est présente

Pour que les noms de colonnes avec des alias soient équivalents, SnowConvert AI exige que toutes les valeurs spécifiées dans la clause IN aient un alias spécifié et que la spécification de la table soit présente dans le code d’entrée. Cela est nécessaire pour que SnowConvert AI puisse créer correctement la liste d’alias pour la table résultante.

EWIs connexes¶

1. SSC-EWI-0015 : Le format de l’instruction pivot/non pivot d’entrée n’est pas pris en charge

Description¶

RANK trie un jeu de résultats et identifie le rang numérique de chaque ligne du résultat. Le seul argument de RANK est la ou les colonnes de tri, et la fonction renvoie un entier qui représente le rang de chaque ligne dans le résultat. (RANK dans Teradata)

 RANK ( sort_expression [ ASC | DESC ] [,...] )

 RANK() OVER 
( 
    [ PARTITION BY <expr1> ]
    ORDER BY <expr2> [ { ASC | DESC } ] 
    [ <window_frame> ]
)

Modèle de source d’échantillon¶

 CREATE TABLE Sales (
  Product VARCHAR(255),
  Sales INT
);

INSERT INTO Sales (Product, Sales) VALUES ('A', 100);
INSERT INTO Sales (Product, Sales) VALUES ('B', 150);
INSERT INTO Sales (Product, Sales) VALUES ('C', 200);
INSERT INTO Sales (Product, Sales) VALUES ('D', 150);
INSERT INTO Sales (Product, Sales) VALUES ('E', 120);
INSERT INTO Sales (Product, Sales) VALUES ('F', NULL);

 CREATE OR REPLACE TABLE Sales (
  Product VARCHAR(255),
  Sales INT
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;

INSERT INTO Sales (Product, Sales)
VALUES ('A', 100);

INSERT INTO Sales (Product, Sales)
VALUES ('B', 150);

INSERT INTO Sales (Product, Sales)
VALUES ('C', 200);

INSERT INTO Sales (Product, Sales)
VALUES ('D', 150);

INSERT INTO Sales (Product, Sales)
VALUES ('E', 120);

INSERT INTO Sales (Product, Sales)
VALUES ('F', NULL);

 SELECT
  Sales,
  RANK(Sales ASC) AS SalesAsc,
  RANK(Sales DESC) AS SalesDesc,
  RANK(Sales) AS SalesDefault
FROM
  Sales;

 SELECT
  Sales,
  RANK() OVER (
  ORDER BY
    Sales ASC) AS SalesAsc,
    RANK() OVER (
    ORDER BY
    Sales DESC NULLS LAST) AS SalesDesc,
    RANK() OVER (
    ORDER BY
    Sales DESC NULLS LAST) AS SalesDefault
    FROM
    Sales;

Problèmes connus ¶

Aucun problème n’a été constaté.

EWIs connexes ¶

Pas d’EWIs connexes.

Description¶

Teradata et Snowflake prennent en charge les fonctions qui appliquent des expressions régulières aux entrées de type varchar. Pour plus de détails, consultez la documentation Teradata et la documentation Snowflake.

REGEXP_SUBSTR(source. regexp [, position, occurrence, match])
REGEXP_REPLACE(source. regexp [, replace_string, position, occurrence, match])
REGEXP_INSTR(source. regexp [, position, occurrence, return_option, match])
REGEXP_SIMILAR(source. regexp [, match])
REGEXP_SPLIT_TO_TABLE(inKey. source. regexp, match)

Modèles d’échantillons de sources¶

CREATE TABLE regexpTable
(
    col1 CHAR(35)
);

INSERT INTO regexpTable VALUES('hola');

CREATE OR REPLACE TABLE regexpTable
(
    col1 CHAR(35)
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;

INSERT INTO regexpTable
VALUES ('hola');

SELECT
REGEXP_REPLACE(col1,'.*(h(i|o))','ha', 1, 0, 'x'),
REGEXP_SUBSTR(COL1,'.*(h(i|o))', 2, 1, 'x'),
REGEXP_INSTR(COL1,'.*(h(i|o))',1, 1, 0, 'x'),
REGEXP_SIMILAR(COL1,'.*(h(i|o))', 'xl')
FROM regexpTable;

COLUMN1|COLUMN2|COLUMN3|COLUMN4|
-------+-------+-------+-------+
hala   |null   |1      |0      |

--** SSC-FDM-0007 - MISSING DEPENDENT OBJECT "regexpTable" **
SELECT
REGEXP_REPLACE(col1, '.*(h(i|o))', 'ha', 1, 0),
REGEXP_SUBSTR(COL1, '.*(h(i|o))', 2, 1),
REGEXP_INSTR(COL1, '.*(h(i|o))', 1, 1, 0),
--** SSC-FDM-TD0016 - VALUE 'l' FOR PARAMETER 'match_arg' IS NOT SUPPORTED IN SNOWFLAKE **
REGEXP_LIKE(COL1, '.*(h(i|o))')
FROM
regexpTable;

COLUMN1|COLUMN2|COLUMN3|COLUMN4|
-------+-------+-------+-------+
hala   |null   |1      |FALSE  |

Problèmes connus¶

1. Snowflake prend uniquement en charge les expressions régulièresPOSIX

L’utilisateur sera averti lorsque SnowConvert AI trouvera une expression régulière non-POSIX.

2. L’option « l » de Teradata « match_arg » n’est pas prise en charge par Snowflake

L’option “l” n’a pas d’équivalent dans Snowflake et l’utilisateur sera averti si SnowConvert AI les trouve.

3. La correction de la taille du type de données CHAR peut entraîner des comportements différents

Certaines fonctions Regex de Teradata tenteront de faire correspondre la colonne entière du type de données CHAR dans une table, même si certains caractères de la colonne sont restés vides en raison de l’insertion d’une chaîne plus petite. Dans Snowflake, cela ne se produit pas car le type de données CHAR est de taille variable.

4. REGEXP_SPLIT_TO_TABLE non pris en charge

La fonction n’est actuellement pas prise en charge par Snowflake.

EWIs connexes¶

1. SSC-FDM-0007 : Élément avec dépendances manquantes.

2. SSC-FDM-TD0016 : La valeur “l” pour le paramètre “match_arg” n’est pas prise en charge par Snowflake.

Description¶

Découpez une chaîne en une table en utilisant les délimiteurs fournis. Pour plus d’informations, consultez STRTOK_SPLIT_TO_TABLE.

[TD_SYSFNLIB.] STRTOK_SPLIT_TO_TABLE ( inkey, instring, delimiters )
  RETURNS ( outkey, tokennum, token )

Modèles d’échantillons de sources¶

CREATE TABLE strtokTable
(
	col1 INTEGER,
	col2 VARCHAR(100)
);

INSERT INTO strtokTable VALUES(4, 'hello-world-split-me');
INSERT INTO strtokTable VALUES(1, 'string$split$by$dollars');

CREATE OR REPLACE TABLE strtokTable
(
	col1 INTEGER,
	col2 VARCHAR(100)
)
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"teradata"}}'
;

INSERT INTO strtokTable
VALUES (4, 'hello-world-split-me');

INSERT INTO strtokTable
VALUES (1, 'string$split$by$dollars');

SELECT outkey, tokennum, token FROM table(STRTOK_SPLIT_TO_TABLE(strtokTable.col1, strtokTable.col2, '-$')
RETURNS (outkey INTEGER, tokennum INTEGER, token VARCHAR(100))) AS testTable
ORDER BY outkey, tokennum;

outkey |tokennum | token  |
-------+---------+--------+
1      |1        |string  |
-------+---------+--------+
1      |2        |split   |
-------+---------+--------+
1      |3        |by      |
-------+---------+--------+
1      |4        |dollars |
-------+---------+--------+
4      |1        |hello   |
-------+---------+--------+
4      |2        |world   |
-------+---------+--------+
4      |3        |split   |
-------+---------+--------+
4      |4        |me      |

SELECT
CAST(strtokTable.col1 AS INTEGER) AS outkey,
CAST(INDEX AS INTEGER) AS tokennum,
CAST(VALUE AS VARCHAR) AS token
FROM
strtokTable,
table(STRTOK_SPLIT_TO_TABLE(strtokTable.col2, '-$')) AS testTable
ORDER BY outkey, tokennum;