SnowConvert : fonctions Redshift¶

Fonctions système¶

IDENTITY¶

Description ¶

La fonction IDENTITY est une fonction de système qui opère sur une colonne spécifiée d’une table pour déterminer la valeur initiale de l’identité. Si la valeur initiale n’est pas disponible, elle prend par défaut la valeur fournie dans la fonction. Ceci sera traduit en séquence dans Snowflake.

Grammar Syntax ¶

 "identity"(oid_id, oid_table_id, default)

Copy

Note

Cette fonction n’est plus prise en charge dans Redshift. Elle utilise la valeur par défaut pour définir l’identité et se comporte comme une colonne d’identité standard.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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

Fonctions de chaîne de caractères¶

BTRIM¶

Description ¶

La fonction BTRIM extrait une chaîne en supprimant les blancs de début et de fin ou en supprimant les caractères de début et de fin qui correspondent à une chaîne spécifiée facultative. (RedShift SQL Références linguistiques fonction BTRIM)

Grammar Syntax ¶

 BTRIM(string [, trim_chars ] )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

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

Code de sortie :

 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

Problèmes connus

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

Related EWIs

Il n’y a pas de problème connu.

CONCAT

Description

La fonction CONCAT concatène deux expressions et renvoie l’expression résultante. (RedShift SQL Références linguistiques fonction CONCAT).

Grammar Syntax

 CONCAT ( expression1, expression2 )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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

EWIs connexes¶

Il n’y a pas de problème connu.

LEFT et RIGHT¶

Description ¶

Ces fonctions renvoient le nombre spécifié de caractères les plus à gauche ou les plus à droite d’une chaîne de caractères. (Références linguistiques SQL fonction LEFT et RIGHT).

Grammar Syntax ¶

 LEFT( string,  integer )

RIGHT( string,  integer )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

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

Code de sortie :

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

Copy

left_3	right_3
Chi	ago

Know Issues

Dans Snowflake et Redshift, les fonctions LEFT et RIGHT traitent différemment les valeurs négatives :

Snowflake : renvoie une chaîne vide lorsque le deuxième argument est négatif.
Redshift : lève une erreur d’exécution avec des valeurs négatives.

Related EWIs

Il n’y a pas de problème connu.

LOWER

Description

