SnowConvert AI – Teradata – Integrierte Funktionen¶

Architekturunterschiede zwischen Teradata und Snowflake¶

Teradata verfügt über eine Shared-Nothing-Architektur mit Access Module Processors (AMP), bei der jeder AMP seinen eigenen Anteil am Plattenspeicher verwaltet und bei Abfragen über Hashing zugegriffen wird. Um die Vorteile der Parallelität zu nutzen, sollten die gespeicherten Informationen gleichmäßig auf AMPs verteilt werden. Zu diesem Zweck bietet Teradata eine Gruppe von Hashwert-Funktionen an, mit denen Sie feststellen können, wie gut die aktuellen Primärindizes sind.

Die Snowflake-Architektur hingegen ist anders. Sie verwaltet die Speicherung der Daten selbst, so dass sich die Benutzer nicht um die Optimierung der Datenverteilung kümmern müssen.

Endkonstanten (UNTIL_CHANGED und UNTIL_CLOSED)¶

Sowohl UNTIL_CHANGED als auch UNTIL_CLOSED sind Teradata-Konstanten, die eine undefinierte Endgrenze für Perioden darstellen. Intern werden diese Konstanten als der maximale Wert dargestellt, den ein Zeitstempel haben kann, z. B. ‚9999-12-31 23:59:59,999999‘. Während der Migration der Funktion PERIOD wird die Endgrenze überprüft, um festzustellen, ob sie eine dieser Konstanten ist, und sie gegebenenfalls durch Varchar mit dem Wert ‚9999-12-31 23:59:59.999999‘ zu ersetzen. Ist dies der Fall, wandelt Snowflake den Varchar-Wert je nach Typ der Anfangsgrenze beim Aufruf von PERIOD___UDF aufruft.

Implizite Konvertierung¶

Einige Teradata-Zeichenfolgenfunktionen wie INDEX oder POSITION akzeptieren Nicht-Zeichenfolgen-Datentypen und konvertieren sie implizit in eine Zeichenfolge. Dies kann zu Inkonsistenzen in den Ergebnissen dieser Funktionen zwischen Teradata und Snowflake führen. Zum Beispiel der folgende Teradata-Code:

 SELECT INDEX(35, '5');

Das Ergebnis ist 4, während die CHARINDEX-Entsprechung in Snowflake:

 SELECT CHARINDEX('5', 35);

2 ist. Dies geschieht, weil Teradata seine eigenen Standardformate hat, die bei der impliziten Konvertierung verwendet werden. Im obigen Beispiel interpretiert Teradata die numerische Konstante 35 als BYTEINT und verwendet BYTEINT Standardformat'-999' für die implizite Konvertierung in eine Zeichenfolge, wodurch der konvertierte Wert ' 35' lautet. Andererseits verwendet Snowflake seine eigenen Standardformate, was zu Inkonsistenzen im Ergebnis führt.

Um dieses Problem zu lösen, werden die folgenden Änderungen an diesen Funktionsparametern vorgenommen:

• Wenn der Parameter not eine Umwandlung mit Format hat, wird stattdessen eine Funktion von SnowflakeTO_VARCHARmit dem Standard-Teradata-Format-Äquivalent in Snowflake hinzugefügt.

• Wenn der Parameter eine Formatumwandlung hat, dann wird das Format in sein Snowflake-Äquivalent konvertiert und die FunktionTO_VARCHARhinzugefügt.

  • Als Randbemerkung: Teradata ignoriert das Vorzeichen einer Zahl, wenn es nicht explizit in ein Format eingefügt wird, während Snowflake immer Leerzeichen hinzufügt, um das Vorzeichen einzufügen, auch wenn es nicht angegeben wurde. In diesen Fällen wird geprüft, ob das Vorzeichen angegeben wurde und es aus der Snowflake-Zeichenfolge entfernt, falls es nicht angegeben wurde.

Nach diesen Änderungen würde der Code folgendermaßen aussehen:

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

Das Ergebnis ist 4, das gleiche wie der Teradata-Code.

Beschreibung¶

Die Coalesce-Funktion wird verwendet, um das erste Nicht-Null-Element in einer Liste zurückzugeben. Weitere Informationen dazu finden Sie unter COALESCE.

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

