Types de données SQL : modifications de la longueur maximale, de la sortie et des messages d’erreur (en attente)

Attention

Ce changement de comportement est présent dans le bundle 2024_08.

Pour connaître le statut actuel du bundle, reportez-vous à Historique du bundle.

Avec ce changement de comportement, les expressions SQL et certains messages d’erreur se comportent comme suit :

Avant la modification:
  • Dans les expressions et messages d’erreur SQL compilés, Snowflake a explicitement spécifié la longueur du type de données (par exemple, VARCHAR(16777216)).

  • Lors du chargement d’objets de plus de 16 MB, une erreur liée à l’analyse ou au traitement d’une chaîne ou d’un fichier volumineux est renvoyée (par exemple, 100069 (22P02): Error parsing JSON: document is too large, max size 16777216 bytes).

Après la modification:
  • Dans les expressions et messages d’erreur SQL compilés, Snowflake omet la longueur du type de données (par exemple, VARCHAR).

  • Lors du chargement d’objets de plus de 16 MB, une erreur liée au stockage d’un objet volumineux est renvoyée (par exemple, 100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <actual_size>).

Par le passé, une erreur se produisait lorsque vous tentiez d’interroger un objet supérieur à 16 MB (8 MB pour BINARY, GEOMETRY et GEOGRAPHY) sur une zone de préparation. Vous pouvez désormais lire et traiter des objets jusqu’à 128 MB en taille. Bien que vous ne puissiez toujours pas charger des objets plus grands que 16 MB en taille dans une colonne ou les afficher dans un jeu de résultats, vous pouvez interroger des objets jusqu’à 128 MB en taille (64 MB pour BINARY, GEOMETRY et GEOGRAPHY) dans les fichiers sur une zone de préparation et réduire la taille des objets avant de stocker les objets dans les colonnes.

Pour plus d’informations, voir Réduction de la taille des objets supérieurs à 16 MB avant le chargement.

La nouvelle limite de taille n’est pas explicitement exposée dans la sortie ou les métadonnées de requête SQL. Cependant, vous pouvez implicitement observer la nouvelle longueur accrue en créant ou en lisant des objets de taille plus grande, mais sans les stocker. L’activation de cette fonctionnalité introduit les changements de comportement suivants :

  • Les types VARCHAR et BINARY apparaissent sans longueur dans la sortie des commandes GET_DDL, SHOW et DESCRIBE pour les expressions de colonne, les UDFs et les procédures stockées.

    Par exemple, VARCHAR est affiché à la place de VARCHAR(16777216). Cette modification s’applique uniquement aux objets nouvellement créés dont vous n’avez pas explicitement spécifié la longueur dans l’instruction DDL. Le changement ne s’applique pas aux objets existants.

  • Certaines instructions qui ont échoué auparavant avec une erreur maximum size exceeded (ou une erreur similaire) réussiront désormais.

    Les instructions qui se contentent de charger ou de créer, sans jamais stocker ni retourner une grande valeur, réussiront désormais.

  • Certaines instructions qui ont échoué auparavant avec un maximum size exceeded (ou similaire) continuera à échouer, cependant, avec un code d’erreur ou un message différent.

    Le nouveau code d’erreur et le nouveau message sont toujours liés au dépassement de la limite 16 MB, mais l’erreur peut provenir d’une autre partie du plan d’exécution. Par exemple, cannot load value pourrait changer pour cannot store value ou cannot output value.

Le premier changement affecte tous les clients. Les deuxième et troisième modifications affectent les clients qui tentent de charger ou de générer des objets de plus de 16 MB.

Important

Nous déconseillons fortement de créer une logique qui dépend de messages d’erreur associés à des objets de plus de 16 MB. Au lieu de cela, vous pouvez créer une logique qui utilise la fonction BIT_LENGTH pour vérifier la taille de la valeur.

Changements dans les métadonnées

Il y a des changements de comportement qui affectent les types d’opérations suivants :

Pour ces types d’opérations, il y a des changements dans les métadonnées de l’ensemble de résultats.

Note