La fonction LOWER convertit une chaîne en minuscules. ([RedShift SQL Références linguistiques fonction minuscules ](https://docs.aws.amazon.com/redshift/latest/dg/r_LOWER.html))

Grammar Syntax

 LOWER ( string )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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(“Valeurs”)
test	test	values
test	test	values
test	test	values

EWIs connexes¶

Il n’y a pas de problème connu.

QUOTE_IDENT¶

Description ¶

La fonction QUOTE\N-IDENT renvoie la chaîne spécifiée sous la forme d’une chaîne avec un guillemet double en tête et un guillemet double de fin. (RedShift SQL Références linguistiques fonction QUOTE_IDENT).

Pour répliquer la fonctionnalité de cette fonction, elle est convertie en fonction CONCAT.

Grammar Syntax ¶

 QUOTE_IDENT(string)

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Sample Source Patterns

Input Code:

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

Copy

quote_ident	quote_ident
« « »CAT » » »	« Foo bar » » »

Code de sortie :

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

Copy

quote_ident	quote_ident
« « »CAT » » »	« Foo bar » » »

Problèmes connus

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

Related EWIs

Il n’y a pas de problème connu.

REGEXP_REPLACE

Description

Ces fonctions recherchent dans une chaîne un modèle d’expression régulière et remplacent chaque occurrence du modèle par la chaîne spécifiée. (SQL Références linguistiques fonction REGEXP\N-REPLACE ).

Grammar Syntax

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

Copy

Avertissement

Cette fonction est partiellement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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) : Expression régulière inon valide : “(?=\N-[^ ]\N-[[a-z])(?=\N-[^ ]\N-[[0-9])\N-[^ ]+”, pas d’argument pour l’opérateur de répétition : ?

Problèmes connus¶

Cette fonction comprend un argument parameters qui permet à l’utilisateur d’interpréter le modèle à l’aide du dialecte Perl Compatible Regular Expression (PCRE), représenté par la valeur p, celle-ci est supprimée pour éviter tout problème lors de la correction du code.

EWIs connexes¶

[SSC-EWI-0009](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/teradataEWI. md#ssc-ewi-td0020) : la fonction Regexp\N_Substr ne prend en charge que les expressions régulières POSIX.
[SSC-FDM-0032](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0032) : le paramètre n’est pas une valeur littérale, la transformation n’a pas pu être entièrement appliquée
[SSC-FDM- PG0011](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/postgresqlFDM. md#ssc-fdm-pg0011) : l’utilisation de la contrainte de colonne COLLATE a été désactivée pour cette condition de recherche de modèle.

REPLACE¶

Description¶

Remplace toutes les occurrences d’un ensemble de caractères dans une chaîne existante par d’autres caractères spécifiés. (Référence linguistique Redshift SQL fonction REPLACE).

Cette fonction est entièrement prise en charge dans Snowflake.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

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	Pomme Orange Banane Raisin	http://example.com/new-path/resource

Code de sortie :

 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	Pomme Orange Banane Raisin	http://example.com/new-path/resource

Known Issues

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

Related EWIs

Il n’y a pas de problème connu.

SPLIT_PART

Description

Fractionne une chaîne sur le délimiteur spécifié et renvoie la partie à la position spécifiée (SQL Références linguistiques fonction SPLIT_PART ).

Grammar Syntax

 SPLIT_PART(string, delimiter, position)

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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

Problèmes connus¶

Il y a une différence dans la façon dont SPLIT_PART se comporte lorsqu’il est utilisé avec des classements insensibles à la casse (CASE_INSENSITIVE ou en-ci) dans Snowflake par rapport à Redshift.

EWIs connexes¶

Il n’y a pas de problème connu.

SUBSTRING¶

Description ¶

Renvoie le sous-ensemble d’une chaîne en fonction de la position de départ spécifiée. (RedShift fonction SUBSTRING).

Grammar 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

Avertissement

Cette fonction est partiellement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

machien_3_2	machine_1_4
ch	mach

Code de sortie :

 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

machien_3_2	machine_1_4
ch	mach

Problèmes connus¶

Lorsque la position de départ `` dans Redshift est égale ou inférieure à 0, la fonction SUBSTRING effectue une opération mathématique (position de départ + nombre de caractères). Si le résultat est inférieur ou égal à 0, SUBSTRING renvoie une chaîne vide. Dans Snowflake, le comportement de start_position lorsqu’elle est égale ou inférieure à 0 diffère, ce qui conduit à des résultats différents.

EWIs connexes¶

Il n’y a pas de problème connu.

TRIM¶

Description ¶

La fonction TRIM élimine les blancs ou les caractères spécifiés d’une chaîne de caractères. (Référence linguistique RedShift SQL fonction TRIM)

Dans Redshift, il est possible de spécifier où effectuer une opération trim à l’aide de mots-clés (BOTH, LEADING ou TRAILING). Cette fonctionnalité peut être répliquée dans Snowflake en utilisant les fonctions TRIM, LTRIM et RTRIM, respectivement.

Grammar Syntax ¶

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

Copy

Cette fonction est entièrement prise en charge par Snowflake.

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
« chien

FromTrim
Bonjour le monde

Code de sortie :

 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
« chien

FromTrim
Bonjour le monde

Know Issues

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

Related EWIs

Il n’y a pas de problème connu.

UPPER

Description

La fonction UPPER convertit une chaîne en majuscules. (Référence linguistique [RedShift SQL fonction Upper ](https://docs.aws.amazon.com/redshift/latest/dg/r_UPPER.html))

Grammar Syntax

 UPPER ( string )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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(“Valeurs”)
TEST	TEST	VALUES
TEST	TEST	VALUES
TEST	TEST	VALUES

EWIs connexes¶

Il n’y a pas de problème connu.

Fonctions d’agrégation¶

AVG¶

Description¶

La fonction AVG renvoie la moyenne (moyenne arithmétique) des valeurs de l’expression d’entrée. (Référence linguistique Redshift SQL fonction AVG)

Cette fonction est entièrement prise en charge par Snowflake.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

Grammar Syntax

 AVG ( [ DISTINCT | ALL ] expression )

Copy

Sample Source Patterns

Données de configuration

 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

Note

AVG, selon le type de données, peut se comporter différemment en termes d’arrondi et de formatage, ce qui peut se traduire par une précision ou des décimales différentes lors de la comparaison entre Redshift et Snowflake.

Related EWIs

Il n’y a pas de problème connu.

COUNT

Description

La fonction COUNT compte les lignes définies par l’expression. (Référence linguistique Redshift SQL fonction COUNT)

COUNT et APPROXIMATE COUNT sont entièrement prises en charge dans Snowflake par COUNT et APPROX_COUNT_DISTINCT.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

Grammar Syntax¶

 COUNT ( * | expression )

COUNT ( [ DISTINCT | ALL ] expression )

APPROXIMATE COUNT ( DISTINCT expression )

Copy

Modèles d’échantillons de sources¶

Données de configuration¶

 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

Code d’entrée :¶

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

Code de sortie :¶

 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

Problèmes connus ¶

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

EWIs connexes¶

Il n’y a pas de problème connu.

Fonctions mathématiques¶

MAX¶

Description ¶

La fonction MAX renvoie la valeur maximale d’un ensemble de lignes. (Référence linguistique RedShift SQL fonction MAX).

Grammar Syntax ¶

 MAX ( [ DISTINCT | ALL ] expression )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

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

Code de sortie :

 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

Il n’y a pas de problème connu.

MIN

Description

La fonction MIN renvoie la valeur minimale d’un ensemble de lignes (Référence linguistique RedShift SQL fonction MIN).

Grammar Syntax

 MIN ( [ DISTINCT | ALL ] expression )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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

EWIs connexes¶

Il n’y a pas de problème connu.

NUMERIC¶

Description ¶

La fonction NUMERIC est une fonction système qui transforme une valeur de chaîne en valeur numérique.

Cette fonction est entièrement prise en charge dans Snowflake.

Grammar Syntax

 select "numeric"(VARCHAR);

Copy

Sample Source Patterns

Input Code:

 SELECT "numeric"('2024');

Copy

« numeric »
2024

Code de sortie :

 SELECT
TO_NUMERIC('2024');

Copy

TO_NUMERIC
2024

Related EWIs

Il n’y a pas de problème connu.

ROUND

Description

La fonction ROUND arrondit les nombres à l’entier ou au décimal le plus proche. (Référence linguistique RedShift SQL fonction ROUND ).

Grammar Syntax

 ROUND(number [ , integer ] )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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

EWIs connexes¶

Il n’y a pas de problème connu.

SUM¶

Description ¶

La fonction SUM renvoie la somme des valeurs de la colonne ou de l’expression d’entrée. (RedShift SQL Référence linguistique fonction SUM )

Grammar Syntax ¶

 SUM ( [ DISTINCT | ALL ] expression )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

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

Code de sortie :

 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

Il n’y a pas de problème connu.

TRUNC

Description

La fonction TRUNC tronque les nombres à l’entier ou au décimal précédent.

Pour plus d’informations, veuillez vous référer à la fonction TRUNC.

Grammar Syntax

 TRUNC(number [ , integer ])

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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

EWIs connexes¶

Il n’y a pas de problème connu.

Fonctions de formatage des types de données¶

TO_DATE¶

Description¶

TO_DATE convertit une date représentée par une chaîne de caractères en un type de données DATE. (Référence linguistique Redshift SQL fonction TO_DATE)

Cette fonction est entièrement prise en charge dans Snowflake.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

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	ERROR[22008] : champ date/heure valeur de la date en dehors de la plage : 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	Impossible d’analyser “20010631” comme date au format “YYYYMMDD”

Known Issues

La requête SELECT TO_DATE('20010631', 'YYYYMMDD') échoue dans Snowflake parce que le mois de juin ne compte que 30 jours, et que TO_DATE de Snowflake n’ajuste pas automatiquement les dates non valides, contrairement à TO_DATE de Redshift avec is_strict défini sur false, ce qui le convertirait au 1er juillet. Pour éviter les erreurs dues à des chaînes de dates non valides, vous pouvez utiliser TRY_TO_DATE, qui renvoie NULL si la conversion échoue. Cela permet une exécution plus fluide des requêtes et une identification plus aisée des dates non valides.

Related EWIs

SSC-FDM-RS0004 : les dates non valides provoquent des erreurs dans Snowflake.
SSC-EWI-PG0005 : le format de date ou d’heure n’est pas pris en charge par Snowflake.
[SSC-FDM-0032](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0032) : le paramètre n’est pas une valeur littérale, la transformation n’a pas pu être entièrement appliquée

TO_CHAR

Description

TO\CHAR convertit un horodatage ou une expression numérique en format de données de type chaîne de caractères. (Référence linguistique Redshift SQL fonction TO_CHAR fonction)

Avertissement

Cette fonction est partiellement prise en charge par Snowflake.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

Grammar Syntax¶

 TO_CHAR(timestamp_expression | numeric_expression , 'format')

Copy

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :¶

 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	Déc-Jeu-31-2009 11 :15PM

Problèmes connus ¶

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

EWIs connexes¶

SSC-EWI-PG0005 : le format de date/numérique actuel peut avoir un comportement différent dans Snowflake.

Pour les valeurs temporelles¶

Description¶

Les chaînes de format suivantes s’appliquent à des fonctions telles que TO_CHAR. Ces chaînes peuvent contenir des séparateurs de date (tels que “-”, “/” ou “:”) ainsi que les « dateparts » et « timeparts » suivants. (Page de référence des chaînes de format datetime de Redshift)

Grammar Syntax¶

TO_CHAR (timestamp_expression, 'format')

Copy

La table suivante spécifie le mappage de chaque élément de format à Snowflake :

Redshift	Snowflake	Remarques
`BC AD, bc, ad` (indicateurs d’époque en majuscules et minuscules)	`PUBLIC.ERA_INDICATORS_UDF`
`B.C,. A.D., b.c., a.d.` (majuscules et minuscules, indicateurs d’époque avec points)	`PUBLIC.ERA_INDICATORS_WITH_POINTS_UDF`
`CC`	`PUBLIC.CENTURY_UDF`
`YYYY` et `YY`	-	Pris en charge directement
`YYY` et `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 Mois, mois`	`PUBLIC.FULL_MONTH_NAME_UDF`
`MON, Moi, moi`	`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, Jour, jour`	`PUBLIC.DAYNAME_LONG_UDF`
`DY, Jr, jr`	`PUBLIC.DAYNAME_SHORT_UDF`
`DDD`	`DAYOFYEAR`
`IDDD`	`PUBLIC.DAY_OF_YEAR_ISO_UDF`
`D`	`PUBLIC.DAY_OF_WEEK_UDF`	Pour que cette UDF fonctionne correctement, le paramètre de session Snowflake `WEEK_START` doit avoir sa valeur par défaut (`0`)
`ID`	`DAYOFWEEKISO`
`J`	`PUBLIC.JULIAN_DAY_UDF`
`HH24`	-	Pris en charge directement
`HH`	`HH12`
`HH12`	-	Pris en charge directement
`MI`	-	Pris en charge directement
`SS`	-	Pris en charge directement
`MS`	`FF3`
`US`	`FF6`
`AM PM, am, pm (indicateurs méridiens en majuscules et minuscules)`	`PUBLIC.MERIDIAN_INDICATORS_UDF`
`A.M., P.M., a.m., p.m.` (indicateurs méridiens majuscules et minuscules avec points)	`PUBLIC.MERIDIAN_INDICATORS_WITH_POINTS_UDF`
`TZ` et `tz`	`UTC` et `utc`	Selon la documentation redshift, tous les horodatages avec fuseau horaire sont stockés en UTC, ce qui fait que cet élément de format renvoie un résultat fixe
`OF`	`+00`	Selon la documentation redshift, tous les horodatages avec fuseau horaire sont stockés en UTC, ce qui fait que cet élément de format renvoie un résultat fixe
`SSSS`	`PUBLIC.SECONDS_PAST_MIDNIGHT`
`SP`		Il s’agit d’un modificateur de modèle PostgreSQL pour « spell mode », mais il ne fait rien sur Redshift, il est donc supprimé de la sortie.
`FX`		Il s’agit d’un autre modificateur de modèle pour « format fixe », mais il n’a aucune utilité pour la fonction TO_CHAR et a donc été supprimé.

Modèles d’échantillons de sources¶

Transformation directe des éléments de format (pas de fonctions/UDFs)¶

Le résultat est conservé sous la forme d’une fonction unique TO_CHAR

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

Transformation de format à l’aide de fonctions/UDFs¶

Le résultat est une concaténation de plusieurs fonctions intégrées TOCHAR, UDFs et Snowflake qui génèrent la représentation équivalente sous forme de chaîne de la valeur de l’heure de la date

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

Texte cité¶

Les éléments de format dans le texte entre guillemets doubles sont ajoutés à la sortie directement sans les interpréter, les guillemets doubles échappés sont transformés en leur équivalent échappé dans Snowflake.

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

Problèmes connus¶

Les modificateurs de modèles ne sont pas pris en charge¶

Les modificateurs de modèles de format suivants :

FM (mode remplissage)
TH et th (suffixe du nombre ordinal en majuscules et minuscules)
TM (mode traduction)

Ne sont pas pris en charge, leur inclusion dans un format va générer SSC-EWI-PG0005

Code d’entrée :

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

Copy

Code de sortie :

 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

Paramètre du format transmis par la variable

Lorsque le paramètre du format est transmis comme une variable au lieu d’un littéral de chaîne, la transformation des éléments de format ne peut pas être appliquée, un avertissement FDM sera ajouté aux utilisations de la fonction à ce sujet.

Code d’entrée :

 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

Code de sortie :

 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

EWIs connexes¶

SSC-EWI-PG0005 : le format de date/numérique actuel peut avoir un comportement différent dans Snowflake.
[SSC-FDM-0032](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0032) : le paramètre n’est pas une valeur littérale, la transformation n’a pas pu être entièrement appliquée

Fonctions JSON¶

JSON_EXTRACT_PATH_TEXT¶

Description ¶

La fonction JSON_EXTRACT_PATH_TEXT renvoie la valeur de la paire clé-valeur référencée par une série d’éléments de chemin dans une chaîne JSON. (RedShift SQL Référence linguistique fonction JSON_EXTRACT_PATH_TEXT )

Grammar Syntax ¶

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

Copy

Cette fonction est entièrement prise en charge par Snowflake.

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	Toute marque	Toute marque	Toute marque	NULL

Code de sortie :

 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	Toute marque	Toute marque	Toute marque	NULL

Code d’entrée utilisant les variables comme chemins :

 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	result
appliances	brand	Toute marque

Code de sortie :

 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	result
appliances	brand	Toute marque

Known Issues

Par rapport à Snowflake, Redshift traite différemment les caractères lorsqu’il s’agit d’une nouvelle ligne, d’une tabulation ou d’un chariot. Redshift interprète les caractères comme les caractères eux-mêmes. Snowflake l’applique.
La fonction Snowflake reçoit deux paramètres : le premier est le littéral JSON et le second est le chemin séparé par un point pour accéder aux objets internes. La transformation remplace la liste des chemins par une fonction qui joindra les chemins séparés par des points, même s’il s’agit d’une référence à une colonne.
Lorsque le chemin est envoyé par l’intermédiaire d’une variable et que celle-ci contient des espaces, elle doit être mise entre guillemets.

Related EWIs

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

Fonctions de hachage

FNV_HASH

Description

FNV_HASH Calcule la fonction de hachage non cryptographique de 64 bits FNV-1a pour tous les types de données de base.\ (Référence linguistique Redshift SQL fonction FNV_HASH ).

Note

Dans Snowflake, il n’existe pas de fonction équivalente qui fournisse l’algorithme FNV, mais la fonction HASH fournit les mêmes fonctionnalités non cryptographiques.

Grammar Syntax¶

 FNV_HASH(value [, seed])

Copy

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :¶

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

Copy

FNV_HASH	FNV_HASH_SEED
3199932455444588441	3199932455444588441

Note

Dans la fonction FNVHASH de Redshift, le paramètre « seed » est facultatif, mais il n’est pas utilisé dans la fonction « hachage » de Snowflake, car le paramètre « seed » n’est utilisé que pour l’algorithme FNV.

Problèmes connus ¶

Il n’y a pas de problème connu.

EWIs connexes¶

Il n’y a pas de problème connu.

Fonctions conditionnelles¶

COALESCE¶

Description ¶

Renvoie la valeur de la première expression qui n’est pas null dans une série d’expressions. Lorsqu’une valeur non nulle est trouvée, les expressions restantes de la liste ne sont pas évaluées.

Pour plus d’informations, veuillez vous référer à la fonction COALESCE.

Grammar Syntax ¶

 COALESCE( expression, expression, ... )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

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

Code de sortie :

 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

Il n’y a pas de problème connu.

GREATEST et LEAST

Description

Renvoie la plus grande ou la plus petite valeur d’une liste d’un nombre quelconque d’expressions. (Référence linguistique Redshift SQL fonction GREATEST et LEAST)

Grammar Syntax

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

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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	nulles
40	10	25

least	greatest
GERMANY	USA

Code de sortie :

 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	nulles
40	10	NULL

least	greatest
GERMANY	USA

Problèmes connus¶

Il n’y a pas de problème connu

EWIs connexes¶

NULLIF¶

Description ¶

L’expression NULLIF compare deux arguments et renvoie null si les arguments sont égaux. S’ils ne sont pas égaux, le premier argument est renvoyé. Dans Redshift, NULLIF ignore les blancs de fin lors de la comparaison de valeurs de chaînes dans certains scénarios. Par conséquent, le comportement peut différer entre Redshift et Snowflake. Pour cette raison, dans le RTRIM de transformation ajoutera pour obtenir l’équivalence entre Redshift et Snowflake (Référence linguistique Redshift SQL fonction NULLIF)

Grammar Syntax ¶

 NULLIF ( expression1, expression2 )

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Sample Source Patterns

Input Code:

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

Copy

différent	same
first	NULL

Code de sortie :

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

Copy

différent	same
first	NULL

Known Issues

Il n’y a pas de problème connu.

Related EWIs

Il n’y a pas de EWIs connu.

NVL

Description

Dans RedShift, NVL peut contenir 2 arguments ou plus, alors que dans Snowflake, la fonction NVL n’accepte que 2 arguments. Afin d’émuler le même comportement, NVL avec 3 arguments ou plus est transformé en fonction COALESCE.

Cette fonction est entièrement prise en charge par Snowflake.

Grammar Syntax ¶

 NVL( expression, expression, ... )

Copy

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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

Problèmes connus¶

Il n’y a pas de problème connu.

EWIs connexes¶

Il n’y a pas de problème connu.

Fonctions de date et d’heure¶

CONVERT_TIMEZONE¶

Description¶

La fonction CONVERT_TIMEZONE d’Amazon Redshift convertit un horodatage d’un fuseau horaire à un autre, où vous spécifiez le fuseau horaire d’origine, le fuseau horaire cible et l’horodatage à convertir. Le rendre utile pour la gestion précise du temps dans différentes régions

Grammar Syntax¶

 CONVERT_TIMEZONE(source_timezone, target_timezone, timestamp)

Copy

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :¶

 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

EWIs connexes¶

Il n’y a pas de problème connu.

CURRENT_DATE¶

Description¶

CURRENT_DATE renvoie une date dans le fuseau horaire de la session en cours (UTC par défaut) dans le format par défaut : YYYY-MM-DD. (Référence linguistique RedShift SQL CURRENT_DATE)

Grammar Syntax¶

 CURRENT_DATE

Copy

Modèles d’échantillons de sources¶

Code d’entrée :¶

 SELECT CURRENT_DATE;

Copy

DATE
2024-09-22

Code de sortie :¶

 SELECT
    CURRENT_DATE();

Copy

DATE_T
2024-09-22

Recommandations¶

Il n’y a pas de recommandations.

EWIs connexes¶

Il n’y a pas de problème connu.

DATE¶

Description¶

Cette fonction convertit une expression d’entrée en date.

Cette fonction est entièrement prise en charge dans Snowflake.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

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

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

Related EWIs

Il n’y a pas de problème connu.

DATE_ADD

Description

La fonction DATE_ADD d’Amazon Redshift ajoute un intervalle de temps spécifié à une date ou à un horodatage. Où datetimepart est le type d’intervalle (comme 'day' ou 'month'), interval est le nombre d’unités à ajouter (positif ou négatif) et timestamp est la date d’origine.

DATE_ADD est converti en DATEADD, pour plus d’informations sur cette conversion, cliquez ici.

Valable datepart dans Snowflake pour DATE_ADD :

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

Formats non pris en charge dans Snowflake pour 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

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

Related EWIs

Il n’y a pas de problème connu.

DATE_DIFF

Description

DATEDIFF renvoie la différence entre les parties de date de deux expressions de date ou d’heure.

(Référence linguistique RedShift SQL fonction DATEDIFF)

Valable datepart dans Snowflake pour DATE_DIFF :

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

Formats non pris en charge dans Snowflake pour DATEDIFF :

decade, decades
century, centuries
millennium, millennia

Grammar Syntax

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

Copy

Cette fonction est entièrement prise en charge dans Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

year	month	day	year2
10	131	4016	10

week	century	decade
574	10	100

Code de sortie :¶

 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

year	month	day	year2
10	131	4016	10

week	century	decade
574	10	100

Problèmes connus¶

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

EWIs connexes¶

Il n’y a pas de problème connu.

DATE_PART¶

Description ¶

DATE_PART extrait les valeurs des parties de date d’une expression. DATE_PART est un synonyme de la fonction PGDATE_-PART.

(RedShift SQL Référence liguistique fonction DATE_PART )

Valable datepart dans Snowflake pour DATE_PART :

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

Formats non valides dans Snowflake pour DATE_PART :

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

Grammar Syntax ¶

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

Copy

Avertissement

Cette fonction est partiellement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :¶

 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

Problèmes connus¶

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

EWIs connexes¶

SSC-EWI-PGOOO5 : le format de date/numérique actuel peut avoir un comportement différent dans Snowflake.

DATE_TRUNC¶

Description¶

La fonction DATE_TRUNC tronque une expression d’horodatage ou un littéral en fonction de la partie de la date que vous spécifiez, telle que l’heure, le jour ou le mois.

(Référence linguistique Redshift SQL fonction DATE_TRUNC).

Dans Snowflake cette fonction tronque une valeur DATE, TIME ou TIMESTAMP à la précision spécifiée.

Valable \N- dans Snowflake :

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

Formats non valides dans Snowflake :

Semaines
decade, decades
century, centuries
millennium, millennia

Cette fonction est entièrement prise en charge dans Snowflake.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

Grammar Syntax

 DATE_TRUNC('datepart', timestamp)

Copy

Sample Source Patterns

Parties de la date prises en charge

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

Parties de la date non valides

Cette transformation est effectuée afin d’émuler le comportement de Redshift pour les parties de date suivantes

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

Pour plus d’informations, veuillez vous référer à la documentation suivante dans Snowflake :

Known Issues

Dans Amazon Redshift, la précision par défaut des horodatages est de 6 chiffres (microsecondes), tandis que dans Snowflake, la précision par défaut est de 9 chiffres (nanosecondes). En raison de ces différences de précision, il est important de prendre en compte vos besoins spécifiques lorsque vous travaillez avec des horodatages. Si vous avez besoin d’une précision différente dans l’une ou l’autre plateforme, vous pouvez utiliser les options suivantes.

Utilisez ALTERSESSION :

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

Copy

Veuillez noter qu’en fonction du type de données utilisé pour stocker la valeur obtenue avec DATE_TRUNC(), il peut y avoir des limites de précision qui pourraient entraîner une perte d’exactitude.

Related EWIs

Il n’y a pas de problème connu.

DATEADD

Description

Incrémente une valeur DATE, TIME, TIMETZ ou TIMESTAMP d’un intervalle spécifié.

(Référence linguistique RedShift SQL fonction DATEADD)

La fonction DATEADD d’Amazon Redshift ajoute un intervalle de temps spécifié à une date ou à un horodatage. Où datepart est le type d’intervalle (comme jour ou mois), interval est le nombre d’unités à ajouter (positif ou négatif), et date est la date d’origine.

Valable datepart dans Snowflake pour DATEADD :

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

Formats non pris en charge dans Snowflake pour DATEADD :

weeks
decade, decades
century, centuries
millennium, millennia

Grammar Syntax

 DATEADD(datepart, interval, date)

Copy

Sample Source Patterns

Parties de la date prises en charge :

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

Parties de date non prises en charge

Cette transformation est effectuée afin d’émuler le comportement de Redshift pour les parties de date suivantes

semaines est converti en sa partie équivalente de date prise en charge, week.

Les parties de date suivantes sont transformées en leur équivalent en years :

décennie, décennies : convertis en année multipliée par dix.
century, centuries: converted to year times one hundred.
millénaire, millénaires : convertis en années multipliées par mille.

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

Remarques

Dans Amazon Redshift, lorsque vous utilisez DATEADD pour ajouter des années au 29 février d’une année bissextile, cela se répercute sur le 1er mars de l’année suivante, car l’année suivante n’est pas une année bissextile. Redshift gère l’arithmétique des dates en passant à la date valide la plus proche. Comme le 29 février n’existe pas dans les années non bissextiles, il est fixé par défaut au 1er mars. Par exemple, si l’on ajoute une année au 29 février 2020, on obtient le 1er mars 2021.

Related EWIs

Il n’y a pas de problème connu.

DATEDIFF

Description

DATEDIFF renvoie la différence entre les parties de date de deux expressions de date ou d’heure.

(Référence linguistique RedShift SQL fonction DATEDIFF)

Valable datepart dans Snowflake pour DATEDIFF :

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

Formats non pris en charge dans Snowflake pour DATEDIFF :

decade, decades
century, centuries
millennium, millennia

Grammar Syntax

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

Copy

Cette fonction est entièrement prise en charge dans Snowflake.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

year	month	day
10	131	4016

week	century	decade
574	10	100

Code de sortie :¶

 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

year	month	day
10	131	4016

week	century	decade
574	10	100

Problèmes connus¶

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

EWIs connexes¶

Il n’y a pas de problème connu.

GETDATE¶

Description¶

GETDATE renvoie la date et l’heure actuelles dans le fuseau horaire de la session en cours (UTC par défaut). Elle renvoie la date ou l’heure de début de l’instruction en cours, même si elle se trouve dans un bloc de transaction.(Référence linguistique Redshift SQL fonction GETDATE).

Dans Snowflake, cette fonction fournit la date et l’heure actuelles avec une précision de l’ordre de la nanoseconde (jusqu’à 9 chiffres) et tient compte du fuseau horaire.

Cette fonction est entièrement prise en charge dans Snowflake.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

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

Utilisez ALTERSESSION :

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

Copy

Veuillez noter qu’en fonction du type de données utilisé pour stocker la valeur obtenue avec GETDATE(), il peut y avoir des limites de précision qui pourraient entraîner une perte d’exactitude.

Related EWIs

Il n’y a pas de problème connu.

TIMESTAMP

Description

La fonction TIMESTAMP est une fonction système qui transforme une valeur de chaîne en horodatage.

Cette fonction est entièrement prise en charge dans Snowflake.

Grammar Syntax ¶

 select "timestamp"(VARCHAR);

Copy

Modèles d’échantillons de sources¶

Code d’entrée :¶

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

Copy

« timestamp »
2024-03-01 03:22:33.000000

Code de sortie :

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

Copy

TO_TIMESTAMP
2024-03-01 03:22:33.000

Problèmes connus¶

Utilisez ALTERSESSION :

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

Copy

EWIs connexes¶

Il n’y a pas de problème connu.

TRUNC¶

Description ¶

Tronque un TIMESTAMP et renvoie une DATE.

Pour plus d’informations, veuillez vous référer à la fonction TRUNC.

Grammar Syntax ¶

 TRUNC(timestamp)

Copy

Note

Cette fonction est prise en charge par Snowflake. Cependant, dans Snowflake, il tronque une valeur DATE, TIME ou TIMESTAMP à la précision spécifiée.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

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

EWIs connexes¶

Il n’y a pas de problème connu.

Fonctions de la fenêtre¶

AVG¶

Description¶

La fonction de fenêtre AVG renvoie la moyenne (moyenne arithmétique) des valeurs d’expression à l’entrée.

(Redshift SQL Référence linguistique fonction AVG )

Cette fonction est entièrement prise en charge dans Snowflake.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

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

Il n’y a pas de problème connu.

COUNT

Description

La fonction de fenêtre COUNT compte les lignes définies par l’expression.

(Redshift SQL Référence linguistique fonction COUNT )

Cette fonction est entièrement prise en charge dans Snowflake.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

Grammar Syntax¶

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

Copy

Modèles d’échantillons de sources¶

Données de configuration¶

 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

Code d’entrée :¶

 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

Code de sortie :¶

 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

Problèmes connus ¶

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

EWIs connexes¶

Il n’y a pas de problème connu.

DENSE_RANK¶

Description ¶

La fonction de fenêtre DENSE\_RANK détermine le rang d’une valeur dans un groupe de valeurs, sur la base de l’expression ORDER BY dans la clause OVER. La fonction DENSE_RANK diffère de RANK sur un point : si deux lignes ou plus sont à égalité, il n’y a pas de vide dans la séquence des valeurs classées.

Pour plus d’informations, veuillez vous référer à la fonction DENSE_RANK.

Grammar Syntax ¶

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

Copy

Note

Cette fonction est prise en charge par Snowflake. Cependant, la clause ORDER BY est obligatoire dans Snowflake. Dans le cas où il n’existe pas, un ORDER BY 1 sera ajouté afin de garantir une équivalence totale.

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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

EWIs connexes¶

Il n’y a pas de problème connu.

LEAD¶

Description¶

La fonction de fenêtre LEAD renvoie les valeurs d’une ligne à un décalage donné sous (après) la ligne actuelle de la partition.

(Référence linguistique Redshift SQL fenêtre LEAD function)

Avertissement

Cette fonction est partiellement prise en charge par Snowflake. Dans Redshift, le décalage peut être un entier constant ou une expression qui s’évalue à un entier. Dans Snowflake, la limite est qu’il ne peut s’agir que d’une constante.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

Grammar Syntax¶

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

Copy

Modèles d’échantillons de sources¶

Données de configuration¶

 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

Code d’entrée :¶

 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

Code de sortie :¶

 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

Problèmes connus ¶

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

EWIs connexes¶

Il n’y a pas de problème connu.

RANK¶

Description ¶

La fonction de fenêtre RANK détermine le rang d’une valeur dans un groupe de valeurs, sur la base de l’expression ORDER BY dans la clause OVER. Si la clause facultative PARTITION BY est présente, les classements sont réinitialisés pour chaque groupe de lignes.

Pour de plus amples informations, veuillez vous référer à la fonction RANK.

Grammar Syntax ¶

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

Copy

Note

Modèles d’échantillons de sources¶

Code d’entrée :¶

 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

Code de sortie :

 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

EWIs connexes¶

Il n’y a pas de problème connu.

ROW_NUMBER¶

Description ¶

La fonction de fenêtre ROW_NUMBER attribue un numéro ordinal à la ligne actuelle dans un groupe de lignes, en comptant à partir de 1, sur la base de l’expression ORDER BY dans la clause OVER. (RedShift SQL Référence linguistique fonction fenêtre ROW_NUMBER )

Grammar Syntax ¶

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

Copy

Cette fonction est entièrement prise en charge dans Snowflake.

La clause ORDER BY est obligatoire dans Snowflake. Dans le cas où il n’existe pas, un ORDER BY 1 sera ajouté afin de garantir une équivalence totale.

Pour plus d’informations sur les identificateurs cités dans les fonctions, cliquez ici.

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

Code de sortie :

 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

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

Related EWIs

Il n’y a pas de problème connu.