Sowohl die COALESCE-Funktionen von Teradata als auch von Snowflake erlauben die Kombination von numerischen Parametern mit Zeichenfolgen- und Datumsparametern mit Zeitstempeln. Sie behandeln diese beiden Fälle jedoch unterschiedlich:

• Numerische Parameter zusammen mit Zeichenfolgen-Parametern: Teradata konvertiert alle numerischen Parameter in Varchar, während Snowflake das Gegenteil tut

• Zeitstempel zusammen mit Datumsparametern: Teradata konvertiert alle Zeitstempel in ein Datum, während Snowflake das Gegenteil tut

Um die Funktionsäquivalenz im ersten Fall zu gewährleisten, werden alle numerischen Parameter mit der Funktionto_varcharinstringumgewandelt, wodurch das Format der Zahlen berücksichtigt wird. Im zweiten Fall werden alle Zeitstempel mit to_date in ein Datum umgewandelt. Teradata ignoriert das Format der Zeitstempel bei der Transformation, so dass es bei der Transformation entfernt wird.

Beispielhafte Quellcode-Muster¶

 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 |

Bekannte Probleme¶

Keine bekannten Probleme_.\_

Zugehörige EWIs¶

• SSC-EWI-TD0025: Ausgabeformat nicht unterstützt.

Schweregrad¶

Niedrig

Beschreibung¶

Bruchteile von Sekunden werden nur angezeigt, wenn dies explizit im Sitzungsparameter TIME_OUTPUT_FORMAT festgelegt ist.

SELECT current_timestamp(4) at local;

SELECT
CURRENT_TIMESTAMP(4);

Empfehlungen¶

• Prüfen Sie, ob der Sitzungsparameter TIME_OUTPUT___FORMAT so eingestellt ist, dass Sie die gewünschte Verhaltensweise erhalten.

• Wenn Sie weitere Unterstützung benötigen, können Sie uns eine E-Mail an snowconvert-support@snowflake.com senden.

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs ¶

Keine zugehörigen EWIs.

Beschreibung¶

Gibt die Anzahl der Tage zurück, die vom Monatsanfang bis zum angegebenen Datum verstrichen sind. Weitere Informationen finden Sie unter DAYNUMBER_OF_MONTH.

DAYNUMBER_OF_MONTH(expression [, calendar_name])

Sowohl Teradata als auch Snowflake behandeln die Funktion DAYNUMBER_OF_MONTH auf die gleiche Weise, mit einer Ausnahme:

• Der ISO-Kalender: Ein ISO Monat hat 4 oder 5 vollständige Wochen. Weitere Informationen finden Sie unter Über ISO-Berechnung.

Um die funktionale Gleichwertigkeit zu gewährleisten, wird eine benutzerdefinierte Funktion (UDF) für den ISO-Kalenderfall hinzugefügt.

Beispielhafte Quellcode-Muster¶

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     |

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs ¶

Keine zugehörigen EWIs.

Beschreibung¶

Die Funktion FROM_BYTES kodiert eine Folge von Bits in eine Folge von Zeichen, die ihre Kodierung darstellen. Weitere Informationen finden Sie unter FROM_BYTES(Encoding).

Snowflake bietet keine Unterstützung für die Funktion FROM_BYTES. Für die häufigsten Fälle, in denen diese Funktion verwendet wird, gibt es Umgehungsmöglichkeiten.

Beispielhafte Quellcode-Muster¶

 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    |

Bekannte Probleme¶

1. TO_NUMBER-Formatparameter muss mit den Ziffern der Eingabezeichenfolge übereinstimmen.

2. Es gibt keine funktional äquivalente integrierte Funktion für FROM_BYTES bei der Kodierung nach ANSI

Zugehörige EWIs¶

1. SSC-EWI-0031: FUNCTION NOT SUPPORTED

Beschreibung¶

Die Funktion GetQueryBandValue sucht einen Namensschlüssel innerhalb des Abfragebands und gibt den zugehörigen Wert zurück, falls vorhanden. Sie können damit innerhalb der Transaktion, der Sitzung, des Profils oder eines der Schlüsselwert-Paare des Abfragebands suchen.

Weitere Informationen zu dieser Funktion finden Sie unter GetQueryBandValue in der Teradata-Dokumentation.

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