Cette liste n’est pas exhaustive.

Renvoi de métadonnées pour les UDFs

Pour les nouvelles fonctions définies par l’utilisateur (UDFs) qui utilisent des valeurs VARCHAR ou BINARY en entrée ou en sortie, les changements dans les métadonnées pour les instructions DDL liées à des UDFs affectent la sortie renvoyée lorsque vous appelez la fonction GET_DDL, exécutez l’instruction DESCRIBE FUNCTION ou interroger la table d’événements. L’exemple suivant crée une UDF :

CREATE OR REPLACE FUNCTION udf_varchar(g1 VARCHAR)
  RETURNS VARCHAR
  AS $$
    'Hello' || g1
  $$;
Copy

GET_DDL

Les métadonnées renvoyées par une fonction GET_DDL change de la manière suivante :

SELECT GET_DDL('function', 'udf_varchar(VARCHAR)');
Copy
Métadonnées avant le changement:
CREATE OR REPLACE FUNCTION "UDF_VARCHAR"("G1" VARCHAR(16777216))
RETURNS VARCHAR(16777216)
LANGUAGE SQL
AS '
  ''Hello'' || g1
';
Métadonnées après le changement:
CREATE OR REPLACE FUNCTION "UDF_VARCHAR"("G1" VARCHAR)
RETURNS VARCHAR
LANGUAGE SQL
AS '
  ''Hello'' || g1
';

DESCRIBE FUNCTION

Les métadonnées renvoyées pour une instruction DESCRIBE FUNCTION changent de la manière suivante :

DESCRIBE FUNCTION udf_varchar(VARCHAR);
Copy
Métadonnées avant le changement:
+-----------+-------------------+
| property  | value             |
|-----------+-------------------|
| signature | (G1 VARCHAR)      |
| returns   | VARCHAR(16777216) |
| language  | SQL               |
| body      |                   |
|           |   'Hello' || g1   |
|           |                   |
+-----------+-------------------+
Métadonnées après le changement:
+-----------+-------------------+
| property  | value             |
|-----------+-------------------|
| signature | (G1 VARCHAR)      |
| returns   | VARCHAR           |
| language  | SQL               |
| body      |                   |
|           |   'Hello' || g1   |
|           |                   |
+-----------+-------------------+

Table des événements

Pour les nouvelles fonctions définies par l’utilisateur qui renvoient des valeurs VARCHAR ou BINARY en sortie, l’attribut snow.executable.name dans la colonne RESOURCE_ATTRIBUTES de la table d’événements change comme suit :

Métadonnées avant le changement:
{
  "db.user": "MYUSERNAME",
  "snow.database.id": 13,
  "snow.database.name": "MY_DB",
  "snow.executable.id": 197,
  "snow.executable.name": "UDF_VARCHAR(X VARCHAR):VARCHAR(16777216)",
  "snow.executable.type": "FUNCTION",
  "snow.owner.id": 2,
  "snow.owner.name": "MY_ROLE",
  "snow.query.id": "01ab0f07-0000-15c8-0000-0129000592c2",
  "snow.schema.id": 16,
  "snow.schema.name": "PUBLIC",
  "snow.session.id": 1275605667850,
  "snow.session.role.primary.id": 2,
  "snow.session.role.primary.name": "MY_ROLE",
  "snow.user.id": 25,
  "snow.warehouse.id": 5,
  "snow.warehouse.name": "MYWH",
  "telemetry.sdk.language": "python"
}
Copy
Métadonnées après le changement:
{
  "db.user": "MYUSERNAME",
  "snow.database.id": 13,
  "snow.database.name": "MY_DB",
  "snow.executable.id": 197,
  "snow.executable.name": "UDF_VARCHAR(X VARCHAR):VARCHAR",
  "snow.executable.type": "FUNCTION",
  "snow.owner.id": 2,
  "snow.owner.name": "MY_ROLE",
  "snow.query.id": "01ab0f07-0000-15c8-0000-0129000592c2",
  "snow.schema.id": 16,
  "snow.schema.name": "PUBLIC",
  "snow.session.id": 1275605667850,
  "snow.session.role.primary.id": 2,
  "snow.session.role.primary.name": "MY_ROLE",
  "snow.user.id": 25,
  "snow.warehouse.id": 5,
  "snow.warehouse.name": "MYWH",
  "telemetry.sdk.language": "python"
}
Copy

