SnowConvert: Redshift-Funktionen¶

Systemfunktionen¶

IDENTITY¶

Beschreibung ¶

Die Funktion IDENTITY ist eine Systemfunktion, die auf eine bestimmte Spalte einer Tabelle wirkt, um den Anfangswert für die Identität zu bestimmen. Wenn der Anfangswert nicht verfügbar ist, wird standardmäßig der in der Funktion angegebene Wert verwendet. Dies wird in eine Sequenz in Snowflake übersetzt.

Grammatikalische Syntax ¶

 "identity"(oid_id, oid_table_id, default)

Copy

Bemerkung

Diese Funktion wird in Redshift nicht mehr unterstützt. Sie verwendet den Standardwert, um die Identität zu definieren und verhält sich wie eine Standard-Identitätsspalte.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE IF NOT EXISTS table_test
(
    id integer,
    inventory_combo BIGINT  DEFAULT "identity"(850178, 0, '5,3'::text)
);

INSERT INTO table_test (id) VALUES
    (1),
    (2),
    (3),
    (4);

SELECT * FROM table_test;

Copy

id	inventory_combo
1	5
2	8
3	11
3	14

Ausgabecode:

 CREATE TABLE IF NOT EXISTS table_test
(
    id integer,
    inventory_combo BIGINT IDENTITY(5,3) ORDER
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/13/2024",  "domain": "test" }}';

INSERT INTO table_test (id) VALUES
    (1),
    (2),
    (3),
    (4);

SELECT * FROM
    table_test;

Copy

id	inventory_combo
1	5
2	8
3	11
3	14

Zeichenfolgenfunktionen¶

BTRIM¶

Beschreibung ¶

Die Funktion BTRIM kürzt eine Zeichenfolge durch Entfernen führender und nachstehender Leerzeichen oder durch Entfernen führender und nachstehender Zeichen, die mit einer optional angegebenen Zeichenfolge übereinstimmen. (RedShift SQL-Referenz: BTRIM-Funktion)

Grammatikalische Syntax ¶

 BTRIM(string [, trim_chars ] )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Sample Source Patterns

Input Code:

 SELECT '     abc    ' AS untrim, btrim('     abc    ') AS trim;

SELECT 'setuphistorycassettes' AS untrim, btrim('setuphistorycassettes', 'tes') AS trim;

Copy

utrim	trim
abc	abc

untrim	trim
setuphistorycassettes	uphistoryca

Ausgabecode:

 SELECT '     abc    ' AS untrim,
TRIM('     abc    ') AS trim;

SELECT 'setuphistorycassettes' AS untrim,
TRIM('setuphistorycassettes', 'tes') AS trim;

Copy

utrim	trim
abc	abc

untrim	trim
setuphistorycassettes	uphistoryca

Probleme kennen

Es wurden keine Probleme gefunden.

Related EWIs

Es gibt keine bekannten Probleme.

CONCAT

Description

Die Funktion CONCAT verkettet zwei Ausdrücke und gibt den resultierenden Ausdruck zurück. (RedShift SQL-Referenz: CONCAT-Funktion).

Grammar Syntax

 CONCAT ( expression1, expression2 )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE test_concat_function (
    col1 varchar
 );

INSERT INTO test_concat_function
VALUES ('name');

SELECT  CONCAT(col1, ' TEST '),
        "CONCAT"(col1, ' TEST '),
        col1 || ' TEST ' 
FROM test_concat_function;

Copy

CONCAT(col1, ' TEST ')	"CONCAT"(col1, ' TEST ')	col1 \|\| ' TEST '
name TEST	name TEST	name TEST

Ausgabecode:

 CREATE TABLE test_concat_function (
    col1 varchar
 )
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/20/2024",  "domain": "test" }}';

INSERT INTO test_concat_function
VALUES ('name');

SELECT  CONCAT(col1, ' TEST '),
        CONCAT(col1, ' TEST '),
        col1 || ' TEST '
FROM
        test_concat_function;

Copy

CONCAT(NAME, ' TEST ')	"CONCAT"(NAME, ' TEST ')	NAME \|\| ' TEST '
name TEST	name TEST	name TEST

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

LEFT und RIGHT¶

Beschreibung ¶

Diese Funktionen geben die angegebene Anzahl der Zeichen ganz links oder ganz rechts in einer Zeichenfolge zurück. (SQL-Referenzen: LEFT- und RIGHT-Funktion).

Grammatikalische Syntax ¶

 LEFT( string,  integer )

RIGHT( string,  integer )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Sample Source Patterns

Input Code:

 SELECT LEFT('Chicago', 3) AS left_3, RIGHT('Chicago', 3) AS right_3;

Copy

left_3	right_3
Chi	ago

Ausgabecode:

 SELECT LEFT('Chicago', 3) AS left_3, RIGHT('Chicago', 3) AS right_3;

Copy

left_3	right_3
Chi	ago

Know Issues

In Snowflake und Redshift behandeln die Funktionen LEFT und RIGHT negative Werte unterschiedlich:

Snowflake: Gibt eine leere Zeichenfolge zurück, wenn das zweite Argument negativ ist.
Redshift: Erzeugt einen Laufzeitfehler bei negativen Werten.

Related EWIs

Es gibt keine bekannten Probleme.

LOWER

Description

Die Funktion LOWER wandelt eine Zeichenfolge in Kleinbuchstaben um. ([RedShift SQL-Referenz: Lower ](https://docs.aws.amazon.com/redshift/latest/dg/r_LOWER. html)Funktion)

Grammar Syntax

 LOWER ( string )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE test_lower_function (
    col1 varchar
 );

INSERT INTO test_lower_function
VALUES ('test'),
       ('Test'),
       ('TEST');

SELECT  LOWER(COL1),
        "LOWER"(COL1),
        LOWER('vaLues')
FROM test_lower_function;

Copy

LOWER(COL1)	"LOWER"(COL1)	LOWER('vaLues')
test	test	values
test	test	values
test	test	values

Ausgabecode:

 CREATE TABLE test_lower_function (
    col1 varchar
 )
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/21/2024",  "domain": "test" }}';

INSERT INTO test_lower_function
VALUES ('test'),
       ('Test'),
       ('TEST');

SELECT  LOWER(COL1),
        LOWER(COL1),
        LOWER('vaLues')
FROM
        test_lower_function;

Copy

LOWER(COL1)	„LOWER“(COL1)	LOWER(‚vaLues‘)
test	test	Werte
test	test	Werte
test	test	Werte

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

QUOTE_IDENT¶

Beschreibung ¶

Die Funktion QUOTE_IDENT gibt die angegebene Zeichenfolge als Zeichenfolge mit einem führenden und einem nachstehenden doppelten Anführungszeichen zurück. ([RedShift SQL Sprachhinweise QUOTE_IDENT Funktion](https://docs.aws.amazon.com/redshift/latest/dg/r_QUOTE_IDENT. html)).

Um die Funktionalität dieser Funktion zu replizieren, wird sie in eine CONCAT-Funktion umgewandelt.

Grammatikalische Syntax ¶

 QUOTE_IDENT(string)

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Sample Source Patterns

Input Code:

 SELECT 
    QUOTE_IDENT('"CAT"'),
    "QUOTE_IDENT"('Foo bar') ;

Copy

quote\_ident	quote\_ident
„““CAT“““	„Foo bar“““

Ausgabecode:

 SELECT
    CONCAT('"', REPLACE('"CAT"', '"', '""'), '"'),
    CONCAT('"', REPLACE('Foo bar', '"', '""'), '"');

Copy

quote\_ident	quote\_ident
„““CAT“““	„Foo bar“““

Bekannte Probleme

Es wurden keine Probleme gefunden.

Related EWIs

Es gibt keine bekannten Probleme.

REGEXP_REPLACE

Description

Diese Funktion sucht in einer Zeichenfolge nach einem Muster für einen regulären Ausdruck und ersetzt jedes Vorkommen des Musters durch die angegebene Zeichenfolge. ([SQL Sprachhinweise REGEXP_REPLACE Funktion](https://docs.aws.amazon.com/clean-rooms/latest/sql-reference/r_REGEXP_REPLACE. html)).

Grammar Syntax

 REGEXP_REPLACE( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )

Copy

Warnung

Diese Funktion wird teilweise von Snowflake unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE my_table (col1 varchar);
SELECT regexp_replace('the fox', 'FOX', 'quick brown fox', 1, 'ip');
SELECT 
regexp_replace(d, '[hidden]'),
regexp_replace(d, f)
FROM 
(SELECT 
regexp_replace('pASswd7','(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+') as d, 'passwd7' as f);
SELECT regexp_replace(col1, 'passwd7', '[hidden]', 1, 'ip') as rp from my_table;

Copy

regexp_replace	regexp_replace	regexp_replace
the quick brown fox	pASsw7	pASsw7

Ausgabecode:

 CREATE TABLE my_table (col1 varchar)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "00/00/0000",  "domain": "test" }}';
SELECT
REGEXP_REPLACE('the fox', 'FOX', 'quick brown fox', 1, 0, 'i');
SELECT
REGEXP_REPLACE(d, '[hidden]'),
REGEXP_REPLACE(d,
                  --** SSC-FDM-0032 - PARAMETER 'regex_string' IS NOT A LITERAL VALUE, TRANSFORMATION COULD NOT BE FULLY APPLIED **
                  f)
FROM
(SELECT
REGEXP_REPLACE('pASswd7',
                         !!!RESOLVE EWI!!! /*** SSC-EWI-0009 - regexp_replace FUNCTION ONLY SUPPORTS POSIX REGULAR EXPRESSIONS ***/!!!
                         '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+') as d, 'passwd7' as f);
SELECT
REGEXP_REPLACE(col1, 'passwd7', '[hidden]', 1, 0, 'i') as rp from
my_table;

Copy

REGEXP_REPLACE	RESULT
the quick brown fox	100048 (2201B): Ungültiger regulärer Ausdruck: ‚(?=[^ ][a-z])(?=[^ ][0-9])[^ ]+‘, kein Argument für Wiederholungsoperator: ?

Probleme kennen¶

Diese Funktion enthält ein parameters-Argument, das es dem Benutzer ermöglicht, das Muster mit Hilfe des Perl Compatible Regular Expression (PCRE)-Dialekts zu interpretieren, der durch den Wert p repräsentiert wird. Dies wird entfernt, um Probleme bei der Korrektur des Codes zu vermeiden.

Zugehörige EWIs¶

[SSC-EWI-0009](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/teradataEWI. md#ssc-ewi-td0020): Regexp_Substr-Funktion unterstützt nur POSIX-reguläre Ausdrücke.
[SSC-FDM-0032](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0032): Parameter ist kein Literalwert, Transformation konnte nicht vollständig angewendet werden
[SSC-FDM- PG0011](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/postgresqlFDM. md#ssc-fdm-pg0011): Die Verwendung der COLLATE-Spalteneinschränkung wurde für diese Musterabgleichsbedingung deaktiviert.

REPLACE¶

Beschreibung¶

Ersetzt alle Vorkommen einer Gruppe von Zeichen in einer bestehenden Zeichenfolge durch andere angegebene Zeichen. (Redshift SQL-Referenz: REPLACE-Funktion).

Diese Funktion wird in Snowflake vollständig unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammar Syntax

 REPLACE(string, old_chars, new_chars)

Copy

Sample Source Patterns

Input Code:

 SELECT REPLACE('Hello World', ' ', '_') AS modified_string,
       REPLACE('Apple, Orange, Banana, Grape', ',', '') AS fruits,
       REPLACE('http://example.com/path/to/resource', '/path/to', '/new-path') AS updated_url;

Copy

MODIFIED_STRING	FRUITS	UPDATED_URL
Hello_World	Apple Orange Banana Grape	http://example.com/new-path/resource

Ausgabecode:

 SELECT REPLACE('Hello World', ' ', '_') AS modified_string,
       REPLACE('Apple, Orange, Banana, Grape', ',', '') AS fruits,
       REPLACE('http://example.com/path/to/resource', '/path/to', '/new-path') AS updated_url;

Copy

MODIFIED_STRING	FRUITS	UPDATED_URL
Hello_World	Apple Orange Banana Grape	http://example.com/new-path/resource

Known Issues

Es wurden keine Probleme gefunden.

Related EWIs

Es gibt keine bekannten Probleme.

SPLIT_PART

Description

Teilt eine Zeichenfolge an dem angegebenen Trennzeichen und gibt den Teil an der angegebenen Position zurück. ([SQL Sprachhinweise SPLIT_PART-Funktion](https://docs.aws.amazon.com/redshift/latest/dg/SPLIT_PART. html)).

Grammar Syntax

 SPLIT_PART(string, delimiter, position)

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 select split_part('abc$def$ghi','$',2) AS split_1,
split_part('abc$def$ghi','$',4) AS split_2,
split_part('abc$def$ghi','#',1) AS split_3;

Copy

split_1	split_2	split_3
def		abc$def$ghi

Ausgabecode:

 select split_part('abc$def$ghi','$',2) AS split_1,
split_part('abc$def$ghi','$',4) AS split_2,
split_part('abc$def$ghi','#',1) AS split_3;

Copy

split_1	split_2	split_3
def		abc$def$ghi

Probleme kennen¶

Es gibt einen Unterschied in der Verhaltensweise von SPLIT_PART bei der Verwendung von Sortierungen ohne Berücksichtigung der Groß- und Kleinschreibung (CASE_INSENSITIVE oder en-ci) in Snowflake und Redshift.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

SUBSTRING¶

Beschreibung ¶

Gibt die Teilmenge einer Zeichenfolge basierend auf der angegebenen Startposition zurück. (RedShift SUBSTRING Funktion).

Grammatikalische Syntax ¶

 SUBSTRING(character_string FROM start_position [ FOR number_characters ] )

SUBSTRING(character_string, start_position, number_characters )

SUBSTRING(binary_expression, start_byte, number_bytes )

SUBSTRING(binary_expression, start_byte )

Copy

Warnung

Diese Funktion wird in Snowflake teilweise unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT SUBSTRING('machine' FROM 3 for 2) AS machien_3_2, SUBSTRING('machine',1,4) AS machine_1_4;

SELECT SUBSTRING('12345'::varbyte, 2, 4) AS substring_varbyte;

Copy

machine_3_2	machine_1_4
ch	mach

Ausgabecode:

 SELECT SUBSTRING('machine', 3, 2) AS machien_3_2, SUBSTRING('machine',1,4) AS machine_1_4;

SELECT SUBSTRING('12345':: BINARY, 2, 4) !!!RESOLVE EWI!!! /*** SSC-EWI-RS0006 - THE BEHAVIOR OF THE SUBSTRING FUNCTION MAY DIFFER WHEN APPLIED TO BINARY DATA. ***/!!! AS substring_varbyte;

Copy

machine_3_2	machine_1_4
ch	mach

Probleme kennen¶

Wenn die start_position in Redshift 0 oder weniger ist, führt die Funktion SUBSTRING eine mathematische Operation durch (start_position + number_characters). Wenn das Ergebnis 0 oder weniger ist, gibt SUBSTRING eine leere Zeichenfolge zurück. In Snowflake verhält sich start_position anders, wenn es 0 oder weniger ist, was zu unterschiedlichen Ergebnissen führt.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

TRIM¶

Beschreibung ¶

Die Funktion TRIM kürzt eine Zeichenfolge um Leerzeichen oder bestimmte Zeichen. (RedShift SQL-Referenz: TRIM- Funktion)

In Redshift ist es möglich, mit Hilfe von Schlüsselwörtern (BOTH, LEADING oder TRAILING) anzugeben, wo eine Trim-Operation durchgeführt werden soll. Diese Funktionalität kann in Snowflake mit den Funktionen TRIM, LTRIM und RTRIM nachgebildet werden.

Grammatikalische Syntax ¶

 TRIM( [ BOTH | LEADING | TRAILING ] [trim_chars FROM ] string )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Sample Source Patterns

Input Code:

 SELECT TRIM('    dog    ') AS SimpleTrim;

SELECT TRIM(LEADING '"' FROM'"dog"') AS LeadingTrim;

SELECT TRIM(TRAILING '"' FROM'"dog"') AS TrailingTrim;

SELECT TRIM('x' FROM 'xxxHello Worldxxx') AS FromTrim;

Copy

SimpleTrim
dog

LeadingTrim
dog“

TrailingTrim
„dog

FromTrim
Hello World

Ausgabecode:

 SELECT TRIM('    dog    ') AS SimpleTrim;

SELECT
LTRIM('"dog"', '"') AS LeadingTrim;

SELECT
RTRIM('"dog"', '"') AS TrailingTrim;

SELECT
TRIM('xxxHello Worldxxx', 'x') AS FromTrim;

Copy

SimpleTrim
dog

LeadingTrim
dog“

TrailingTrim
„dog

FromTrim
Hello World

Know Issues

Es wurden keine Probleme gefunden.

Related EWIs

Es gibt keine bekannten Probleme.

UPPER

Description

Die Funktion UPPER wandelt eine Zeichenfolge in Großbuchstaben um. ([RedShift SQL-Referenz: Upper](https://docs.aws.amazon.com/redshift/latest/dg/r_UPPER. html)Funktion)

Grammar Syntax

 UPPER ( string )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE test_upper_function (
    col1 varchar
 );

INSERT INTO test_upper_function
VALUES ('test'),
       ('Test'),
       ('TEST');

SELECT  UPPER(COL1),
        "UPPER"(COL1),
        UPPER('vaLues') 
FROM test_upper_function;

Copy

UPPER(COL1)	"UPPER"(COL1)	UPPER('vaLues')
TEST	TEST	VALUES
TEST	TEST	VALUES
TEST	TEST	VALUES

Ausgabecode:

 CREATE TABLE test_upper_function (
    col1 varchar
 )
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/21/2024",  "domain": "test" }}';

INSERT INTO test_upper_function
VALUES ('test'),
       ('Test'),
       ('TEST');

SELECT  UPPER(COL1),
        UPPER(COL1),
        UPPER('vaLues')
FROM
        test_upper_function;

Copy

UPPER(COL1)	„UPPER“(COL1)	UPPER(‚vaLues‘)
TEST	TEST	VALUES
TEST	TEST	VALUES
TEST	TEST	VALUES

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

Aggregatfunktionen¶

AVG¶

Beschreibung¶

Die Funktion AVG gibt den Durchschnitt (arithmetisches Mittel) der Eingabeausdruckswerte zurück. (Redshift SQL-Referenz: AVG-Funktion)

Diese Funktion wird von Snowflake vollständig unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammar Syntax

 AVG ( [ DISTINCT | ALL ] expression )

Copy

Sample Source Patterns

Datenkonfiguration

 CREATE TABLE example_table (
    my_smallint_column SMALLINT,
    my_integer_column INTEGER,
    my_bigint_column BIGINT,
    my_numeric_column NUMERIC,
    my_decimal_column DECIMAL,
    my_real_column REAL,
    my_double_precision_column DOUBLE PRECISION,
    my_super_column SUPER
);


INSERT INTO example_table (
    my_smallint_column,
    my_integer_column,
    my_bigint_column,
    my_numeric_column,
    my_decimal_column,
    my_real_column,
    my_double_precision_column,
    my_super_column
)
VALUES
    (1, 100, 10000000000, 123.45, 678.90, 3.14, 2.71828, 123),
    (2, 200, 20000000000, 234.56, 789.01, 2.71, 3.14159, 456),
    (3, 300, 30000000000, 345.67, 890.12, 1.41, 1.61803, 789),
    (4, 400, 40000000000, 456.78, 901.23, 1.61, 1.41421, 101112),
    (5, 500, 50000000000, 567.89, 123.45, 2.17, 3.14159, 131415);

Copy

 CREATE TABLE example_table (
    my_smallint_column SMALLINT,
    my_integer_column INTEGER,
    my_bigint_column BIGINT,
    my_numeric_column NUMERIC,
    my_decimal_column DECIMAL,
    my_real_column REAL,
    my_double_precision_column DOUBLE PRECISION,
    my_super_column VARIANT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/27/2024",  "domain": "test" }}';


INSERT INTO example_table (
    my_smallint_column,
    my_integer_column,
    my_bigint_column,
    my_numeric_column,
    my_decimal_column,
    my_real_column,
    my_double_precision_column,
    my_super_column
)
VALUES
    (1, 100, 10000000000, 123.45, 678.90, 3.14, 2.71828, 123),
    (2, 200, 20000000000, 234.56, 789.01, 2.71, 3.14159, 456),
    (3, 300, 30000000000, 345.67, 890.12, 1.41, 1.61803, 789),
    (4, 400, 40000000000, 456.78, 901.23, 1.61, 1.41421, 101112),
    (5, 500, 50000000000, 567.89, 123.45, 2.17, 3.14159, 131415);

Copy

Input Code:

 SELECT
    AVG(DISTINCT my_smallint_column) AS type_smallint,
    AVG(ALL my_integer_column) AS type_integer,
    AVG(my_bigint_column) AS type_bigint,
    AVG(my_numeric_column) AS type_numeric,
    AVG(my_decimal_column) AS type_decimal,
    AVG(my_real_column) AS type_real,
    AVG(my_double_precision_column) AS type_double_precision,
    AVG(my_super_column) AS type_super
FROM example_table;

Copy

type_smallint	type_integer	type_bigint	type_numeric	type_decimal	type_real	type_double_precision	type_super
3	300	30000000000	345	676	2,2080000400543214	2,40674	46779

Output Code:

 SELECT
     AVG(DISTINCT my_smallint_column) AS type_smallint,
     AVG(ALL my_integer_column) AS type_integer,
     AVG(my_bigint_column) AS type_bigint,
     AVG(my_numeric_column) AS type_numeric,
     AVG(my_decimal_column) AS type_decimal,
     AVG(my_real_column) AS type_real,
     AVG(my_double_precision_column) AS type_double_precision,
     AVG(my_super_column) AS type_super
FROM example_table;

Copy

type_smallint	type_integer	type_bigint	type_numeric	type_decimal	type_real	type_double_precision	type_super
3,000000	300,000000	30000000000,000000	345,800000	676,400000	2,208	2,40674	46779

Hinweis

AVG, je nach Datentyp kann sich Redshift in Bezug auf Rundung und Formatierung unterschiedlich verhalten, was beim Vergleich von Redshift mit Snowflake zu unterschiedlichen Genauigkeiten oder Dezimalstellen führen kann.

Related EWIs

Es gibt keine bekannten Probleme.

COUNT

Description

Die Funktion COUNT zählt die durch den Ausdruck definierten Zeilen. (Redshift SQL-Referenz: COUNT-Funktion)

[COUNT](https://docs.aws.amazon.com/redshift/latest/dg/r_COUNT. html) und [APPROXIMATE COUNT ](https://docs.aws.amazon.com/redshift/latest/dg/r_COUNT. html) werden in Snowflake vollständig von COUNT und APPROX_COUNT_DISTINCT unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammatikalische Syntax¶

 COUNT ( * | expression )

COUNT ( [ DISTINCT | ALL ] expression )

APPROXIMATE COUNT ( DISTINCT expression )

Copy

Beispielhafte Quellcode-Muster¶

Datenkonfiguration¶

 CREATE TABLE sales (
    sale_id INT PRIMARY KEY,
    product_id INT,
    sale_amount DECIMAL(10, 2),
    sale_date DATE,
    customer_id INT
);

INSERT INTO sales (sale_id, product_id, sale_amount, sale_date, customer_id) VALUES
(1, 101, 100.00, '2024-01-01', 1001),
(2, 102, 200.00, '2024-01-01', 1002),
(3, 101, 150.00, '2024-01-02', 1001),
(4, 103, 250.00, '2024-01-02', 1003),
(5, 102, 300.00, '2024-01-03', 1002),
(6, 101, 200.00, '2024-01-03', 1004),
(7, 101, 120.00, '2024-01-04', 1001),
(8, 102, 180.00, '2024-01-04', 1005),
(9, 103, 300.00, '2024-01-05', 1003),
(10, 101, 130.00, '2024-01-05', 1006),
(10, 101, 130.00, '2024-01-05', 1006);

Copy

Eingabecode:¶

SELECT
    product_id,
    COUNT(sale_id) AS total_sales,
    "COUNT"(DISTINCT sale_id) AS total_sales_distinct,
    "count"(ALL sale_id) AS total_sales_all,
    COUNT(*) AS total_sales_asterisk,
    APPROXIMATE COUNT ( DISTINCT sale_id) AS aprroximate_count_total_sales
FROM
    sales
GROUP BY
    product_id
ORDER BY
    total_sales DESC;

Copy

PRODUCT_ID	TOTAL_SALES	TOTAL_SALES_DISTINCT	TOTAL_SALES_ALL	TOTAL_SALES_ASTERISK	APRROXIMATE_COUNT_TOTAL_SALES
101	6	5	6	6	5
102	3	3	3	3	3
103	2	2	2	2	2

Ausgabecode:¶

 SELECT
    product_id,
    COUNT(sale_id) AS total_sales,
    COUNT(DISTINCT sale_id) AS total_sales_distinct,
    COUNT(ALL sale_id) AS total_sales_all,
    COUNT(*) AS total_sales_asterisk,
    APPROX_COUNT_DISTINCT ( DISTINCT sale_id) AS aprroximate_count_total_sales
FROM
    sales
GROUP BY
    product_id
ORDER BY
    total_sales DESC;

Copy

PRODUCT_ID	TOTAL_SALES	TOTAL_SALES_DISTINCT	TOTAL_SALES_ALL	TOTAL_SALES_ASTERISK	APRROXIMATE_COUNT_TOTAL_SALES
101	6	5	6	6	5
102	3	3	3	3	3
103	2	2	2	2	2

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

Mathematik-Funktionen¶

MAX¶

Beschreibung ¶

Die Funktion MAX gibt den maximalen Wert in einer Reihe von Zeilen zurück. (RedShift SQL-Referenz MAX-Funktion).

Grammatikalische Syntax ¶

 MAX ( [ DISTINCT | ALL ] expression )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Sample Source Patterns

Input Code:

 CREATE TABLE test_max_function (
    col1 INT
 );

INSERT INTO test_max_function
VALUES ('200'),
       ('20'),
       ('2'),
       ('2');

SELECT MAX(COL1), MAX(DISTINCT COL1), MAX(ALL COL1) FROM test_max_function;

Copy

SUM(COL1)	SUM(DISTINCT COL1)	SUM(ALL COL1)
200	200	200

Ausgabecode:

 CREATE TABLE test_max_function (
    col1 INT
 )
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/20/2024",  "domain": "test" }}';

INSERT INTO test_max_function
VALUES ('200'),
       ('20'),
       ('2'),
       ('2');

SELECT MAX(COL1), MAX(DISTINCT COL1), MAX(ALL COL1) FROM
    test_max_function;

Copy

SUM(COL1)	SUM(DISTINCT COL1)	SUM(ALL COL1)
200	200	200

Related EWIs

Es gibt keine bekannten Probleme.

MIN

Description

Die Funktion MIN gibt den Mindestwert in einer Reihe von Zeilen zurück (RedShift SQL-Referenz MIN-Funktion).

Grammar Syntax

 MIN ( [ DISTINCT | ALL ] expression )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE test_min_function (
    col1 INT
 );

INSERT INTO test_min_function
VALUES ('200'),
       ('20'),
       ('2'),
       ('2');

SELECT MIN(COL1), MIN(DISTINCT COL1), MIN(ALL COL1) FROM test_min_function;

Copy

SUM(COL1)	SUM(DISTINCT COL1)	SUM(ALL COL1)
2	2	2

Ausgabecode:

 CREATE TABLE test_min_function (
    col1 INT
 )
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/20/2024",  "domain": "test" }}';

INSERT INTO test_min_function
VALUES ('200'),
       ('20'),
       ('2'),
       ('2');

SELECT MIN(COL1), MIN(DISTINCT COL1), MIN(ALL COL1) FROM
    test_min_function;

Copy

SUM(COL1)	SUM(DISTINCT COL1)	SUM(ALL COL1)
2	2	2

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

NUMERIC¶

Beschreibung ¶

Die Funktion NUMERIC ist eine Systemfunktion, die einen Zeichenfolgenwert in einen numerischen Wert umwandelt.

Diese Funktion wird in Snowflake vollständig unterstützt.

Grammar Syntax

 select "numeric"(VARCHAR);

Copy

Sample Source Patterns

Input Code:

 SELECT "numeric"('2024');

Copy

„numeric“
2024

Ausgabecode:

 SELECT
TO_NUMERIC('2024');

Copy

TO_NUMERIC
2024

Related EWIs

Es gibt keine bekannten Probleme.

ROUND

Description

Die Funktion ROUND rundet Zahlen auf die nächste Ganzzahl oder den nächsten Dezimalwert. (RedShift SQL-Referenz: ROUND-Funktion).

Grammar Syntax

 ROUND(number [ , integer ] )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT 28.05 AS score, ROUND(28.05) AS round_score;
SELECT 15.53969483712 AS comission, ROUND(15.53969483712, 2) AS round_comission;

Copy

score	round_score
28,05	28

comission	round_comission
15.53969483712	15,54

Ausgabecode:

 SELECT 28.05 AS score, ROUND(28.05) AS round_score;
SELECT 15.53969483712 AS comission, ROUND(15.53969483712, 2) AS round_comission;

Copy

score	round_score
28,05	28

comission	round_comission
15.53969483712	15,54

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

SUM¶

Beschreibung ¶

Die Funktion SUM gibt die Summe der Werte der Eingabespalten oder des Ausdrucks zurück. ([RedShift SQL ](https://docs.aws.amazon.com/redshift/latest/dg/r_SUM. html)Referenz: SUM-Funktion)

Grammatikalische Syntax ¶

 SUM ( [ DISTINCT | ALL ] expression )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Sample Source Patterns

Input Code:

 CREATE TABLE test_sum_function (
    col1 INT
 );

INSERT INTO test_sum_function
VALUES ('200'),
       ('20'),
       ('2'),
       ('2');

SELECT SUM(COL1), SUM(DISTINCT COL1), SUM(ALL COL1) FROM test_sum_function;

Copy

SUM(COL1)	SUM(DISTINCT COL1)	SUM(ALL COL1)
224	222	224

Ausgabecode:

 CREATE TABLE test_sum_function (
    col1 INT
 )
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/20/2024",  "domain": "test" }}';

INSERT INTO test_sum_function
VALUES ('200'),
       ('20'),
       ('2'),
       ('2');

SELECT SUM(COL1), SUM(DISTINCT COL1), SUM(ALL COL1) FROM
    test_sum_function;

Copy

SUM(COL1)	SUM(DISTINCT COL1)	SUM(ALL COL1)
224	222	224

Related EWIs

Es gibt keine bekannten Probleme.

TRUNC

Description

Die Funktion TRUNC schneidet Zahlen auf die vorherige Ganzzahl oder Dezimalzahl ab.

Für weitere Informationen lesen Sie bitte die TRUNC-Funktion.

Grammar Syntax

 TRUNC(number [ , integer ])

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE test_trunc_function (
    col1 INT,
    col2 FLOAT
 );

INSERT INTO test_trunc_function
VALUES ('200','111.13'),
       ('20','111.133444'),
       ('2','111.1350');

SELECT TRUNC(col1, -1), TRUNC(col2, -1) FROM test_trunc_function;

Copy

TRUNC(COL1, -1)	TRUNC(COL2, -1)
200	110
20	110
0	110

Ausgabecode:

 CREATE TABLE test_trunc_function (
    col1 INT,
    col2 FLOAT
 )
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/30/2024" }}';

INSERT INTO test_trunc_function
VALUES ('200','111.13'),
       ('20','111.133444'),
       ('2','111.1350');

SELECT TRUNC(col1, -1), TRUNC(col2, -1) FROM test_trunc_function;

Copy

TRUNC(COL1, -1)	TRUNC(COL2, -1)
200	110
20	110
0	110

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

Funktionen zur Formatierung von Datentypen¶

TO_DATE¶

Beschreibung¶

TO_DATE konvertiert ein durch eine Zeichenfolge dargestelltes Datum in einen DATE-Datentyp. (Redshift SQL-Referenz: TO_DATE-Funktion)

Diese Funktion wird in Snowflake vollständig unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammar Syntax

 TO_DATE(string, format, [is_strict])

Copy

Sample Source Patterns

Input Code:

 SELECT TO_DATE('02 Oct 2001', 'DD Mon YYYY');
SELECT TO_DATE('20010631', 'YYYYMMDD', FALSE);
SELECT TO_DATE('20010631', 'YYYYMMDD', TRUE);
SELECT TO_DATE('1,993 12 23', 'Y,YYY MM DD');
SELECT TO_DATE(d, 'YYYY/MM/DD'),
       TO_DATE(d, f)
       FROM (SELECT '2001-01-01'::date as d, 'DD/MM/YYYY' as f);

Copy

to_date	to_date	to_date
2001-10-02	2001-07-01	[22008] ERROR: Datum/Uhrzeit Feld Datumswert außerhalb des Bereichs: 2001-6-31

Output Code:

 SELECT TO_DATE('02 Oct 2001', 'DD Mon YYYY');
SELECT
       TRY_TO_DATE(/*** SSC-FDM-RS0004 - INVALID DATES WILL CAUSE ERRORS IN SNOWFLAKE ***/ '20010631', 'YYYYMMDD');
SELECT TO_DATE('20010631', 'YYYYMMDD');
SELECT TO_DATE('1,993 12 23', 'Y,YYY MM DD') !!!RESOLVE EWI!!! /*** SSC-EWI-PG0005 - Y,YYY MM DD FORMAT MAY FAIL OR MAY HAVE A DIFFERENT BEHAVIOR IN SNOWFLAKE. ***/!!!;
SELECT TO_DATE(d, 'YYYY/MM/DD'),
       --** SSC-FDM-0032 - PARAMETER 'format_string' IS NOT A LITERAL VALUE, TRANSFORMATION COULD NOT BE FULLY APPLIED **
       TO_DATE(d, f)
       FROM (SELECT '2001-01-01'::date as d, 'DD/MM/YYYY' as f);

Copy

to_date	to_date	to_date
2001-10-02	NULL	Kann ‚20010631‘ nicht als Datum mit dem Format ‚YYYYMMDD‘ auswerten

Known Issues

Die Abfrage SELECT TO_DATE('20010631', 'YYYYMMDD') schlägt in Snowflake fehl, da der Juni nur 30 Tage hat und Snowflakes TO_DATE ungültige Daten nicht automatisch anpasst, im Gegensatz zu Redshifts TO_DATE mit is_strict, das auf „false“ gesetzt ist, wodurch es auf den 1. Juli umgestellt würde. Um Fehler bei ungültigen Datumszeichenfolgen zu vermeiden, können Sie TRY_TO_DATE verwenden, das NULL zurückgibt, wenn die Konvertierung fehlschlägt. Dies ermöglicht eine reibungslosere Ausführung von Abfragen und eine einfachere Identifizierung ungültiger Daten.

Related EWIs

[SSC-FDM-RS0004](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/redshiftFDM. md#ssc-fdm-rs0004): Ungültige Datumsangaben führen zu Fehlern in Snowflake.
[SSC-EWI-PG0005](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/postgresEWI. md#ssc-ewi-pg0005): Das Datums- oder Zeitformat wird in Snowflake nicht unterstützt.
[SSC-FDM-0032](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0032): Parameter ist kein Literalwert, Transformation konnte nicht vollständig angewendet werden

TO_CHAR

Description

TO_CHAR konvertiert einen Zeitstempel oder numerischen Ausdruck in ein Zeichenfolgen-Datenformat. ([Redshift SQL-Referenz: TO_CHAR-Funktion](https://docs.aws.amazon.com/redshift/latest/dg/r_TO_CHAR. html))

Warnung

Diese Funktion wird in Snowflake teilweise unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammatikalische Syntax¶

 TO_CHAR(timestamp_expression | numeric_expression , 'format')

Copy

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT TO_CHAR(timestamp '2009-12-31 23:15:59', 'YYYY'),
       TO_CHAR(timestamp '2009-12-31 23:15:59', 'YYY'),
       TO_CHAR(timestamp '2009-12-31 23:15:59', 'TH'),
       "to_char"(timestamp '2009-12-31 23:15:59', 'MON-DY-DD-YYYY HH12:MIPM'),
       TO_CHAR(125.8, '999.99'),
       "to_char"(125.8, '999.99');

Copy

TO_CHAR	TO_CHAR	TO_CHAR	TO_CHAR	TO_CHAR
2009	009	DEC-THU-31-2009 11:15PM	125,80	125,80

Ausgabecode:¶

 SELECT
       TO_CHAR(timestamp '2009-12-31 23:15:59', 'YYYY'),
       PUBLIC.YEAR_PART_UDF(timestamp '2009-12-31 23:15:59', 3),
       TO_CHAR(timestamp '2009-12-31 23:15:59', 'TH') !!!RESOLVE EWI!!! /*** SSC-EWI-PG0005 - TH FORMAT MAY FAIL OR MAY HAVE A DIFFERENT BEHAVIOR IN SNOWFLAKE. ***/!!!,
       PUBLIC.MONTH_SHORT_UDF(timestamp '2009-12-31 23:15:59', 'uppercase') || '-' || PUBLIC.DAYNAME_SHORT_UDF(timestamp '2009-12-31 23:15:59', 'uppercase') || TO_CHAR(timestamp '2009-12-31 23:15:59', '-DD-YYYY HH12:MI') || PUBLIC.MERIDIAN_INDICATORS_UDF(timestamp '2009-12-31 23:15:59', 'uppercase'),
       TO_CHAR(125.8, '999.99'),
       TO_CHAR(125.8, '999.99');

Copy

TO_CHAR	TO_CHAR
2009	Dec-Thu-31-2009 11:15PM

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

[SSC-EWI-PG0005](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/postgresEWI. md#ssc-ewi-pg0005): Das aktuelle Datums-/Nummernformat kann sich in Snowflake anders verhalten.

Für Datetimes-Werte¶

Beschreibung¶

Die folgenden Formatzeichenfolgen gelten für Funktionen wie TO_CHAR. Diese Zeichenfolgen können Datetime-Trennzeichen enthalten (z. B. „-“, „/“, oder „:“) und die folgenden „dateparts“ und „timeparts“. (Redshift-Referenzseite Datetime-Formatzeichenfolgen)

Grammatikalische Syntax¶

TO_CHAR (timestamp_expression, 'format')

Copy

In der folgenden Tabelle finden Sie die Zuordnung der einzelnen Formatelemente zu Snowflake:

Redshift	Snowflake	Anmerkungen
`BC, AD, bc, ad` (Groß- und Kleinbuchstaben als Ära-Indikatoren)	`PUBLIC.ERA_INDICATORS_UDF`
`B.C.,. A.D., b.c., a.d.` (Groß- und Kleinbuchstaben Ära-Indikatoren mit Punkten)	`PUBLIC.ERA_INDICATORS_WITH_POINTS_UDF`
`CC`	`PUBLIC.CENTURY_UDF`
`YYYY` und `YY`	-	Direkt unterstützt
`YYY` und `Y`	`PUBLIC.YEAR_PART_UDF`
`Y,YYY`	`PUBLIC.YEAR_WITH_COMMA_UDF`
`IYYY`	`YEAROFWEEKISO`
`I, IY, IYY`	`PUBLIC.ISO_YEAR_PART_UDF`
`Q`	`QUARTER`
`MONTH, Month, month`	`PUBLIC.FULL_MONTH_NAME_UDF`
`MON, Mon, mon`	`PUBLIC.MONTH_SHORT_UDF`
`RM, rm`	`PUBLIC.ROMAN_NUMERALS_MONTH_UDF`
`W`	`PUBLIC.WEEK_OF_MONTH_UDF`
`WW`	`PUBLIC.WEEK_NUMBER_UDF`
`IW`	`WEEKISO`
`DAY, Day, day`	`PUBLIC.DAYNAME_LONG_UDF`
`DY, Dy, dy`	`PUBLIC.DAYNAME_SHORT_UDF`
`DDD`	`DAYOFYEAR`
`IDDD`	`PUBLIC.DAY_OF_YEAR_ISO_UDF`
`D`	`PUBLIC.DAY_OF_WEEK_UDF`	Damit diese UDF korrekt funktioniert, sollte der Snowflake-Sitzungsparameter `WEEK_START` den Standardwert haben (`0`)
`ID`	`DAYOFWEEKISO`
`J`	`PUBLIC.JULIAN_DAY_UDF`
`HH24`	-	Direkt unterstützt
`HH`	`HH12`
`HH12`	-	Direkt unterstützt
`MI`	-	Direkt unterstützt
`SS`	-	Direkt unterstützt
`MS`	`FF3`
`US`	`FF6`
`AM, PM, am, pm` (Groß- und Kleinbuchstaben-Meridianindikatoren)	`PUBLIC.MERIDIAN_INDICATORS_UDF`
`A.M., P.M., a.m., p.m.` (Groß- und Kleinschreibung der Meridianindikatoren mit Punkten)	`PUBLIC.MERIDIAN_INDICATORS_WITH_POINTS_UDF`
`TZ` und `tz`	`UTC` und `utc`	Laut der redshift-Dokumentation werden alle Zeitstempel mit Zeitzone in UTC gespeichert, was dazu führt, dass dieses Format-Element ein festes Ergebnis liefert
`OF`	`+00`	Laut der redshift-Dokumentation werden alle Zeitstempel mit Zeitzone in UTC gespeichert, was dazu führt, dass dieses Format-Element ein festes Ergebnis liefert
`SSSS`	`PUBLIC.SECONDS_PAST_MIDNIGHT`
`SP`		Dies ist ein PostgreSQL Template-Muster-Modifikator für „spell mode“, der jedoch bei Redshift nichts bewirkt und daher aus der Ausgabe entfernt wird.
`FX`		Dies ist ein weiterer Vorlagenmuster-Modifikator für „festes Format“, der jedoch in der Funktion TO_CHAR keine Verwendung findet und daher entfernt wird.

Beispielhafte Quellcode-Muster¶

Direkte Transformation von Formatelementen (keine Funktionen/UDFs)¶

Das Ergebnis wird als eine einzige TO_CHAR-Funktion erhalten

Redshift¶

 SELECT TO_CHAR('2013-10-03 13:50:15.456871'::TIMESTAMP, 'DD/MM/YY HH:MI:SS.MS') AS col1;

Copy

+----------------------+
|col1                  |
+----------------------+
|03/10/13 01:50:15.456 |
+----------------------+

Copy

Snowflake¶

 SELECT TO_CHAR('2013-10-03 13:50:15.456871'::TIMESTAMP, 'DD/MM/YY HH12:MI:SS.FF3') AS col1;

Copy

+----------------------+
|col1                  |
+----------------------+
|03/10/13 01:50:15.456 |
+----------------------+

Copy

Formattransformation mit Funktionen/UDFs¶

Das Ergebnis ist eine Verkettung mehrerer TO_CHAR, UDFs und integrierter Snowflake-Funktionen, die die entsprechende Zeichenfolgendarstellung des Werts für Datum und Uhrzeit erzeugen

Redshift¶

 SELECT TO_CHAR(DATE '2025-07-05', '"Today is " Month DAY DD, "it belongs to the week " IW') AS result;

Copy

+-------------------------------------------------------------+
|result                                                       |
+-------------------------------------------------------------+
|Today is  July      SATURDAY  05, it belongs to the week  27 |
+-------------------------------------------------------------+

Copy

Snowflake¶

 SELECT
    'Today is ' ||
    TO_CHAR(DATE '2025-07-05', ' ') ||
    PUBLIC.FULL_MONTH_NAME_UDF(DATE '2025-07-05', 'firstOnly') ||
    ' ' ||
    PUBLIC.DAYNAME_LONG_UDF(DATE '2025-07-05', 'uppercase') ||
    TO_CHAR(DATE '2025-07-05', ' DD, ') ||
    'it belongs to the week ' ||
    TO_CHAR(DATE '2025-07-05', ' ') ||
    WEEKISO(DATE '2025-07-05') AS result;

Copy

+-------------------------------------------------------------+
|result                                                       |
+-------------------------------------------------------------+
|Today is  July      SATURDAY  05, it belongs to the week  27 |
+-------------------------------------------------------------+

Copy

Zitierter Text¶

Formatelemente in doppelten Anführungszeichen werden direkt in die Ausgabe eingefügt, ohne dass sie interpretiert werden, doppelte Anführungszeichen mit Escapezeichen werden in ihr Snowflake-Äquivalent umgewandelt.

Redshift¶

 SELECT
    TO_CHAR(DATE '2025-01-16', 'MM "TESTING DD" DD') AS result1,
    TO_CHAR(DATE '2025-01-16', 'MM TESTING \\"DD\\" DD') AS result2,
    TO_CHAR(DATE '2025-01-16', 'MM "TESTING \\"DD\\"" DD') AS result3;

Copy

+-----------------+-------------------+-------------------+
|result1          |result2            |result3            |
+-----------------+-------------------+-------------------+
|01 TESTING DD 16 |01 TEST5NG "16" 16 |01 TESTING "DD" 16 |
+-----------------+-------------------+-------------------+

Copy

Snowflake¶

 SELECT
    TO_CHAR(DATE '2025-01-16', 'MM ') || 'TESTING DD' || TO_CHAR(DATE '2025-01-16', ' DD') AS result1,
    TO_CHAR(DATE '2025-01-16', 'MM TEST') || PUBLIC.ISO_YEAR_PART_UDF(DATE '2025-01-16', 1) || TO_CHAR(DATE '2025-01-16', 'NG ""DD"" DD') AS result2,
    TO_CHAR(DATE '2025-01-16', 'MM ') || 'TESTING "DD"' || TO_CHAR(DATE '2025-01-16', ' DD') AS result3;

Copy

+-----------------+-------------------+-------------------+
|result1          |result2            |result3            |
+-----------------+-------------------+-------------------+
|01 TESTING DD 16 |01 TEST5NG "16" 16 |01 TESTING "DD" 16 |
+-----------------+-------------------+-------------------+

Copy

Bekannte Probleme¶

Vorlagenmuster-Modifikatoren nicht unterstützt¶

Die folgenden Formatvorlagen-Modifikatoren:

FM (Füllmodus)
TH und th (Suffix der Ordnungszahl in Groß- und Kleinbuchstaben)
TM (Übersetzungsmodus)

Werden nicht unterstützt, ihre Aufnahme in ein Format erzeugt [SSC-EWI-PG0005](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/postgresEWI. md#ssc-ewi-pg0005)

Eingabecode:

 SELECT TO_CHAR(CURRENT_DATE, 'FMMonth'),
TO_CHAR(CURRENT_DATE, 'DDTH'),
TO_CHAR(CURRENT_DATE, 'DDth'),
TO_CHAR(CURRENT_DATE, 'TMMonth');

Copy

Ausgabecode:

 SELECT
TO_CHAR(CURRENT_DATE(), 'FM') || PUBLIC.FULL_MONTH_NAME_UDF(CURRENT_DATE(), 'firstOnly') !!!RESOLVE EWI!!! /*** SSC-EWI-PG0005 - FMMonth FORMAT MAY FAIL OR MAY HAVE A DIFFERENT BEHAVIOR IN SNOWFLAKE. ***/!!!,
TO_CHAR(CURRENT_DATE(), 'DDTH') !!!RESOLVE EWI!!! /*** SSC-EWI-PG0005 - DDTH FORMAT MAY FAIL OR MAY HAVE A DIFFERENT BEHAVIOR IN SNOWFLAKE. ***/!!!,
TO_CHAR(CURRENT_DATE(), 'DDth') !!!RESOLVE EWI!!! /*** SSC-EWI-PG0005 - DDth FORMAT MAY FAIL OR MAY HAVE A DIFFERENT BEHAVIOR IN SNOWFLAKE. ***/!!!,
TO_CHAR(CURRENT_DATE(), 'TM') || PUBLIC.FULL_MONTH_NAME_UDF(CURRENT_DATE(), 'firstOnly') !!!RESOLVE EWI!!! /*** SSC-EWI-PG0005 - TMMonth FORMAT MAY FAIL OR MAY HAVE A DIFFERENT BEHAVIOR IN SNOWFLAKE. ***/!!!;

Copy

Parameter formatieren, der über die Variable übergeben wird

Wenn der Format-Parameter als Variable statt als String-Literal übergeben wird, kann die Transformation von Format-Elementen nicht angewandt werden. In den Verwendungen der Funktion wird eine FDM hinzugefügt, die darauf hinweist.

Eingabecode:

 SELECT TO_CHAR(d, 'YYYY/MM/DD'),
TO_CHAR(d, f)
FROM (SELECT TO_DATE('2001-01-01','YYYY-MM-DD') as d, 'DD/MM/YYYY' as f);

Copy

Ausgabecode:

 SELECT TO_CHAR(d, 'YYYY/MM/DD'),
--** SSC-FDM-0032 - PARAMETER 'format_string' IS NOT A LITERAL VALUE, TRANSFORMATION COULD NOT BE FULLY APPLIED **
TO_CHAR(d, f)
FROM (SELECT TO_DATE('2001-01-01','YYYY-MM-DD') as d, 'DD/MM/YYYY' as f);

Copy

Zugehörige EWIs¶

[SSC-EWI-PG0005](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/postgresEWI. md#ssc-ewi-pg0005): Das aktuelle Datums-/Nummernformat kann sich in Snowflake anders verhalten.
[SSC-FDM-0032](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0032): Parameter ist kein Literalwert, Transformation konnte nicht vollständig angewendet werden

JSON-Funktionen¶

JSON_EXTRACT_PATH_TEXT¶

Beschreibung ¶

Die Funktion JSON_EXTRACT_PATH_TEXT gibt den Wert für das Schlüsselwert-Paar zurück, auf das eine Reihe von Pfadelementen in einer JSON-Zeichenfolge verweist. ([RedShift SQL ](https://docs.aws.amazon.com/redshift/latest/dg/r_SUM. html)[Referenz: JSON_EXTRACT_PATH_TEXT- Funktion](https://docs.aws.amazon.com/redshift/latest/dg/JSON_EXTRACT_PATH_TEXT. html))

Grammatikalische Syntax ¶

 JSON_EXTRACT_PATH_TEXT('json_string', 'path_elem' [,'path_elem'[, …] ]              [, null_if_invalid ] )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Sample Source Patterns

Input Code:

 SELECT
'{
  "house": {
    "address": {
      "street": "123 Any St.",
      "city": "Any Town",
      "state": "FL",
      "zip": "32830"
    },
    "bathroom": {
      "color": "green",
      "shower": true
    },
    "appliances": {
      "washing machine": {
        "brand": "Any Brand",
        "color": "beige"
      },
      "dryer": {
        "brand": "Any Brand",
        "color": "white"
      }
    }
  }
}' as VALID_JSON,
'notvalidjson' as INVALID_JSON,
JSON_EXTRACT_PATH_TEXT(VALID_JSON, 'house', 'appliances', 'washing machine', 'brand') AS VALID_JSON_FLAG_DEFAULT_OFF,
JSON_EXTRACT_PATH_TEXT(VALID_JSON, 'house', 'appliances', 'washing machine', 'brand', false) AS VALID_JSON_FLAG_OFF,
JSON_EXTRACT_PATH_TEXT(VALID_JSON, 'house', 'appliances', 'washing machine', 'brand', true) AS VALID_JSON_FLAG_TRUE,
JSON_EXTRACT_PATH_TEXT(INVALID_JSON, 'house', 'appliances', 'washing machine', 'brand', true) AS INVALID_JSON_FLAG_TRUE,
JSON_EXTRACT_PATH_TEXT(INVALID_JSON, 'house', 'appliances', 'washing machine', 'brand', false) AS INVALID_JSON_FLAG_FALSE
;

Copy

VALID_JSON	INVALID_JSON	VALID_JSON_FLAG_DEFAULT_OFF	VALID_JSON_FLAG_OFF	VALID_JSON_FLAG_TRUE	INVALID_JSON_FLAG_TRUE
-	notvalidjson	Any Brand	Any Brand	Any Brand	NULL

Ausgabecode:

 SELECT
'{
  "house": {
    "address": {
      "street": "123 Any St.",
      "city": "Any Town",
      "state": "FL",
      "zip": "32830"
    },
    "bathroom": {
      "color": "green",
      "shower": true
    },
    "appliances": {
      "washing machine": {
        "brand": "Any Brand",
        "color": "beige"
      },
      "dryer": {
        "brand": "Any Brand",
        "color": "white"
      }
    }
  }
}' as VALID_JSON,
'notvalidjson' as INVALID_JSON,
JSON_EXTRACT_PATH_TEXT(VALID_JSON, ARRAY_TO_STRING(['house', 'appliances', '"washing machine"', 'brand'], '.')) AS VALID_JSON_FLAG_DEFAULT_OFF,
JSON_EXTRACT_PATH_TEXT(VALID_JSON, ARRAY_TO_STRING(['house', 'appliances', '"washing machine"', 'brand'], '.')) AS VALID_JSON_FLAG_OFF,
JSON_EXTRACT_PATH_TEXT(TRY_PARSE_JSON(VALID_JSON), ARRAY_TO_STRING(['house', 'appliances', '"washing machine"', 'brand'], '.')) AS VALID_JSON_FLAG_TRUE,
JSON_EXTRACT_PATH_TEXT(TRY_PARSE_JSON(INVALID_JSON), ARRAY_TO_STRING(['house', 'appliances', '"washing machine"', 'brand'], '.')) AS INVALID_JSON_FLAG_TRUE,
JSON_EXTRACT_PATH_TEXT(INVALID_JSON, ARRAY_TO_STRING(['house', 'appliances', '"washing machine"', 'brand'], '.')) AS INVALID_JSON_FLAG_FALSE
;

Copy

VALID_JSON	INVALID_JSON	VALID_JSON_FLAG_DEFAULT_OFF	VALID_JSON_FLAG_OFF	VALID_JSON_FLAG_TRUE	INVALID_JSON_FLAG_TRUE
-	notvalidjson	Any Brand	Any Brand	Any Brand	NULL

Eingabe von Code mit Variablen als Pfade:

 SELECT
  'appliances' level_2,
  'brand' level_4,
  JSON_EXTRACT_PATH_TEXT(
    INFO.VALID_JSON,
    'house',
    level_2,
    'washing machine',
    level_4
  ) result
FROM
  (
    SELECT
      '{
  "house": {
    "address": {
      "street": "123 Any St.",
      "city": "Any Town",
      "state": "FL",
      "zip": "32830"
    },
    "bathroom": {
      "color": "green",
      "shower": true
    },
    "appliances": {
      "washing machine": {
        "brand": "Any Brand",
        "color": "beige"
      },
      "dryer": {
        "brand": "Any Brand",
        "color": "white"
      }
    }
  }
}' AS VALID_JSON
  ) INFO;

Copy

level_2	level_4	Ergebnis
appliances	brand	Any Brand

Ausgabecode:

 SELECT
  'appliances' level_2,
  'brand' level_4,
  JSON_EXTRACT_PATH_TEXT(
  INFO.VALID_JSON, ARRAY_TO_STRING(['house',
  level_2, '"washing machine"',
  level_4], '.')) result
FROM
  (
    SELECT
      '{
  "house": {
    "address": {
      "street": "123 Any St.",
      "city": "Any Town",
      "state": "FL",
      "zip": "32830"
    },
    "bathroom": {
      "color": "green",
      "shower": true
    },
    "appliances": {
      "washing machine": {
        "brand": "Any Brand",
        "color": "beige"
      },
      "dryer": {
        "brand": "Any Brand",
        "color": "white"
      }
    }
  }
}' AS VALID_JSON
  ) INFO;

Copy

level_2	level_4	Ergebnis
appliances	brand	Any Brand

Known Issues

Redshift behandelt andere Zeichen als Snowflake, wenn es sich um Zeilenumbrüche, Tabulatoren und Wagen handelt. Redshift interpretiert die Zeichen als die Zeichen selbst. Snowflake wendet es an.
Die Funktion Snowflake erhält zwei Parameter: Der erste ist das JSON Literal und der zweite ist der durch einen Punkt getrennte Pfad, um auf die inneren Objekte zuzugreifen. Die Transformation ersetzt die Liste der Pfade durch eine Funktion, die die durch Punkte getrennten Pfade verbindet, auch wenn es sich um einen Spaltenverweis handelt.
Wenn der Pfad über eine Variable gesendet wird und die Variable Leerzeichen enthält, sollte sie in Anführungszeichen gesetzt werden.

Related EWIs

Es wurden keine Probleme gefunden.

Hashfunktionen

FNV_HASH

Description

FNV_HASH Berechnet die 64-Bit FNV-1a nicht kryptografische Hash-Funktion für alle Basisdatentypen.\ ([Redshift SQL-Referenz: FNV_HASH-Funktion](https://docs.aws.amazon.com/redshift/latest/dg/r_FNV_HASH. html)).

Bemerkung

In Snowflake gibt es keine entsprechende Funktion, die den FNV-Algorithmus bereitstellt, aber die HASH-Funktion bietet die gleiche nicht-kryptographische Funktionalität.

Grammatikalische Syntax¶

 FNV_HASH(value [, seed])

Copy

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT FNV_HASH('John Doe') as FNV_HASH,
       FNV_HASH('John Doe', 3) as FNV_HASH_SEED;

Copy

FNV_HASH	FNV_HASH_SEED
-1568545727084176168	-5484851035903916490

Ausgabecode:¶

 SELECT
       HASH('John Doe') as FNV_HASH,
       HASH('John Doe') as FNV_HASH_SEED;

Copy

FNV_HASH	FNV_HASH_SEED
3199932455444588441	3199932455444588441

Bemerkung

In der Funktion FNV_HASH von Redshift ist der Seed-Parameter optional, aber er wird in der Hashwert-Funktion von Snowflake nicht verwendet, da der Seed-Parameter nur beim Algorithmus FNV verwendet wird.

Bekannte Probleme ¶

Es gibt keine bekannten Probleme.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

Bedingte Funktionen¶

COALESCE¶

Beschreibung ¶

Gibt den Wert des ersten Ausdrucks zurück, der in einer Reihe von Ausdrücken nicht null ist. Wenn ein Nicht-Null-Wert gefunden wird, werden die restlichen Ausdrücke in der Liste nicht ausgewertet.

Für weitere Informationen lesen Sie bitte die COALESCE-Funktion.

Grammatikalische Syntax ¶

 COALESCE( expression, expression, ... )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Sample Source Patterns

Input Code:

 CREATE TABLE suppliers (
  supplier_id INT PRIMARY KEY,
  supplier_name VARCHAR(30),
  phone_region_1 VARCHAR(15),
  phone_region_2 VARCHAR(15));

INSERT INTO suppliers(supplier_id, supplier_name, phone_region_1, phone_region_2)
  VALUES(1, 'Company_ABC', NULL, '555-01111'),
        (2, 'Company_DEF', '555-01222', NULL),
        (3, 'Company_HIJ', '555-01333', '555-01444'),
        (4, 'Company_KLM', NULL, NULL); 

SELECT COALESCE(phone_region_1, phone_region_2) IF_REGION_1_NULL,
       COALESCE(phone_region_2, phone_region_1) IF_REGION_2_NULL
  FROM suppliers
  ORDER BY supplier_id;

Copy

IF_REGION_1_NULL	IF_REGION_2_NULL
555-01111	555-01111
555-01222	555-01222
555-01333	555-01444
null	null

Ausgabecode:

 CREATE TABLE suppliers (
  supplier_id INT PRIMARY KEY,
  supplier_name VARCHAR(30),
  phone_region_1 VARCHAR(15),
  phone_region_2 VARCHAR(15))
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/27/2024" }}';

INSERT INTO suppliers (supplier_id, supplier_name, phone_region_1, phone_region_2)
  VALUES(1, 'Company_ABC', NULL, '555-01111'),
        (2, 'Company_DEF', '555-01222', NULL),
        (3, 'Company_HIJ', '555-01333', '555-01444'),
        (4, 'Company_KLM', NULL, NULL);

SELECT COALESCE(phone_region_1, phone_region_2) IF_REGION_1_NULL,
       COALESCE(phone_region_2, phone_region_1) IF_REGION_2_NULL
  FROM
       suppliers
  ORDER BY supplier_id;

Copy

IF_REGION_1_NULL	IF_REGION_2_NULL
555-01111	555-01111
555-01222	555-01222
555-01333	555-01444
null	null

Related EWIs

Es gibt keine bekannten Probleme.

GREATEST und LEAST

Description

Gibt den größten oder kleinsten Wert aus einer Liste mit einer beliebigen Anzahl von Ausdrücken zurück. ([Redshift SQL-Referenz: GREATEST und LEAST Funktion](https://docs.aws.amazon.com/redshift/latest/dg/r_GREATEST_LEAST. html))

Grammar Syntax

 GREATEST (value [, ...])
LEAST (value [, ...])

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT GREATEST(10, 20, NULL, 40, 30) AS greatest, LEAST(10, 20, NULL, 40, 30) AS least, GREATEST(NULL, NULL, NULL) AS nulls;

SELECT LEAST('GERMANY', 'USA') AS LEAST, GREATEST('GERMANY', 'USA') AS GREATEST;

Copy

greatest	least	nulls
40	10	25

least	greatest
GERMANY	USA

Ausgabecode:

 SELECT
GREATEST_IGNORE_NULLS(10, 20, NULL, 40, 30) AS greatest,
LEAST_IGNORE_NULLS(10, 20, NULL, 40, 30) AS least,
GREATEST_IGNORE_NULLS(NULL, NULL, NULL) AS nulls;

SELECT
LEAST_IGNORE_NULLS(RTRIM('GERMANY'), RTRIM('USA')) AS LEAST,
GREATEST_IGNORE_NULLS(RTRIM('GERMANY'), RTRIM('USA')) AS GREATEST;

Copy

greatest	least	nulls
40	10	NULL

least	greatest
GERMANY	USA

Bekannte Probleme¶

Es gibt keine bekannten Probleme

Zugehörige EWIs¶

NULLIF¶

Beschreibung ¶

Der Ausdruck NULLIF vergleicht zwei Argumente und gibt null zurück, wenn die Argumente gleich sind. Wenn sie nicht gleich sind, wird das erste Argument zurückgegeben. In Redshift ignoriert NULLIF nachstehende Leerzeichen beim Vergleich von String-Werten in bestimmten Szenarien. Daher kann sich die Verhaltensweise von Redshift und Snowflake unterscheiden. Aus diesem Grund wird in der Transformation RTRIM hinzugefügt, um die Äquivalenz zwischen Redshift und Snowflake zu erhalten (Redshift SQL-Referenz: NULLIF-Funktion)

Grammatikalische Syntax ¶

 NULLIF ( expression1, expression2 )

Copy

Diese Funktion wird von Snowflake vollständig unterstützt.

Sample Source Patterns

Input Code:

 SELECT NULLIF('first', 'second') AS different, NULLIF('first', 'first') AS same;

Copy

different	same
first	NULL

Ausgabecode:

 SELECT NULLIF(RTRIM('first'), RTRIM('second')) AS different, NULLIF(RTRIM('first'), RTRIM('first')) AS same;

Copy

different	same
first	NULL

Known Issues

Es gibt keine bekannten Probleme.

Related EWIs

Es sind keine EWIs bekannt.

NVL

Description

Gibt den Wert des ersten Ausdrucks zurück, der in einer Reihe von Ausdrücken nicht null ist. Wenn ein Nicht-Null-Wert gefunden wird, werden die restlichen Ausdrücke in der Liste nicht ausgewertet. (Redshift SQL-Referenz Referenz NVL-Funktion)

In RedShift kann NVL 2 oder mehr Argumente enthalten, während die Funktion NVL in Snowflake nur 2 Argumente akzeptiert. Um dieselbe Verhaltensweise zu emulieren, wird NVL mit 3 oder mehr Argumenten in die Funktion COALESCE umgewandelt.

Diese Funktion wird von Snowflake vollständig unterstützt.

Grammatikalische Syntax ¶

 NVL( expression, expression, ... )

Copy

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE suppliers (
  supplier_id INT PRIMARY KEY,
  supplier_name VARCHAR(30),
  phone_region_1 VARCHAR(15),
  phone_region_2 VARCHAR(15),
  phone_region_3 VARCHAR(15));

INSERT INTO suppliers(supplier_id, supplier_name, phone_region_1, phone_region_2, phone_region_3)
  VALUES(1, 'Company_ABC', NULL, '555-01111', NULL),
        (2, 'Company_DEF', '555-01222', NULL, NULL),
        (3, 'Company_HIJ', '555-01333', '555-01444', NULL),
        (4, 'Company_KLM', NULL, NULL, NULL); 

SELECT NVL(phone_region_1, phone_region_2) IF_REGION_1_NULL,
       NVL(phone_region_2, phone_region_1) IF_REGION_2_NULL,
       NVL(phone_region_2, phone_region_1, phone_region_3) THREE_ARG_NVL
  FROM suppliers
  ORDER BY supplier_id;

Copy

IF_REGION_1_NULL	IF_REGION_2_NULL	IF_REGION_3_NULL
555-01111	555-01111	555-01111
555-01222	555-01222	555-01222
555-01333	555-01444	555-01444
null	null	null

Ausgabecode:

 CREATE TABLE suppliers (
  supplier_id INT PRIMARY KEY,
  supplier_name VARCHAR(30),
  phone_region_1 VARCHAR(15),
  phone_region_2 VARCHAR(15),
  phone_region_3 VARCHAR(15))
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/26/2024",  "domain": "test" }}';

INSERT INTO suppliers (supplier_id, supplier_name, phone_region_1, phone_region_2, phone_region_3)
  VALUES(1, 'Company_ABC', NULL, '555-01111', NULL),
        (2, 'Company_DEF', '555-01222', NULL, NULL),
        (3, 'Company_HIJ', '555-01333', '555-01444', NULL),
        (4, 'Company_KLM', NULL, NULL, NULL);

SELECT NVL(phone_region_1, phone_region_2) IF_REGION_1_NULL,
       NVL(phone_region_2, phone_region_1) IF_REGION_2_NULL,
       COALESCE(phone_region_2, phone_region_1, phone_region_3) THREE_ARG_NVL
  FROM
       suppliers
  ORDER BY supplier_id;

Copy

IF_REGION_1_NULL	IF_REGION_2_NULL
555-01111	555-01111
555-01222	555-01222
555-01333	555-01444
null	null

Bekannte Probleme¶

Es gibt keine bekannten Probleme.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

Datums- und Uhrzeitfunktionen¶

CONVERT_TIMEZONE¶

Beschreibung¶

Die Funktion CONVERT_TIMEZONE in Amazon Redshift konvertiert einen Zeitstempel von einer Zeitzone in eine andere, wobei Sie die ursprüngliche Zeitzone, die Zielzeitzone und den zu konvertierenden Zeitstempel angeben. Nützlich für die genaue Verwaltung der Zeit in verschiedenen Regionen

Grammatikalische Syntax¶

 CONVERT_TIMEZONE(source_timezone, target_timezone, timestamp)

Copy

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT
    GETDATE(),
    CONVERT_TIMEZONE('UTC', 'Europe/London', GETDATE()) AS london_time,
    CONVERT_TIMEZONE('UTC', 'Asia/Tokyo', GETDATE()) AS tokyo_time;

Copy

getdate	london_time	tokyo_time
2024-10-02 16:14:55,000000	2024-10-02 17:14:55,000000	2024-10-03 01:14:55,000000

Ausgabecode:¶

 SELECT
    GETDATE(),
    CONVERT_TIMEZONE('UTC', 'Europe/London', GETDATE()) AS london_time,
    CONVERT_TIMEZONE('UTC', 'Asia/Tokyo', GETDATE()) AS tokyo_time;

Copy

getdate	london_time	tokyo_time
2024-10-02 09:18:43.848	2024-10-02 10:17:35.351	2024-10-02 18:17:35.351

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

CURRENT_DATE¶

Beschreibung¶

CURRENT_DATE gibt ein Datum in der aktuellen Zeitzone der Sitzung (UTC standardmäßig) im Standardformat zurück: YYYY-MM-DD. (RedShift SQL-Referenz: CURRENT_DATE)

Grammatikalische Syntax¶

 CURRENT_DATE

Copy

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT CURRENT_DATE;

Copy

DATE
2024-09-22

Ausgabecode:¶

 SELECT
    CURRENT_DATE();

Copy

DATE_T
2024-09-22

Empfehlungen¶

Es gibt keine Empfehlungen.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

DATE¶

Beschreibung¶

Diese Funktion wandelt einen Eingabeausdruck in ein Datum um.

Diese Funktion wird in Snowflake vollständig unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammar Syntax

 DATE(<expr>)

Copy

Sample Source Patterns

Input Code:

 SELECT DATE('2024-02-02 04:05:06.789');

SELECT "DATE"("GETDATE"());

SELECT "date"('2024-02-02 04:05:06.789');

Copy

DATE(‚2024-02-02 04:05:06,789‘)
2024-02-02

„DATE“(„GETDATE“())
2024-11-20

„date“(‚2024-02-02 04:05:06,789‘)
2024-02-02

Output Code:

 SELECT DATE('2024-02-02 04:05:06.789');

SELECT DATE(GETDATE());

SELECT DATE('2024-02-02 04:05:06.789');

Copy

DATE(‚2024-02-02 04:05:06,789‘)
2024-02-02

„DATE“(„GETDATE“())
2024-11-20

„DATE“(‚2024-02-02 04:05:06.789‘)
2024-02-02

Known Issues

Es wurden keine Probleme gefunden.

Related EWIs

Es gibt keine bekannten Probleme.

DATE_ADD

Description

Die Funktion DATE_ADD in Amazon Redshift fügt ein bestimmtes Zeitintervall zu einem Datum oder Zeitstempel hinzu. Dabei steht datetimepart für die Art des Intervalls (wie 'day' oder 'month'), interval für die Anzahl der zu addierenden Einheiten (positiv oder negativ) und timestamp für das ursprüngliche Datum.

DATE_ADD wird in DATEADD umgewandelt. Weitere Informationen zu dieser Konvertierung finden Sie unter hier.

Gültig datepart in Snowflake für DATE_ADD:

microsecond, microseconds
millisecond, milliseconds
second, seconds
minute, minutes
hour, hours
day, days
week
month, months
quarter, quarters
year, years

Nicht unterstützte Formate in Snowflake für DATE_ADD:

weeks
decade, decades
century, centuries
millennium, millennia

Grammar Syntax

 DATE_ADD( datetimepart, interval, timestamp )

Copy

Sample Source Patterns

Input Code:

 SELECT DATE_ADD('day', 10, '2024-11-01'), DATE_ADD('month', 3, '2024-11-01');

SELECT "DATE_ADD"('DAYS',18,'2008-02-28');

Copy

date_add	date_add
2024-11-11 00:00:00,000000	2025-02-01 00:00:00,000000

„date_add“
2008-03-17 00:00:00,000000

Output Code:

 SELECT
DATEADD('day', 10, '2024-11-01'),
DATEADD('month', 3, '2024-11-01');

SELECT
DATEADD('DAYS',18,'2008-02-28');

Copy

DATEADD	DATEADD
2024-11-11 00:00:00,000	2025-02-01 00:00:00,000

DATEADD
2008-03-17 00:00:00,000

Know Issues

Es wurden keine Probleme gefunden.

Related EWIs

Es gibt keine bekannten Probleme.

DATE_DIFF

Description

DATEDIFF gibt die Differenz zwischen den Datumsteilen von zwei Datums- oder Zeitausdrücken zurück.

(RedShift SQL-Referenz: DATEDIFF-Funktion)

Gültig datepart in Snowflake für DATE_DIFF:

microsecond, microseconds
millisecond, milliseconds
second, seconds
minute, minutes
hour, hours
day, days
week
month, months
quarter, quarters
year, years

Nicht unterstützte Formate in Snowflake für DATEDIFF:

decade, decades
century, centuries
millennium, millennia

Grammar Syntax

 DATE_DIFF( datepart, {date|time|timetz|timestamp}, {date|time|timetz|timestamp} )

Copy

Diese Funktion wird in Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT DATE_DIFF(year,'2009-01-01','2019-12-31') as year,
    DATE_DIFF(month,'2009-01-01','2019-12-31') as month,
    DATE_DIFF(day,'2009-01-01','2019-12-31') as day,
    date_diff('year'::text, '2009-01-01 00:00:00'::timestamp without time zone, '2019-12-31 00:00:00'::timestamp without time zone) AS "year2";
    

SELECT DATE_DIFF(week,'2009-01-01','2019-12-31') as week,
    DATE_DIFF(century,'1009-01-01','2009-12-31') as century,
    DATE_DIFF(decade,'1009-01-01','2009-12-31') as decade;

Copy

Jahr	Monat	Tag	year2
10	131	4016	10

week	Jahrhundert	Jahrzehnt
574	10	100

Ausgabecode:¶

 SELECT
    DATEDIFF(year, '2009-01-01', '2019-12-31') as year,
    DATEDIFF(month, '2009-01-01', '2019-12-31') as month,
    DATEDIFF(day, '2009-01-01', '2019-12-31') as day,
    DATEDIFF(year, '2009-01-01 00:00:00':: TIMESTAMP_NTZ, '2019-12-31 00:00:00':: TIMESTAMP_NTZ) AS year2;


SELECT
    DATEDIFF(week,'2009-01-01','2019-12-31') as week,
    DATEDIFF(YEAR, '1009-01-01', '2009-12-31') / 100 as century,
    DATEDIFF(YEAR, '1009-01-01', '2009-12-31') / 10 as decade;

Copy

Jahr	Monat	Tag	year2
10	131	4016	10

week	Jahrhundert	Jahrzehnt
574	10	100

Probleme kennen¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

DATE_PART¶

Beschreibung ¶

DATE_PART extrahiert Datumsteilwerte aus einem Ausdruck. DATE_PART ist ein Synonym für die Funktion PGDATE_PART.

(RedShift SQL-Referenz: DATE_PART-Funktion)

Gültig datepart in Snowflake für DATE_PART:

second, seconds
minute, minutes
hour, hours
day, days
week
dayofweek
dayofyear
month, months
quarter, quarters
year, years
Epoche

Ungültige Formate in Snowflake für DATE_PART:

microsecond, microseconds
millisecond, milliseconds
weeks
decade, decades
century, centuries
millennium, millennia

Grammatikalische Syntax ¶

{PGDATE_PART | DATE_PART}(datepart, {date|timestamp})

Copy

Warnung

Diese Funktion wird teilweise von Snowflake unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT DATE_PART(minute, timestamp '2023-01-04 04:05:06.789') AS dateMinute,
    PGDATE_PART(dayofweek, timestamp '2022-05-02 04:05:06.789') AS dateDayofweek,
    "DATE_PART"('month', date '2022-05-02') AS dateMonth,
    pgdate_part('weeks'::text, '2023-02-28'::date::timestamp without time zone) AS wks;
    
SELECT DATE_PART(weeks, date '2023-02-28') AS wks,
    DATE_PART(decade, date '2023-02-28') AS dec,
    PGDATE_PART(century, date '2023-02-28') AS cen;

Copy

dateMinute	dateDayofweek	dateMonth	wks
5	1	5	9

Ausgabecode:¶

 SELECT
    DATE_PART(minute, timestamp '2023-01-04 04:05:06.789') AS dateMinute,
    DATE_PART(dayofweek, timestamp '2022-05-02 04:05:06.789') AS dateDayofweek,
    DATE_PART('month', date '2022-05-02') AS dateMonth,
    DATE_PART(week, '2023-02-28'::date:: TIMESTAMP_NTZ) AS wks;

SELECT
    DATE_PART(week, date '2023-02-28') AS wks,
    !!!RESOLVE EWI!!! /*** SSC-EWI-PG0005 - decade FORMAT MAY FAIL OR MAY HAVE A DIFFERENT BEHAVIOR IN SNOWFLAKE. ***/!!!
    DATE_PART(decade, date '2023-02-28') AS dec,
    !!!RESOLVE EWI!!! /*** SSC-EWI-PG0005 - century FORMAT MAY FAIL OR MAY HAVE A DIFFERENT BEHAVIOR IN SNOWFLAKE. ***/!!!
    DATE_PART(century, date '2023-02-28') AS cen;

Copy

dateMinute	dateDayofweek	dateMonth	wks
5	1	5	9

Probleme kennen¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

[SSC-EWI-PGOOO5](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/postgresEWI. md#ssc-ewi-pg0005): Das aktuelle Datums-/Nummernformat kann sich in Snowflake anders verhalten.

DATE_TRUNC¶

Beschreibung¶

Die Funktion DATE_TRUNC schneidet einen Zeitstempelausdruck oder ein Literal auf der Grundlage des von Ihnen angegebenen Datumsteils ab, z. B. Stunde, Tag oder Monat.

([Redshift SQL-Referenz: DATE_TRUNC-Funktion](https://docs.aws.amazon.com/redshift/latest/dg/r_DATE_TRUNC. html)).

In Snowfla ke schneidet diese Funktion einen DATE, TIME, oder TIMESTAMP Wert auf die angegebene Genauigkeit ab.

Gültig [<datepart> ](https://docs.aws.amazon.com/redshift/latest/dg/r_DATE_TRUNC. html)in Snowflake:

microsecond, microseconds
millisecond, milliseconds
second, seconds
minute, minutes
hour, hours
day, days
week
month, months
quarter, quarters
year, years

Ungültige Formate in Snowflake:

Wochen
decade, decades
century, centuries
millennium, millennia

Diese Funktion wird in Snowflake vollständig unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammar Syntax

 DATE_TRUNC('datepart', timestamp)

Copy

Sample Source Patterns

Unterstützte Datumsteile

Input Code:

 SELECT
    DATE_TRUNC('second', TIMESTAMP '2024-02-02 04:05:06.789') AS sec,
    DATE_TRUNC('hours', TIMESTAMP '2024-02-02 04:05:06.789') AS hrs,
    DATE_TRUNC('week', TIMESTAMP '2024-02-02 04:05:06.789') AS wk, 
    "DATE_TRUNC"('month', TIMESTAMP '2024-02-02 04:05:06.789') AS mth,
    "date_trunc"('quarters', TIMESTAMP '2024-02-02 04:05:06.789') AS qtr,
    date_trunc('second'::text, '2024-02-02 04:05:06.789'::timestamp without time zone) AS sec2;

Copy

SEC	HRS	WK	MTH	QTR	SEC2
2024-02-02 04:05:06.000000	2024-02-02 04:00:00.000000	2024-01-29 00:00:00.000000	2024-02-01 00:00:00.000000	2024-01-01 00:00:00.000000	2024-02-02 04:05:06.000000

Output Code:

 SELECT
    DATE_TRUNC('second', TIMESTAMP '2024-02-02 04:05:06.789') AS sec,
    DATE_TRUNC('hours', TIMESTAMP '2024-02-02 04:05:06.789') AS hrs,
    DATE_TRUNC('week', TIMESTAMP '2024-02-02 04:05:06.789') AS wk,
    DATE_TRUNC('month', TIMESTAMP '2024-02-02 04:05:06.789') AS mth,
    DATE_TRUNC('quarters', TIMESTAMP '2024-02-02 04:05:06.789') AS qtr,
    date_trunc('second','2024-02-02 04:05:06.789':: TIMESTAMP_NTZ) AS sec2;

Copy

SEC	HRS	WK	MTH	QTR	SEC2
2024-02-02 04:05:06.000	2024-02-02 04:00:00.000	2024-01-29 00:00:00.000	2024-02-01 00:00:00.000	2024-01-01 00:00:00.000	2024-02-02 04:05:06.000000

Ungültige Datumsteile

Diese Transformation wird durchgeführt, um die Redshift-Verhaltensweise für die folgenden Datumsteile zu emulieren

decade, decades
century, centuries
millennium, millennia

Input Code:

 SELECT
    DATE_TRUNC('weeks', TIMESTAMP '1990-02-02 04:05:06.789') AS wks,
    DATE_TRUNC('decade', TIMESTAMP '1990-02-02 04:05:06.789') AS dec,    
    DATE_TRUNC('century', TIMESTAMP '1990-02-02 04:05:06.789') AS c,        
    DATE_TRUNC('millennium', TIMESTAMP '1990-02-02 04:05:06.789') AS m;

Copy

WKS	DEC	C	M
1990-01-29 00:00:00,000000	1990-01-01 00:00:00,000000	1901-01-01 00:00:00,000000	1001-01-01 00:00:00,000000

Output Code:

 SELECT
    DATE_TRUNC(week, TIMESTAMP '1990-02-02 04:05:06.789') AS wks,
    DATEADD(year, -(EXTRACT(year FROM TIMESTAMP '1990-02-02 04:05:06.789')) % 10, DATE_TRUNC(year, TIMESTAMP '1990-02-02 04:05:06.789')) AS dec,
    DATEADD(year, -(EXTRACT(year FROM TIMESTAMP '1990-02-02 04:05:06.789') - 1) % 100, DATE_TRUNC(year, TIMESTAMP '1990-02-02 04:05:06.789')) AS c,
    DATEADD(year, -(EXTRACT(year FROM TIMESTAMP '1990-02-02 04:05:06.789') - 1) % 1000, DATE_TRUNC(year, TIMESTAMP '1990-02-02 04:05:06.789')) AS m;

Copy

WKS	DEC	C	M
1990-01-29 00:00:00,000	1990-01-01 00:00:00,000	1901-01-01 00:00:00,000	1001-01-01 00:00:00,000

Weitere Informationen finden Sie in der folgenden Dokumentation in Snowflake:

Known Issues

In Amazon Redshift beträgt die Standardpräzision für Zeitstempel 6 Ziffern (Mikrosekunden), während in Snowflake die Standardpräzision 9 Ziffern (Nanosekunden) beträgt. Aufgrund dieser Präzisionsunterschiede ist es wichtig, dass Sie bei der Arbeit mit Zeitstempeln Ihre speziellen Bedürfnisse berücksichtigen. Wenn Sie auf einer der beiden Plattformen eine andere Genauigkeit benötigen, können Sie die folgenden Optionen verwenden.

Verwenden Sie ALTERSESSION:

     --This example is for 2 digits for precision (FF2).
    ALTER SESSION SET TIMESTAMP_OUTPUT_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF2';
    

Copy

Bitte beachten Sie, dass es je nach dem Datentyp, der zum Speichern des mit DATE_TRUNC() erhaltenen Wertes verwendet wird, Beschränkungen bei der Genauigkeit geben kann, die zu einem Verlust an Genauigkeit führen können.

Related EWIs

Es gibt keine bekannten Probleme.

DATEADD

Description

Erhöht einen DATE, TIME, TIMETZ oder TIMESTAMP Wert um ein bestimmtes Intervall.

(RedShift SQL-Referenz: DATEADD-Funktion)

Die Funktion DATEADD in Amazon Redshift fügt ein bestimmtes Zeitintervall zu einem Datum oder Zeitstempel hinzu. Dabei steht datepart für den Typ des Intervalls (wie „Tag“ oder „Monat“), interval für die Anzahl der zu addierenden Einheiten (positiv oder negativ) und date für das ursprüngliche Datum.

Gültig datepart in Snowflake für DATEADD:

microsecond, microseconds
millisecond, milliseconds
second, seconds
minute, minutes
hour, hours
day, days
week
month, months
quarter, quarters
year, years

Nicht unterstützte Formate in Snowflake für DATEADD:

weeks
decade, decades
century, centuries
millennium, millennia

Grammar Syntax

 DATEADD(datepart, interval, date)

Copy

Sample Source Patterns

Unterstützte Datumsteile:

Input Code:

 SELECT dateadd(year, 1, '2024-02-29') AS D1, dateadd(year, 1, '2023-02-28') AS D2
        date_add('year'::text, 1::bigint, '2024-02-29 00:00:00'::timestamp without time zone) AS D3;

Copy

D1	D2	D3
2025-03-01 00:00:00,000000	2024-02-28 00:00:00,000000	2025-03-01 00:00:00,000000

Output Code:

 SELECT
DATEADD(day, 1, dateadd(year, 1, '2024-02-29')) AS D1,
DATEADD(year, 1, '2023-02-28') AS D2,
DATEADD('year', 1, '2024-02-29 00:00:00':: TIMESTAMP_NTZ) AS D3;

Copy

D1	D2	D3
2025-03-01 00:00:00,000	2024-02-28 00:00:00,000	2025-03-01 00:00:00,000000

Nicht unterstützte Datumsteile

Diese Transformation wird durchgeführt, um die Redshift-Verhaltensweise für die folgenden Datumsteile zu emulieren

„Wochen“ wird in den entsprechenden unterstützten Datumsteil umgewandelt, week.

Die folgenden Datumsteile werden in ihr Äquivalent in years umgerechnet:

Jahrzehnt, Dekaden: umgerechnet in Jahr mal zehn.
century, centuries: converted to year times one hundred.
millennium, millennia: converted to year times one thousand.

Input Code:

 SELECT DATEADD(weeks, 1, '2023-02-28') AS wks,
        DATEADD(decade, 1, '2023-02-28') AS dec,
        DATEADD(century, 1, '2023-02-28') AS cen,
        DATEADD(millennium, 1, '2023-02-28') AS mill;
        

SELECT 
    DATEADD(millennium, num_interval, '2023-02-28') AS result
FROM (
    SELECT 5 AS num_interval
);

Copy

wks	dec	cen	mill
2023-03-07 00:00:00,000000	2033-02-28 00:00:00,000000	2123-02-28 00:00:00,000000	3023-02-28 00:00:00,000000

Output Code:

 SELECT
    DATEADD(week, 1, '2023-02-28') AS wks,
    DATEADD(YEAR, 1 * 10, '2023-02-28') AS dec,
    DATEADD(YEAR, 1 * 100, '2023-02-28') AS cen,
    DATEADD(YEAR, 1 * 1000, '2023-02-28') AS mill;


SELECT
    DATEADD(YEAR, num_interval * 1000, '2023-02-28') AS result
FROM (
    SELECT 5 AS num_interval
);

Copy

wks	dec	cen	mill
2023-03-07 00:00:00,000000	2033-02-28 00:00:00,000000	2123-02-28 00:00:00,000000	3023-02-28 00:00:00,000000

Anmerkungen

Wenn Sie in Amazon Redshift DATEADD verwenden, um Jahre bis zum 29. Februar eines Schaltjahres hinzuzufügen, wird das Jahr auf den 1. März des folgenden Jahres verschoben, da das nächste Jahr kein Schaltjahr ist. Redshift behandelt die Datumsarithmetik, indem es auf das nächste gültige Datum umstellt. Da es den 29. Februar in Nicht-Schaltjahren nicht gibt, ist er standardmäßig der 1. März. Wenn Sie beispielsweise den 29. Februar 2020 um ein Jahr verlängern, ergibt das den 1. März 2021.

Related EWIs

Es gibt keine bekannten Probleme.

DATEDIFF

Description

DATEDIFF gibt die Differenz zwischen den Datumsteilen von zwei Datums- oder Zeitausdrücken zurück.

(RedShift SQL-Referenz: DATEDIFF-Funktion)

Gültig datepart in Snowflake für DATEDIFF:

microsecond, microseconds
millisecond, milliseconds
second, seconds
minute, minutes
hour, hours
day, days
week
month, months
quarter, quarters
year, years

Nicht unterstützte Formate in Snowflake für DATEDIFF:

decade, decades
century, centuries
millennium, millennia

Grammar Syntax

 DATEDIFF( datepart, {date|time|timetz|timestamp}, {date|time|timetz|timestamp} )

Copy

Diese Funktion wird in Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 SELECT DATEDIFF(year,'2009-01-01','2019-12-31') as year,
    DATEDIFF(month,'2009-01-01','2019-12-31') as month,
    DATEDIFF(day,'2009-01-01','2019-12-31') as day;
    

SELECT DATEDIFF(week,'2009-01-01','2019-12-31') as week,
    DATEDIFF(century,'1009-01-01','2009-12-31') as century,
    DATEDIFF(decade,'1009-01-01','2009-12-31') as decade;

Copy

Jahr	Monat	Tag
10	131	4016

week	Jahrhundert	Jahrzehnt
574	10	100

Ausgabecode:¶

 SELECT DATEDIFF(year,'2009-01-01','2019-12-31') as year,
    DATEDIFF(month,'2009-01-01','2019-12-31') as month,
    DATEDIFF(day,'2009-01-01','2019-12-31') as day;


SELECT DATEDIFF(week,'2009-01-01','2019-12-31') as week,
    DATEDIFF(YEAR, '1009-01-01', '2009-12-31') / 100 as century,
    DATEDIFF(YEAR, '1009-01-01', '2009-12-31') / 10 as decade;

Copy

Jahr	Monat	Tag
10	131	4016

week	Jahrhundert	Jahrzehnt
574	10	100

Probleme kennen¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

GETDATE¶

Beschreibung¶

GETDATE gibt das aktuelle Datum und die Uhrzeit in der aktuellen Zeitzone der Sitzung zurück (UTC als Standard). Sie gibt das Startdatum oder die Startzeit der aktuellen Anweisung zurück, auch wenn sie sich innerhalb eines Transaktionsblocks befindet. (Redshift SQL-Referenz: GETDATE-Funktion).

In Snowflake liefert diese Funktion das aktuelle Datum und die Uhrzeit mit Nanosekundengenauigkeit (bis zu 9 Ziffern) und ist zeitzonenabhängig.

Diese Funktion wird in Snowflake vollständig unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammar Syntax

 GETDATE()

Copy

Sample Source Patterns

Input Code:

 CREATE TABLE table1 (
    id INTEGER,
    date_t DATE DEFAULT getdate(),
    time_t TIME DEFAULT  "getdate"(),
    timestamp_t TIMESTAMP DEFAULT "GETDATE"(),
    timestamptz_t TIMESTAMPTZ DEFAULT getdate()
);

INSERT INTO table1(id) VALUES (1);

SELECT * FROM table1;

Copy

ID	DATE_T	TIME_T	TIMESTAMP_T	TIMESTAMPTZ_T
1	2024-11-20	17:51:00	2024-11-20 17:51:00,000000	2024-11-20 17:51:00,000000 +00:00

Output Code:

 CREATE TABLE table1 (
    id INTEGER,
    date_t DATE DEFAULT getdate() :: DATE,
    time_t TIME DEFAULT GETDATE() :: TIME,
    timestamp_t TIMESTAMP DEFAULT GETDATE(),
    timestamptz_t TIMESTAMP_TZ DEFAULT getdate()
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/20/2024",  "domain": "test" }}';

INSERT INTO table1 (id) VALUES (1);

SELECT * FROM
    table1;

Copy

ID	DATE_T	TIME_T	TIMESTAMP_T	TIMESTAMPTZ_T
1	2024-11-20	17:51:00	2024-11-20 17:51:00,000	2024-11-20 17:51:00,000 +0000

Known Issues

Verwenden Sie ALTERSESSION:

     --This example is for 2 digits for precision (FF2).
    ALTER SESSION SET TIMESTAMP_OUTPUT_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF2';
    

Copy

Bitte beachten Sie, dass es je nach dem Datentyp, der zum Speichern des mit GETDATE() erhaltenen Wertes verwendet wird, Beschränkungen bei der Genauigkeit geben kann, die zu einem Verlust an Genauigkeit führen können.

Related EWIs

Es gibt keine bekannten Probleme.

TIMESTAMP

Description

Die Funktion TIMESTAMP ist eine Systemfunktion, die einen String-Wert in einen Zeitstempel umwandelt.

Diese Funktion wird in Snowflake vollständig unterstützt.

Grammatikalische Syntax ¶

 select "timestamp"(VARCHAR);

Copy

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 select "timestamp"('2024-03-01 3:22:33');

Copy

„timestamp“
2024-03-01 03:22:33,000000

Ausgabecode:

 select
TO_TIMESTAMP('2024-03-01 3:22:33');

Copy

TO_TIMESTAMP
2024-03-01 03:22:33,000

Probleme kennen¶

Verwenden Sie ALTERSESSION:

     --This example is for 2 digits for precision (FF2).
    ALTER SESSION SET TIMESTAMP_OUTPUT_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF2';
    

Copy

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

TRUNC¶

Beschreibung ¶

Schneidet einen TIMESTAMP ab und gibt ein DATE zurück.

Für weitere Informationen lesen Sie bitte die TRUNC-Funktion.

Grammatikalische Syntax ¶

 TRUNC(timestamp)

Copy

Bemerkung

Diese Funktion wird von Snowflake unterstützt. In Snowflake wird jedoch ein DATE-, TIME- oder TIMESTAMP-Wert auf die angegebene Genauigkeit gekürzt.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE test_date_trunc (
    mytimestamp TIMESTAMP,
    mydate DATE,
    mytimestamptz TIMESTAMPTZ
 );

INSERT INTO test_date_trunc VALUES (
  '2024-05-09 08:50:57.891 -0700',
  '2024-05-09',
  '2024-05-09 08:50:57.891 -0700');

SELECT TRUNC(mytimestamp) AS date1,
       TRUNC(mydate) AS date2,
       TRUNC(mytimestamptz::TIMESTAMP) AS date3,
       TRUNC('2024-05-09 08:50:57.891 -0700'::TIMESTAMP) AS date4,
       TRUNC('2024-05-09 08:50:57.891 -0700'::DATE) AS date5,
       CAST(TRUNC('2024-05-09 08:50:57.891 -0700'::TIMESTAMP) AS TIMESTAMP) AS date6
  FROM test_date_trunc;

Copy

DATE1	DATE2	DATE3	DATE4	DATE5	DATE6
2024-05-09	2024-05-09	2024-05-09	2024-05-09	2024-05-09	2024-05-09 00:00:00,000

Ausgabecode:

CREATE TABLE test_date_trunc (
    mytimestamp TIMESTAMP,
    mydate DATE,
    mytimestamptz TIMESTAMP_TZ
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/13/2024",  "domain": "test" }}';

INSERT INTO test_date_trunc
VALUES (
  '2024-05-09 08:50:57.891 -0700',
  '2024-05-09',
  '2024-05-09 08:50:57.891 -0700');

SELECT
    DATE( TRUNC(mytimestamp, 'day')) AS date1,
    DATE(
    TRUNC(mydate, 'day')) AS date2,
    DATE(
    TRUNC(mytimestamptz::TIMESTAMP, 'day')) AS date3,
    DATE(
    TRUNC('2024-05-09 08:50:57.891 -0700'::TIMESTAMP, 'day')) AS date4,
    DATE(
    TRUNC('2024-05-09 08:50:57.891 -0700'::DATE, 'day')) AS date5,
    CAST(DATE(TRUNC('2024-05-09 08:50:57.891 -0700'::TIMESTAMP, 'day')) AS TIMESTAMP) AS date6
FROM
    test_date_trunc;

Copy

DATE1	DATE2	DATE3	DATE4	DATE5	DATE6
2024-05-09	2024-05-09	2024-05-09	2024-05-09	2024-05-09	2024-05-09 00:00:00,000

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

Fensterfunktionen¶

AVG¶

Beschreibung¶

Die AVG-Fensterfunktion gibt den Durchschnitt (arithmetisches Mittel) der Eingabeausdruckswerte zurück.

([Redshift SQL-Referenz: AVG- Funktion](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_AVG. html))

Diese Funktion wird in Snowflake vollständig unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammar Syntax

 AVG ( [ALL ] expression ) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list 
                        frame_clause ]
)

Copy

Sample Source Patterns

Setup data

 CREATE TABLE example_table (
    my_smallint_column SMALLINT,
    my_integer_column INTEGER,
    my_bigint_column BIGINT,
    my_numeric_column NUMERIC,
    my_decimal_column DECIMAL,
    my_real_column REAL,
    my_double_precision_column DOUBLE PRECISION,
    my_super_column SUPER
);

INSERT INTO example_table (
    my_smallint_column,
    my_integer_column,
    my_bigint_column,
    my_numeric_column,
    my_decimal_column,
    my_real_column,
    my_double_precision_column,
    my_super_column
)
VALUES
    (1, 100, 10000000000, 123.45, 678.90, 3.14, 2.71828, 123),
    (2, 200, 20000000000, 234.56, 789.01, 2.71, 3.14159, 456),
    (3, 300, 30000000000, 345.67, 890.12, 1.41, 1.61803, 789),
    (4, 400, 40000000000, 456.78, 901.23, 1.61, 1.41421, 101112),
    (5, 500, 50000000000, 567.89, 123.45, 2.17, 3.14159, 131415);

Copy

 CREATE TABLE example_table (
    my_smallint_column SMALLINT,
    my_integer_column INTEGER,
    my_bigint_column BIGINT,
    my_numeric_column NUMERIC,
    my_decimal_column DECIMAL,
    my_real_column REAL,
    my_double_precision_column DOUBLE PRECISION,
    my_super_column VARIANT
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "11/27/2024",  "domain": "test" }}';

INSERT INTO example_table (
    my_smallint_column,
    my_integer_column,
    my_bigint_column,
    my_numeric_column,
    my_decimal_column,
    my_real_column,
    my_double_precision_column,
    my_super_column
)
VALUES
    (1, 100, 10000000000, 123.45, 678.90, 3.14, 2.71828, 123),
    (2, 200, 20000000000, 234.56, 789.01, 2.71, 3.14159, 456),
    (3, 300, 30000000000, 345.67, 890.12, 1.41, 1.61803, 789),
    (4, 400, 40000000000, 456.78, 901.23, 1.61, 1.41421, 101112),
    (5, 500, 50000000000, 567.89, 123.45, 2.17, 3.14159, 131415);

Copy

Input Code:

 SELECT
    my_smallint_column,
    AVG(my_integer_column) OVER (PARTITION BY my_smallint_column) AS avg_integer_column,
    AVG(my_numeric_column) OVER () AS avg_numeric_column_all,
    AVG(my_decimal_column) OVER (PARTITION BY my_smallint_column ORDER BY my_integer_column ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cumulative_avg_decimal_column
FROM
    example_table
ORDER BY my_smallint_column
LIMIT 3;

Copy

my_smallint_column	avg_integer_column	avg_numeric_column_all	cumulative_avg_decimal_column
1	100	345	679
2	200	345	789
3	300	345	890

Output Code:

 SELECT
    my_smallint_column,
    AVG(my_integer_column) OVER (PARTITION BY my_smallint_column) AS avg_integer_column,
    AVG(my_numeric_column) OVER () AS avg_numeric_column_all,
    AVG(my_decimal_column) OVER (PARTITION BY my_smallint_column ORDER BY my_integer_column ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cumulative_avg_decimal_column
FROM
    example_table
ORDER BY my_smallint_column
LIMIT 3;

Copy

my_smallint_column	avg_integer_column	avg_numeric_column_all	cumulative_avg_decimal_column
1	100	345	679
2	200	345	789
3	300	345	890

Note

Related EWIs

Es gibt keine bekannten Probleme.

COUNT

Description

Die COUNT-Fensterfunktion zählt die durch den Ausdruck definierten Zeilen.

([Redshift SQL-Referenz: COUNT- Funktion](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_COUNT. html))

Diese Funktion wird in Snowflake vollständig unterstützt.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammatikalische Syntax¶

 COUNT ( * | [ ALL ] expression) OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list frame_clause ]
)

Copy

Beispielhafte Quellcode-Muster¶

Datenkonfiguration¶

 CREATE TABLE sales_data (
    sale_id INT,
    product_id INT,
    sale_date DATE,
    amount DECIMAL(10, 2)
);

INSERT INTO sales_data (sale_id, product_id, sale_date, amount) VALUES
(1, 101, '2024-01-01', 200.00),
(2, 102, '2024-01-02', 150.00),
(3, 101, '2024-01-03', 300.00),
(4, 101, '2024-01-03', 250.00),
(5, 103, '2024-01-04', 450.00),
(6, 102, '2024-01-05', 100.00),
(7, 104, '2024-01-05', 500.00),
(8, 101, '2024-01-06', 350.00);

Copy

Eingabecode:¶

 SELECT
    product_id,
    COUNT(ALL amount) OVER (PARTITION BY product_id) AS count_all_amount,
    "count"(*) OVER() AS total_sales,
    "COUNT"(*) OVER (PARTITION BY product_id ORDER BY sale_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cumulative_count
FROM
    sales_data
ORDER BY product_id;

Copy

PRODUCT_ID	COUNT_ALL_AMOUNT	TOTAL_SALES	CUMULATIVE_COUNT
101	4	8	1
101	4	8	2
101	4	8	3
101	4	8	4
102	2	8	1
102	2	8	2
103	1	8	1
104	1	8	1

Ausgabecode:¶

 SELECT
    product_id,
    COUNT(ALL amount) OVER (PARTITION BY product_id) AS count_all_amount,
    COUNT(*) OVER() AS total_sales,
    COUNT(*) OVER (PARTITION BY product_id ORDER BY sale_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cumulative_count
FROM
    sales_data
ORDER BY product_id;

Copy

PRODUCT_ID	COUNT_ALL_AMOUNT	TOTAL_SALES	CUMULATIVE_COUNT
101	4	8	1
101	4	8	2
101	4	8	3
101	4	8	4
102	2	8	1
102	2	8	2
103	1	8	1
104	1	8	1

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

DENSE_RANK¶

Beschreibung ¶

Die Fensterfunktion DENSE_RANK bestimmt den Rang eines Wertes in einer Gruppe von Werten, basierend auf dem Ausdruck ORDER BY in der OVER-Klausel. Die Funktion DENSE_RANK unterscheidet sich von RANK in einem Punkt: Wenn zwei oder mehr Zeilen gleichauf sind, gibt es keine Lücke in der Reihenfolge der rangierten Werte.

Weitere Informationen finden Sie unter [DENSE_RANK-](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_DENSE_RANK. html) Funktion.

Grammatikalische Syntax ¶

 DENSE_RANK() OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
) 

Copy

Bemerkung

Diese Funktion wird von Snowflake unterstützt. Allerdings ist die ORDER BY-Klausel in Snowflake obligatorisch. Falls sie nicht existiert, wird ein ORDER BY 1 hinzugefügt, um die volle Gleichwertigkeit zu gewährleisten.

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE corn_production 
(
    farmer_ID INTEGER, 
    state varchar, 
    bushels float
);

INSERT INTO corn_production (farmer_ID, state, bushels) VALUES
    (1, 'Iowa', 100),
    (2, 'Iowa', 110),
    (3, 'Kansas', 120),
    (4, 'Kansas', 130),
    (5, 'Kansas', 110);

SELECT DENSE_RANK() OVER (ORDER BY bushels DESC) AS rank1,
DENSE_RANK() OVER (PARTITION BY state ORDER BY bushels DESC) AS rank2,
DENSE_RANK() OVER () AS rank3,
DENSE_RANK() OVER (PARTITION BY state) AS rank4
FROM corn_production;

Copy

rank1	rank2	rank3	rank4
1	1	1	1
2	2	1	1
3	3	1	1
3	1	1	1
4	2	1	1

Ausgabecode:

 CREATE TABLE corn_production
(
    farmer_ID INTEGER,
    state varchar,
    bushels float
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/27/2024" }}';

INSERT INTO corn_production (farmer_ID, state, bushels) VALUES
    (1, 'Iowa', 100),
    (2, 'Iowa', 110),
    (3, 'Kansas', 120),
    (4, 'Kansas', 130),
    (5, 'Kansas', 110);

SELECT DENSE_RANK() OVER (ORDER BY bushels DESC) AS rank1,
DENSE_RANK() OVER (PARTITION BY state ORDER BY bushels DESC) AS rank2,
DENSE_RANK()
    OVER (
    ORDER BY 1) AS rank3,
DENSE_RANK()
    OVER (PARTITION BY state
    ORDER BY 1) AS rank4
FROM
    corn_production;

Copy

rank1	rank2	rank3	rank4
1	1	1	1
2	2	1	1
3	3	1	1
3	1	1	1
4	2	1	1

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

LEAD¶

Beschreibung¶

Die LEAD-Fensterfunktion gibt die Werte für eine Zeile mit einem bestimmten Offset unter (nach) der aktuellen Zeile in der Partition zurück.

([Redshift SQL-Referenz: LEAD- Fensterfunktion](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_LEAD. html))

Warnung

Diese Funktion wird in Snowflake teilweise unterstützt. In Redshift kann der Offset eine konstante Ganzzahl oder ein Ausdruck sein, der zu einer Ganzzahl ausgewertet wird. In Snowflake gibt es die Beschränkung, dass es sich nur um eine Konstante handeln kann.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Grammatikalische Syntax¶

 LEAD (value_expr [, offset ])
[ IGNORE NULLS | RESPECT NULLS ]
OVER ( [ PARTITION BY window_partition ] ORDER BY window_ordering )

Copy

Beispielhafte Quellcode-Muster¶

Datenkonfiguration¶

 CREATE TABLE sales (
    sale_id INT,
    customer_id INT,
    sale_date DATE,
    sale_amount DECIMAL(10, 2)
);

INSERT INTO sales (sale_id, customer_id, sale_date, sale_amount)
VALUES
    (1, 301, '2024-01-01', 150.00),
    (2, 301, '2024-01-02', NULL),
    (3, 301, '2024-01-03', 250.00),
    (4, 301, '2024-01-04', 350.00),
    (5, 302, '2024-02-01', 100.00),
    (6, 302, '2024-02-02', 200.00),
    (7, 302, '2024-02-03', NULL),
    (8, 302, '2024-02-04', 300.00);

Copy

Eingabecode:¶

 SELECT
    LEAD(sale_amount) OVER (PARTITION BY customer_id ORDER BY sale_date) AS lead,
    LEAD(sale_amount, 2) RESPECT NULLS OVER (PARTITION BY customer_id ORDER BY sale_date) AS lead_respect_null,
    LEAD(sale_amount, 1) IGNORE NULLS OVER (PARTITION BY customer_id ORDER BY sale_date) AS lead_ignore_nulls
FROM sales;

Copy

LEAD	LEAD_RESPECT_NULL	LEAD_IGNORE_NULLS
200,00	null	200,00
null	300,00	300,00
300,00	null	300,00
null	null	null
null	250,00	250,00
250,00	350,00	250,00
350,00	null	350,00
null	null	null

Ausgabecode:¶

 SELECT
    LEAD(sale_amount) OVER (PARTITION BY customer_id ORDER BY sale_date) AS lead,
    LEAD(sale_amount, 2) RESPECT NULLS OVER (PARTITION BY customer_id ORDER BY sale_date) AS lead_respect_null,
    LEAD(sale_amount, 1) IGNORE NULLS OVER (PARTITION BY customer_id ORDER BY sale_date) AS lead_ignore_nulls
FROM sales;

Copy

LEAD	LEAD_RESPECT_NULL	LEAD_IGNORE_NULLS
200,00	null	200,00
null	300,00	300,00
300,00	null	300,00
null	null	null
null	250,00	250,00
250,00	350,00	250,00
350,00	null	350,00
null	null	null

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

RANK¶

Beschreibung ¶

Die Fensterfunktion RANK bestimmt den Rang eines Wertes in einer Gruppe von Werten, basierend auf dem Ausdruck ORDER BY in der OVER-Klausel. Wenn die optionale PARTITION BY-Klausel vorhanden ist, werden die Ranglisten für jede Gruppe von Zeilen zurückgesetzt.

Weitere Informationen finden Sie in der Funktion [RANK](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_RANK. html).

Grammatikalische Syntax ¶

 RANK () OVER
(
[ PARTITION BY expr_list ]
[ ORDER BY order_list ]
) 

Copy

Bemerkung

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

 CREATE TABLE corn_production 
(
    farmer_ID INTEGER, 
    state varchar, 
    bushels float
);

INSERT INTO corn_production (farmer_ID, state, bushels) VALUES
    (1, 'Iowa', 100),
    (2, 'Iowa', 110),
    (3, 'Kansas', 120),
    (4, 'Kansas', 130),
    (5, 'Kansas', 110);

SELECT RANK() OVER (ORDER BY bushels DESC) AS rank1,
RANK() OVER (PARTITION BY state ORDER BY bushels DESC) AS rank2,
RANK() OVER () AS rank3,
RANK() OVER (PARTITION BY state) AS rank4
FROM corn_production;

Copy

rank1	rank2	rank3	rank4
1	1	1	1
2	2	1	1
3	3	1	1
3	1	1	1
5	2	1	1

Ausgabecode:

 CREATE TABLE corn_production
(
    farmer_ID INTEGER,
    state varchar,
    bushels float
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "09/27/2024" }}';

INSERT INTO corn_production (farmer_ID, state, bushels) VALUES
    (1, 'Iowa', 100),
    (2, 'Iowa', 110),
    (3, 'Kansas', 120),
    (4, 'Kansas', 130),
    (5, 'Kansas', 110);

SELECT RANK() OVER (ORDER BY bushels DESC) AS rank1,
RANK() OVER (PARTITION BY state ORDER BY bushels DESC) AS rank2,
RANK()
    OVER (
    ORDER BY 1) AS rank3,
RANK()
    OVER (PARTITION BY state
    ORDER BY 1) AS rank4
FROM
    corn_production;

Copy

rank1	rank2	rank3	rank4
1	1	1	1
2	2	1	1
3	3	1	1
3	1	1	1
5	2	1	1

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

ROW_NUMBER¶

Beschreibung ¶

Die ROW_NUMBER-Fensterfunktion weist der aktuellen Zeile innerhalb einer Gruppe von Zeilen eine Ordnungszahl zu, die von 1 an gezählt wird, basierend auf dem Ausdruck ORDER BY in der OVER-Klausel. ([RedShift SQL ](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_ROW_NUMBER. html)[Referenz: ROW_NUMBER-Fensterfunktion](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_ROW_NUMBER. html))

Grammatikalische Syntax ¶

 ROW_NUMBER() OVER(
  [ PARTITION BY expr_list ]
  [ ORDER BY order_list ]
)

Copy

Diese Funktion wird in Snowflake vollständig unterstützt.

Die Klausel ORDER BY ist in Snowflake obligatorisch. Falls sie nicht existiert, wird ein ORDER BY 1 hinzugefügt, um die volle Gleichwertigkeit zu gewährleisten.

Weitere Informationen über zitierte Bezeichner in Funktionen finden Sie unter hier.

Sample Source Patterns

Setup data

 CREATE TABLE corn_production 
(
    farmer_ID INTEGER, 
    state varchar, 
    bushels float
);

INSERT INTO corn_production (farmer_ID, state, bushels) VALUES
    (1, 'Iowa', 100),
    (2, 'Iowa', 110),
    (3, 'Kansas', 120),
    (4, 'Kansas', 130),
    (5, 'Kansas', 110);

Copy

Input Code:

 SELECT  ROW_NUMBER()  OVER ( ORDER BY bushels DESC) AS row1,
        ROW_NUMBER()  OVER ( PARTITION BY state ORDER BY bushels DESC) AS row2,
        ROW_NUMBER()  OVER () AS row3,
        ROW_NUMBER()  OVER ( PARTITION BY state) AS row4
FROM corn_production;

Copy

ROW1	ROW2	ROW3	ROW4
1	1	1	1
2	2	2	2
4	3	3	3
3	1	4	1
5	2	5	2

Ausgabecode:

 SELECT  ROW_NUMBER()  OVER ( ORDER BY bushels DESC) AS row1,
        ROW_NUMBER()  OVER ( PARTITION BY state ORDER BY bushels DESC) AS row2,
        ROW_NUMBER()
        OVER (
        ORDER BY
      1) AS row3,
        ROW_NUMBER()
        OVER ( PARTITION BY state
        ORDER BY
      1) AS row4
FROM
        corn_production;

Copy

ROW1	ROW2	ROW3	ROW4
1	1	1	1
2	2	2	2
4	3	3	3
3	1	4	1
5	2	5	2

Known Issues

Es wurden keine Probleme gefunden.

Related EWIs

Es gibt keine bekannten Probleme.