Beispielhafte Quellcode-Muster¶

 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      |
+----------+----------+

Bekannte Probleme¶

1. GetQueryBandValue ohne QueryBandIn-Parameter nur für Sitzung unterstützt

Teradata ermöglicht die Definition von Abfragebändern auf Transaktions-, Sitzungs- oder Profilebene. Wenn GetQueryBandValue ohne Angabe eines Abfragebands aufgerufen wird, prüft Teradata automatisch die Transaktions-, Sitzungs- oder Profil-Abfragebands, je nach dem Wert des Parameters SearchType.

In Snowflake sind die Abfrage-Tags, die für Sitzung, Benutzer und Konten angegeben werden können, das engste Äquivalent zu Abfragebands.

Aufgrund dieser Unterschiede berücksichtigt die Implementierung von GetQueryBandValue ohne den Parameter QueryBandIn nur das Abfrage-Tag der Sitzung und funktioniert bei anderen Sucharten möglicherweise nicht wie erwartet.

Zugehörige EWIs¶

Keine zugehörigen EWIs.

Beschreibung¶

Die Funktion JSON_CHECK überprüft eine Zeichenfolge auf eine gültige JSON.

Weitere Informationen zu Teradata JSON_CHECK finden Sie hier .

[TD_SYSFNLIB.]JSON_CHECK(string_expr);

Beispielhaftes Quellcode-Muster¶

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;

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs ¶

Keine zugehörigen EWIs.

Beschreibung¶

Wie in der Dokumentation von Teradata beschrieben, verwenden diese Funktionen die JSONPath Abfrage-Syntax, um Informationen über einen Teil einer JSON-Instanz abzufragen. Die gewünschte Entität kann ein beliebiger Teil einer JSON-Instanz sein, wie z. B. ein Name/Wert-Paar, ein Objekt, ein Array, ein Arrayelement oder ein Wert.

Weitere Informationen zu Teradata JSONExtractValue, JSONExtractLargeValue und JSONExtract, finden Sie hier.

 JSON_expr.JSONExtractValue(JSONPath_expr)

JSON_expr.JSONExtractLargeValue(JSONPath_expr)

JSON_expr.JSONExtract(JSONPath_expr)

Die JSON_EXTRACT_UDF ist eine Snowflake-Implementierung der JSONPath-Spezifikation, die eine modifizierte Version der ursprünglichen JavaScript-Implementierung von Stefan Goessner verwendet.

 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;

Bekannte Probleme¶

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

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

Zugehörige EWIs¶

Keine zugehörigen EWIs.

Beschreibung¶

Erzeugt eine Tabelle auf der Grundlage des Inhalts eines JSON-Dokuments. Siehe JSON_TABLE Dokumentation.

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

Die Umrechnung von JSON_TABLE hat die unten dargestellten Überlegungen:

• ROW_NUMBER() ist ein Äquivalent für Ordnungszahlspalten in Snowflake.

• In Teradata muss die zweite Spalte von JSON_TABLE vom Typ JSON sein, da die generierten Spalten die zweite Spalte ersetzen. Aus diesem Grund geht SnowConvert AI davon aus, dass die Spalte den richtigen Typ hat, und verwendet ihn für die Transformation.

Beispielhafte Quellcode-Muster¶

 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 |

Bekannte Probleme¶

1. Der Pfad JSON in COLEXPR darf keine mehreren Sternchenzugriffe haben

Die JSON-Pfad in den Spalten darf keine mehrere Listen mit Sternchenzugriff haben, zum Beispiel: $.Names[*].FullNames[*]. Der JSON-Pfad von ROWEXP kann dies hingegen enthalten.

2. Die JSON-Struktur, die in dem COLEXPR-Literal definiert ist, muss eine gültige JSON-Struktur sein

Wenn dies nicht der Fall ist, wird der Benutzer gewarnt, dass die JSON-Struktur fehlerhaft ist.

Zugehörige EWIs¶

Keine zugehörigen EWIs.

Beschreibung¶

Weist eine neue Instanz eines JSON-Datentyps zu. Weitere Informationen finden Sie unter NEW JSON-Konstruktor-Ausdruck 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 } ]