Renvoi de métadonnées pour les tables avec des expressions de colonne

Pour les nouvelles tables qui utilisent VARCHAR ou BINARY dans les expressions de colonne, les changements de dans les métadonnées pour les instructions DDL liées à ces colonnes affectent la sortie renvoyée lorsque vous appelez la fonction GET_DDL.

L’exemple suivant crée une table avec une expression de colonne :

CREATE OR REPLACE TABLE table_with_default(x INT, v TEXT DEFAULT x::VARCHAR);
Copy

Les métadonnées renvoyées par une fonction GET_DDL change de la manière suivante :

SELECT GET_DDL('table', 'table_with_default');
Copy
Métadonnées avant le changement:
create or replace TABLE TABLE_WITH_DEFAULT ( |
      X NUMBER(38,0),
      V VARCHAR(16777216) DEFAULT CAST(TABLE_WITH_DEFAULT.X AS VARCHAR(16777216))
);
Métadonnées après le changement:
create or replace TABLE TABLE_WITH_DEFAULT ( |
      X NUMBER(38,0),
      V VARCHAR(16777216) DEFAULT CAST(TABLE_WITH_DEFAULT.X AS VARCHAR)
);

Tables externes

L’exemple suivant crée une table externe :

CREATE OR REPLACE EXTERNAL TABLE ext_table(
    data_str VARCHAR AS (value:c1::TEXT))
  LOCATION = @csv_stage
  AUTO_REFRESH = false
  FILE_FORMAT =(type = csv);
Copy

Les métadonnées renvoyées par une fonction GET_DDL change de la manière suivante :

SELECT GET_DDL('table', 'ext_table');
Copy
Métadonnées avant le changement:
create or replace external table EXT_TABLE(
      DATA_STR VARCHAR(16777216) AS (CAST(GET(VALUE, 'c1') AS VARCHAR(16777216))))
location=@CSV_STAGE/
auto_refresh=false
file_format=(TYPE=csv)
;
Métadonnées après le changement:
create or replace external table EXT_TABLE(
      DATA_STR VARCHAR(16777216) AS (CAST(GET(VALUE, 'c1') AS VARCHAR)))
location=@CSV_STAGE/
auto_refresh=false
file_format=(TYPE=csv)
;

Renvoi de métadonnées pour SYSTEM$TYPEOF

Les métadonnées renvoyées pour un appel de la fonction SYSTEM$TYPEOF change de la manière suivante :

SELECT SYSTEM$TYPEOF(REPEAT('a',10));
Copy
Métadonnées avant le changement:
VARCHAR(16777216)[LOB]
Métadonnées après le changement:
VARCHAR[LOB]

Renvoi de métadonnées pour SHOW COLUMNS

Ce changement affecte à la fois les tables existantes et nouvelles. Les métadonnées renvoyées pour une instruction SHOW COLUMNS change de la manière suivante :

CREATE OR REPLACE TABLE t AS
  SELECT TO_VARIANT('abc') AS col;

SHOW COLUMNS IN t;
Copy
Métadonnées avant le changement:
{
  "type":"VARIANT",
  "length":16777216,
  "byteLength":16777216,
  "nullable":true,
  "fixed":false
}
Métadonnées après le changement:
{
  "type":"VARIANT",
  "nullable":true,
  "fixed":false
}

Modifications dans le chargement et le traitement des objets de plus de 16 MB

Il existe des changements de comportement qui affectent les cas où vous essayez de charger ou de traiter des objets de plus de 16 MB en utilisant les types d’opérations suivants :

Note

Cette liste n’est pas exhaustive.

Chargement de données en analysant des fichiers sur une zone de préparation

Lorsque vous essayez de charger des données supérieures à 16 MB en analysant les fichiers sur une zone de préparation, un message d’erreur est renvoyé.

Chargement d’un objet entier de grande taille à l’aide de CREATE TABLE AS SELECT

Un message d’erreur différent apparaît lorsque vous essayez d’utiliser une instruction CREATE TABLE AS SELECT pour charger des objets plus grands que 16 MB pour VARCHAR, VARIANT, OBJECT et ARRAY (ou plus grand que 8 MB pour BINARY, GEOMETRY ou GEOGRAPHY). L’erreur dépend du type de source. Le même changement de message s’applique lorsqu’une instruction INSERT INTO SELECT est utilisée pour ce scénario.

Chargement d’un objet entier de grande taille à partir d’une source JSON

L’exemple suivant tente de charger un objet entier de plus de 16 MB d’une source JSON utilisant CREATE TABLE AS SELECT :

CREATE OR REPLACE FILE FORMAT json_format TYPE = JSON;

CREATE OR REPLACE TABLE table_varchar (lob_column VARCHAR) AS
  SELECT $1::VARCHAR
    FROM @lob_int_stage/driver_status.json.gz (FILE_FORMAT => 'json_format');
Copy
Message d’erreur avant le changement:
100069 (22P02): Error parsing JSON: document is too large, max size 16777216 bytes
Message d’erreur après le changement:
100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <actual_size>
Chargement d’un objet entier de grande taille à partir d’une source XML

L’exemple suivant tente de charger un objet entier de plus de 16 MB d’une source XML utilisant CREATE TABLE AS SELECT :

CREATE or REPLACE FILE FORMAT xml_format TYPE = XML;

CREATE OR REPLACE TABLE table_varchar (lob_column VARCHAR) AS
  SELECT $1 AS XML
    FROM @lob_int_stage/large_xml.xte (FILE_FORMAT => 'xml_format');
Copy
Message d’erreur avant le changement:
100100 (22P02): Error parsing XML: document is too large, max size 16777216 bytes
Message d’erreur après le changement:
100078 (22000): String '<string_preview>' is too long and would be truncated

Chargement d’un objet entier de grande taille à l’aide de COPY INTO <nom_table> … FROM SELECT

Un message d’erreur différent apparaît lorsque vous essayez d’utiliser une instruction COPY INTO <nom_table> … FROM SELECT pour charger des objets plus grands que 16 MB pour VARCHAR, VARIANT, OBJECT et ARRAY (ou plus grand que 8 MB pour BINARY, GEOMETRY ou GEOGRAPHY). L’erreur dépend du type de source.

Important

Si vous essayez de charger des données contenant des objets supérieurs à 16 MB en utilisant la commande COPY INTO avec ON_ERROR=CONTINUE et comptez sur les messages d’erreur écrits dans le journal des erreurs, le changement du message d’erreur pourrait entraîner des problèmes de logique qui dépendent du message d’erreur.

Chargement d’un objet entier de grande taille à partir d’une source JSON

L’exemple suivant tente de charger un objet entier de plus de 16 MB d’une source JSON utilisant COPY INTO <nom_table> … FROM SELECT :

CREATE OR REPLACE TABLE table_varchar (lob_column VARCHAR);

COPY INTO table_varchar FROM (
  SELECT $1::VARCHAR
    FROM @lob_int_stage/driver_status.json.gz (FILE_FORMAT => 'json_format'));
Copy
Message d’erreur avant le changement:
100069 (22P02): Error parsing JSON: document is too large, max size 16777216 bytes
Message d’erreur après le changement:
100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <actual_size>
Chargement de grands objets imbriqués à partir d’une source JSON

L’exemple suivant essaie de charger des données JSON lors de l’accès à de grands objets imbriqués :

CREATE OR REPLACE TABLE table_varchar (lob_column VARCHAR);

COPY INTO table_varchar FROM (
  SELECT $1:"Driver_Status"
    FROM @lob_int_stage/driver_status.json.gz (FILE_FORMAT => 'json_format'));