Der zweite Parameter der Funktion NEW JSON wird von SnowConvert AI immer weggelassen, da Snowflake nur mit UTF-8 arbeitet.

Beispielhafte Quellcode-Muster¶

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}'));

Bekannte Probleme¶

1. Der zweite Parameter wird nicht unterstützt

Der zweite Parameter der Funktion, mit dem das Format der resultierenden JSON angegeben wird, wird nicht unterstützt, da Snowflake nur UTF-8 unterstützt, was bei einigen Verwendungen der Funktion zu Funktionsunterschieden führen kann.

2. JSON mit BINARY-Daten wird nicht unterstützt

Snowflake unterstützt nicht das Parsen von Binärdaten zur Erstellung eines JSON-Werts. Benutzende werden gewarnt, wenn SnowConvert AI einen NEW JSON-Wert im Zusammenhang mit Binärdaten findet.

Zugehörige EWIs¶

1. SSC-EWI-TD0039: Eingabeformat nicht unterstützt.

Beschreibung¶

Extrahiert den Wert des Schlüsselwert-Paares, bei dem der Schlüssel mit dem n-ten Vorkommen des angegebenen Suchnamens übereinstimmt. Siehe NVP.

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

Beispielhafte Quellcode-Muster¶

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 ***/;

Bekannte Probleme¶

1. Bei Trennzeichen mit Leerzeichen () muss der Backslash in Snowflake weggelassen werden

In Teradata werden Trennzeichen, die Leerzeichen enthalten, mit „“ angegeben (siehe NVP mit Leerzeichen in Trennzeichen). Wie in den Beispielen gezeigt, ist es in Teradata nicht notwendig, den Backslash zu in Escape-Zeichen zu setzen, in Snowflake hingegen schon. Das Umschließen der Backslashes mit Escape-Zeichen im Trennzeichen kann automatisch durch SnowConvert AI erfolgen, aber nur, wenn die Trennzeichen literale Zeichenfolgen sind. Andernfalls werden Benutzende gewarnt, dass die Backlashes nicht in Escape-Zeichen gesetzt werden konnten und dass dies in Snowflake zu unterschiedlichen Ergebnissen führen kann.

Zugehörige EWIs¶

1. SSC-FDM-TD0008: Bei Trennzeichen, die keine Literale mit Leerzeichen enthalten, muss der Backslash in Snowflake mit Escape-Zeichen versehen werden.

Beschreibung¶

Laut der Dokumentation von Teradata vergleicht der Operator OVERLAPS zwei oder mehr Zeitraumausdrücke. Wenn sie sich überschneiden, gibt er „true“ zurück.

Weitere Informationen zu OVERLAPS in Teradata finden Sie hier.

period_expression
OVERLAPS
period_expression

Die PERIOD_OVERLAPS_UDF ist eine Snowflake-Implementierung des OVERLAPS-Operators in Teradata.

Beispielhaftes Quellcode-Muster¶

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 ***/!!!;

Bekannte Probleme¶

Zugehörige EWIs¶

1. SSC-EWI-TD0053: Snowflake unterstützt nicht den Zeittyp, da alle Zeiträume stattdessen als varchar behandelt werden.

Beschreibung¶

Laut der Dokumentation von Teradata vergleicht der Operator P_INTERSECT zwei oder mehr Zeitraumausdrücke. Wenn sie sich überschneiden, wird der gemeinsame Teil der Zeitraumausdrücke zurückgegeben.