Copy
Message d’erreur avant le changement:
100069 (22P02): Max LOB size (16777216) exceeded, actual size of parsed column is <object_size>
Message d’erreur après le changement:
100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <actual_size>
Chargement d’un objet entier de grande taille à partir d’une source XML

L’exemple suivant tente de charger un objet entier de plus de 16 MB d’une source XML en utilisant COPY INTO <nom_table> … FROM SELECT :

CREATE OR REPLACE TABLE table_varchar (lob_column VARCHAR);

COPY INTO table_varchar FROM (
  SELECT $1::VARCHAR AS lob_column
    FROM @lob_int_stage/large_xml.xte (FILE_FORMAT => 'xml_format'));
Copy
Message d’erreur avant le changement:
100100 (22P02): Error parsing XML: document is too large, max size 16777216 bytes
Message d’erreur après le changement:
100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <object_size>

Chargement d’un objet entier de grande taille à l’aide de COPY INTO <nom_table> … FROM <zone_de_preparation_ou_emplacement>

Un message d’erreur différent apparaît lorsque vous essayez d’utiliser une instruction COPY INTO <nom_table> … FROM <zone_de_preparation_ou_emplacement> pour charger des objets plus grands que 16 MB pour VARCHAR, VARIANT, OBJECT et ARRAY (ou plus grand que 8 MB pour BINARY, GEOMETRY ou GEOGRAPHY). L’erreur dépend du type de source.

Si vous utilisez la commande COPY avec des objets volumineux, les requêtes peuvent échouer même lorsque le paramètre ON_ERROR est défini sur CONTINUE. Pour plus d’informations, voir les notes sur l’utilisation de la commande COPY.

Important

Si vous essayez de charger des données contenant des objets supérieurs à 16 MB en utilisant la commande COPY INTO avec ON_ERROR=CONTINUE et comptez sur les messages d’erreur écrits dans le journal des erreurs, le changement du message d’erreur pourrait entraîner des problèmes de logique qui dépendent du message.

Chargement d’un objet entier de grande taille à partir d’une source JSON

L’exemple suivant tente de charger un objet entier de plus de 16 MB d’une source JSON en utilisant COPY INTO <nom_table> … FROM <zone_de_preparation_ou_emplacement> :

CREATE OR REPLACE TABLE table_varchar (lob_column VARCHAR);

COPY INTO table_varchar (lob_column)
  FROM @lob_int_stage/driver_status.json.gz
  FILE_FORMAT = (FORMAT_NAME = json_format);
Copy
Message d’erreur avant le changement:
100069 (22P02): Error parsing JSON: document is too large, max size 16777216 bytes
Message d’erreur après le changement:
100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <actual_size>
Chargement d’un objet entier de grande taille à partir d’une source XML

L’exemple suivant tente de charger un objet entier de plus de 16 MB d’un XML source en utilisant COPY INTO < nom_table> … FROM <zone_de_preparation_ou_emplacement> :

CREATE OR REPLACE TABLE table_varchar (lob_column VARCHAR);

COPY INTO table_varchar (lob_column)
  FROM @lob_int_stage/large_xml.xte
  FILE_FORMAT = (FORMAT_NAME = xml_format);
Copy
Message d’erreur avant le changement:
100100 (22P02): Error parsing XML: document is too large, max size 16777216 bytes
Message d’erreur après le changement:
100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <actual_size>

Interrogation d’un objet volumineux dans son intégralité à partir d’un fichier source

Parce que les objets plus grands que 16 MB ne sont actuellement pas autorisés dans un jeu de résultats, un message d’erreur différent s’affiche lorsque vous essayez d’interroger des objets à partir d’un fichier source dont la taille est supérieure à 16 MB pour VARCHAR, VARIANT, OBJECT et ARRAY (ou plus grand que 8 MB pour BINARY, GEOMETRY ou GEOGRAPHY). L’erreur dépend du type de source.

Interrogation d’un objet entier de grande taille à partir d’une source JSON

L’exemple suivant tente d’interroger un objet entier supérieur à 16 MB d’une source JSON :

SELECT $1
  FROM @lob_int_stage/driver_status.json.gz (FILE_FORMAT => 'json_format');
Copy
Message d’erreur avant le changement:
100069 (22P02): Error parsing JSON: document is too large, max size 16777216 bytes
Message d’erreur après le changement:
100082 (22000): The data length in result column $1 is not supported by this version of the client. Actual length <actual_length> exceeds supported length of 16777216.

Interrogation d’un objet entier de grande taille à partir d’une source XML

L’exemple suivant tente d’interroger un objet entier supérieur à 16 MB d’une source XML :

SELECT $1 as lob_column
  FROM @lob_int_stage/large_xml.xte (FILE_FORMAT => 'xml_format');
Copy
Message d’erreur avant le changement:
100100 (22P02): Error parsing XML: document is too large, max size 16777216 bytes
Message d’erreur après le changement:
100082 (22000): The data length in result column $1 is not supported by this version of the client. Actual length <actual_length> exceeds supported length of 16777216.

Interrogation d’un objet entier de grande taille à partir d’une source CSV

L’exemple suivant tente d’interroger un objet entier supérieur à 16 MB d’une source CSV :

SELECT $1
  FROM @lob_int_stage/driver_status.csv.gz (FILE_FORMAT => 'csv_format');
Copy
Message d’erreur avant le changement:
100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <object_size>
Message d’erreur après le changement:
100082 (22000): The data length in result column $1 is not supported by this version of the client. Actual length <actual_length> exceeds supported length of 16777216.

Interrogation d’un objet entier de grande taille à partir d’une source Parquet

L’exemple suivant tente d’interroger un objet entier supérieur à 16 MB d’une source Parquet :

SELECT $1
  FROM @lob_int_stage/driver_status.parquet (FILE_FORMAT => 'parquet_format');
Copy
Message d’erreur avant le changement:
100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <object_size>
Message d’erreur après le changement:
100082 (22000): The data length in result column $1 is not supported by this version of the client. Actual length <actual_length> exceeds supported length of 16777216.

Inclusion d’objets volumineux dans les résultats de la requête

Vous pouvez désormais créer des objets de plus de 16 MB en mémoire. Cependant, vous ne pouvez pas inclure ces objets dans les résultats de la requête ni les stocker dans une table. Lorsque vous tentez de le faire, un message d’erreur est renvoyé.

Tentative d’inclusion d’un objet de plus de 16 MB dans les résultats de la requête

La requête suivante tente de concaténer deux grandes chaînes :

SELECT large_str || large_str FROM lob_strings;
Copy
Message d’erreur avant le changement:
100078 (22000): String '<preview_of_string>' is too long and would be truncated in 'CONCAT'
Message d’erreur après le changement:
100067 (54000): The data length in result column <column_name> is not supported by this version of the client. Actual length <actual_size> exceeds supported length of 16777216.

Tentative de stockage d’un objet supérieur à 16 MB dans une table

L’instruction CREATE TABLE AS SELECT suivante tente de concaténer deux grandes chaînes :

CREATE OR REPLACE TABLE table_varchar
  AS SELECT large_str || large_str as LOB_column
  FROM lob_strings;
Copy
Message d’erreur avant le changement:
100078 (22000): String '<preview_of_string>' is too long and would be truncated in 'CONCAT'
Message d’erreur après le changement:
100067 (54000): The data length in result column <column_name> is not supported by this version of the client. Actual length <actual_size> exceeds supported length of 16777216.

Création d’un grand objet à l’aide de l’agrégation

Lorsque vous essayez de créer un objet supérieur à 16 MB et d’en renvoyer la sortie, un message d’erreur est affiché.

L’exemple suivant utilise la fonction ARRAY_AGG dans une requête d’une colonne d’objet volumineux :

SELECT ARRAY_AGG(status) FROM lob_object;
Copy
Message d’erreur avant le changement:
100082 (22000): Max LOB size (16777216) exceeded, actual size of parsed column is <actual_size>
Message d’erreur après le changement:
100067 (54000): The data length in result column <column_name> is not supported by this version of the client. Actual length <actual_size> exceeds supported length of 16777216.

Réf : 1779