Weitere Informationen zu P_INTERSECT in Teradata finden Sie unter [hier] (https://docs.teradata.com/r/kmuOwjp1zEYg98JsB8fu_A/iW6iefgeyOypFOMY2qGG_A).

period_expression
P_INTERSECT
period_expression

Die PERIOD_INTERSECT_UDF ist eine Snowflake-Implementierung des Operators P_INTERSECT in Teradata.

Beispielhaftes Quellcode-Muster¶

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 ***/!!!;

Bekannte Probleme¶

Zugehörige EWIs¶

1. SSC-EWI-TD0053: Snowflake unterstützt nicht den Zeittyp, da alle Zeiträume stattdessen als varchar behandelt werden.

Beschreibung¶

Die Pivot-Funktion wird verwendet, um Zeilen einer Tabelle in Spalten umzuwandeln. Weitere Informationen finden Sie in der PIVOT Teradata-Dokumentation.

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

Beispielhafte Quellcode-Muster¶

 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         |
--------+-------+------+------+--------------+--------------+--------------+

Bekannte Probleme¶

1. WITH-Klausel nicht unterstützt

Die Verwendung der WITH-Klausel wird derzeit nicht unterstützt.

2. Pivot über mehrere Pivot-Spalten nicht unterstützt

SnowConvert AI transformiert die PIVOT-Funktion in die PIVOT-Funktion in Snowflake, die nur die Anwendung der Funktion auf eine einzelne Spalte unterstützt.

3. Pivot mit mehreren Aggregatfunktionen nicht unterstützt

Die Funktion PIVOT in Snowflake unterstützt nur die Anwendung einer Aggregatfunktion auf die Daten.

4. Unterabfrage in der IN-Klausel nicht unterstützt

Die IN-Klausel der Snowflake PIVOT-Funktion akzeptiert keine Unterabfragen.

5. Aliase werden nur unterstützt, wenn alle IN-Klausel-Elemente sie haben und eine Tabellenspezifikation vorhanden ist

Damit die Spaltennamen mit Aliasnamen gleichwertig sind, muss Folgendes berücksichtigt werden: SnowConvert AI setzt voraus, dass für alle in der IN-Klausel angegebenen Werte ein Alias angegeben und die Tabellenspezifikation im Eingabecode vorhanden ist. Dies ist notwendig, damit SnowConvert AI die Alias-Liste für die resultierende Tabelle erfolgreich erstellen kann.

Zugehörige EWIs¶

1. SSC-EWI-0015: Die pivot/unpivot-Anweisungsformat für die Eingabe wird nicht unterstützt.

Beschreibung¶

RANK sortiert ein Resultset und identifiziert den numerischen Rang jeder Zeile im Ergebnis. Das einzige Argument für RANK ist die Sortierspalte bzw. die Sortierspalten, und die Funktion gibt eine ganze Zahl zurück, die den Rang jeder Zeile im Ergebnis darstellt. (RANK in Teradata)

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

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

Beispielhaftes Quellcode-Muster¶

 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;

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs ¶

Keine zugehörigen EWIs.

Beschreibung¶

Sowohl Teradata als auch Snowflake bieten Unterstützung für Funktionen, die reguläre Ausdrücke auf Varchar-Eingaben anwenden. Weitere Einzelheiten finden Sie in der Teradata-Dokumentation und der Snowflake-Dokumentation.

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)

Beispielhafte Quellcode-Muster¶

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  |

Bekannte Probleme¶

1. Snowflake unterstützt nur POSIX-reguläre Ausdrücke

Benutzende werden gewarnt, wenn SnowConvert AI einen regulären Nicht-POSIX-Ausdruck findet.

2. Die Teradata-Option „match_arg“ ‚l‘ wird in Snowflake nicht unterstützt

Die Option „l“ hat kein Entsprechung in Snowflake und Benutzende werden gewarnt, wenn SnowConvert AI sie findet.

3. Feste Größe des Datentyps CHAR kann zu einer unterschiedlichen Verhaltensweisen führen

Einige Regex-Funktionen in Teradata versuchen, die gesamte Spalte des Datentyps CHAR in einer Tabelle abzugleichen, auch wenn einige der Zeichen in der Spalte leer geblieben sind, weil eine kleinere Zeichenfolge eingefügt wurde. In Snowflake ist dies nicht der Fall, da der Datentyp CHAR eine variable Größe hat.

4. REGEXP_SPLIT\_TO\_TABLE nicht unterstützt

Diese Funktion wird derzeit nicht von Snowflake unterstützt.

Zugehörige EWIs¶

1. SSC-FDM-0007: Element mit fehlenden Abhängigkeiten.

2. SSC-FDM-TD0016: Der Wert „l“ für den Parameter „match_arg“ wird in Snowflake nicht unterstützt.

Beschreibung¶

Zerlegt eine Zeichenfolge in eine Tabelle unter Verwendung der angegebenen Trennzeichen. Weitere Informationen finden Sie unter STRTOK_SPLIT_TO_TABLE.

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

Beispielhafte Quellcode-Muster¶

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;