Bibliothèque de points de contrôle Snowpark¶

Mode de collecte des données par inférence de schéma (schéma)¶

Il s’agit du mode par défaut, qui s’appuie sur l’inférence du schéma Pandera pour obtenir les métadonnées et les contrôles qui seront évalués pour le DataFrame spécifié. Ce mode permet également de collecter des données personnalisées dans les colonnes du DataFrame en fonction du type PySpark.

Les données et les contrôles de la colonne sont collectés en fonction du type PySpark de la colonne (voir les tables ci-dessous). Pour toute colonne, quel que soit son type, les données personnalisées collectées incluront le nom de la colonne, le type de la colonne, Null possible, le nombre de lignes, le nombre de lignes non nulles et le nombre de lignes nulles.

Il définit également un ensemble de contrôles de validation prédéfinis pour chaque type de données, détaillés dans la table suivante :

Ce mode permet à l’utilisateur de définir un échantillon de DataFrame à collecter, mais il est facultatif. Par défaut, la collection fonctionne avec l’ensemble du DataFrame. La taille de l’échantillon doit être statistiquement représentative de la population.

Pandera ne peut que déduire le schéma d’un DataFrame Pandas, ce qui implique que le DataFrame PySpark doit être converti en un DataFrame Pandas, ce qui peut affecter les résolutions de type des colonnes. En particulier, Pandera déduit les types PySpark suivants en tant que types d’objets : string, array, map, null, struct et binary.

La sortie de ce mode est un fichier JSON pour chaque DataFrame collecté, le nom du fichier étant le même que celui du point de contrôle. Ce fichier contient des informations relatives au schéma et comporte deux sections :

1. La section du schéma Pandera contient les données déduites par Pandera telles que le nom, le type (Pandas), si la colonne autorise les valeurs nulles ou non, et d’autres informations pour chaque colonne, ainsi que les vérifications des colonnes basées sur le type PySpark. Il s’agit d’un objet DataFrameSchema de Pandera.

2. La section des données personnalisées est un tableau des données personnalisées collectées par chaque colonne en fonction du type PySpark.

Mode de données DataFrame collectées (DataFrame)¶

Ce mode permet de collecter les données du DataFrame PySpark. Dans ce cas, le mécanisme enregistre toutes les données du DataFrame donné au format Parquet. En utilisant la connexion par défaut de l’utilisateur Snowflake, il tente de télécharger les fichiers Parquet dans la zone de préparation temporelle de Snowflake et de créer une table sur la base des informations contenues dans la phase. Le nom du fichier et de la table est le même que celui du point de contrôle.

La sortie de ce mode est un fichier Parquet résultat de l’enregistrement du DataFrame et une table avec les données du DataFrame dans la connexion de configuration par défaut de Snowflake.

Les fonctions offertes par le cadre¶

• check_with_spark : un décorateur qui convertira tout argument du DataFrame Snowpark en une fonction ou un échantillon, puis en DataFrames PySpark. Le contrôle exécutera ensuite une fonction spark fournie qui reflète la fonctionnalité de la nouvelle fonction Snowpark et comparera les sorties entre les deux implémentations. En supposant que la fonction spark et les fonctions Snowpark sont sémantiquement identiques, cela permet de vérifier ces fonctions sur des données réelles et échantillonnées.

  Paramètres :

  • job_context (SnowparkJobContext) : le contexte de la tâche contenant la configuration et les détails de la validation.

  • spark_function (fn) : la fonction PySpark équivalente pour comparer avec l’implémentation Snowpark.

  • checkpoint_name (str) : nom du point de contrôle. La valeur par défaut est Aucun.

  • sample_number (Optional[int], optional) : le nombre de lignes pour la validation. La valeur par défaut est 100.

  • sampling_strategy (Optional[SamplingStrategy], optional) : la stratégie utilisée pour l’échantillonnage des données. La valeur par défaut est SamplingStrategy.RANDOM_SAMPLE.

  • output_path (Optional[str], optional) : le chemin pour stocker les résultats de la validation. La valeur par défaut est Aucun.

  Voici un exemple :

   def original_spark_code_I_dont_understand(df):
   from pyspark.sql.functions import col, when
  
   ret = df.withColumn(
       "life_stage",
       when(col("byte") < 4, "child")
       .when(col("byte").between(4, 10), "teenager")
       .otherwise("adult"),
   )
   return ret
  
  
  @check_with_spark(
   job_context=job_context, spark_function=original_spark_code_I_dont_understand
  )
  def new_snowpark_code_I_do_understand(df):
    from snowflake.snowpark.functions import col, lit, when
  
    ref = df.with_column(
        "life_stage",
        when(col("byte") < 4, lit("child"))
        .when(col("byte").between(4, 10), lit("teenager"))
        .otherwise(lit("adult")),
   )
   return ref
  
  
   df1 = new_snowpark_code_I_do_understand(df)
  

  Copy

• validate_dataframe_checkpoint : cette fonction valide un Dataframe Snowpark par rapport à un fichier de schéma de point de contrôle spécifique ou un Dataframe importé selon le mode de l’argument. Elle garantit que les informations collectées pour ce DataFrame et le DataFrame transmis à la fonction sont équivalents.

  Paramètres :

  • df (SnowparkDataFrame) : le DataFrame à valider.

  • checkpoint_name (str) : le nom du point de contrôle auquel la validation doit être effectuée.

  • job_context (SnowparkJobContext, optional) (str) : le contexte de la tâche pour la validation. Obligatoire pour le mode PARQUET.

  • mode (CheckpointMode) : le mode de validation (par exemple, SCHEMA, PARQUET). La valeur par défaut est SCHEMA.

  • custom_checks (Optional[dict[Any, Any]], optional) : Vérifications personnalisées à appliquer lors de la validation.

  • skip_checks (Optional[dict[Any, Any]], optional) : contrôles à ignorer lors de la validation.

  • sample_frac (Optional[float], optional) : fraction du DataFrame à échantillonner pour la validation. La valeur par défaut est 0.1.

  • sample_number (Optional[int], optional) : nombre de lignes à échantillonner pour la validation.

  • sampling_strategy (Optional[SamplingStrategy], Optional) : stratégie à utiliser pour l’échantillon.

  • output_path (Optional[str], optional) : le chemin de sortie des résultats de la validation.

  Voici un exemple :

  # Check a schema/stats here!
  validate_dataframe_checkpoint(
     df1,
  "demo_add_a_column_dataframe",
  job_context=job_context,
  mode=CheckpointMode.DATAFRAME, # CheckpointMode.Schema)
  )
  

  Copy

  En fonction du mode choisi, la validation utilisera soit le fichier de schéma collecté, soit un Dataframe chargé par Parquet dans Snowflake pour vérifier l’équivalence par rapport à la version PySpark.

• check-ouput_schema : ce décorateur valide le schéma de la sortie d’une fonction Snowpark et s’assure que le DataFrame de sortie est conforme à un schéma Pandera spécifié. Il est particulièrement utile pour assurer l’intégration et la cohérence des données dans les pipelines Snowpark. Ce décorateur prend plusieurs paramètres, dont le schéma Pandera à valider, le nom du point de contrôle, les paramètres d’échantillonnage et un contexte de tâche optionnelle. Il enveloppe la fonction Snowpark et effectue une validation de schéma sur le DataFrame de sortie avant de renvoyer le résultat.

  Voici un exemple :

  from pandas import DataFrame as PandasDataFrame
  from pandera import DataFrameSchema, Column, Check
  from snowflake.snowpark import Session
  from snowflake.snowpark import DataFrame as SnowparkDataFrame
  from snowflake.snowpark_checkpoints.checkpoint import check_output_schema
  from numpy import int8
  
  # Define the Pandera schema
  out_schema = DataFrameSchema(
  {
       "COLUMN1": Column(int8, Check.between(0, 10, include_max=True, include_min=True)),
       "COLUMN2": Column(float, Check.less_than_or_equal_to(-1.2)),
       "COLUMN3": Column(float, Check.less_than(10)),
  }
  )
  
  # Define the Snowpark function and apply the decorator
  @check_output_schema(out_schema, "output_schema_checkpoint")
  def preprocessor(dataframe: SnowparkDataFrame):
    return dataframe.with_column(
       "COLUMN3", dataframe["COLUMN1"] + dataframe["COLUMN2"]
  )
  
  # Create a Snowpark session and DataFrame
  session = Session.builder.getOrCreate()
  df = PandasDataFrame(
  {
       "COLUMN1": [1, 4, 0, 10, 9],
       "COLUMN2": [-1.3, -1.4, -2.9, -10.1, -20.4],
  }
  )
  
  sp_dataframe = session.create_dataframe(df)
  
  # Apply the preprocessor function
  preprocessed_dataframe = preprocessor(sp_dataframe)
  

  Copy

• check_input_schema : ce décorateur valide le schéma des arguments d’entrée d’une fonction Snowpark. Ce décorateur garantit que le DataFrame d’entrée est conforme à un schéma Pandera spécifié avant l’exécution de la fonction. Il est particulièrement utile pour assurer l’intégration et la cohérence des données dans les pipelines Snowpark. Ce décorateur prend plusieurs paramètres, dont le schéma Pandera à valider, le nom du point de contrôle, les paramètres d’échantillonnage et un contexte de tâche optionnelle. Il enveloppe la fonction Snowpark et effectue une validation de schéma sur le DataFrame d’entrée avant d’exécuter la fonction.

  Voici un exemple :

  from pandas import DataFrame as PandasDataFrame
  from pandera import DataFrameSchema, Column, Check
  from snowflake.snowpark import Session
  from snowflake.snowpark import DataFrame as SnowparkDataFrame
  from snowflake.snowpark_checkpoints.checkpoint import check_input_schema
  from numpy import int8
  
  # Define the Pandera schema
  input_schema = DataFrameSchema(
  {
       "COLUMN1": Column(int8, Check.between(0, 10, include_max=True, include_min=True)),
       "COLUMN2": Column(float, Check.less_than_or_equal_to(-1.2)),
  }
  )
  
  # Define the Snowpark function and apply the decorator
  @check_input_schema(input_schema, "input_schema_checkpoint")
  def process_dataframe(dataframe: SnowparkDataFrame):
   return dataframe.with_column(
       "COLUMN3", dataframe["COLUMN1"] + dataframe["COLUMN2"]
  )
  
  # Create a Snowpark session and DataFrame
  session = Session.builder.getOrCreate()
  df = PandasDataFrame(
  {
       "COLUMN1": [1, 4, 0, 10, 9],
       "COLUMN2": [-1.3, -1.4, -2.9, -10.1, -20.4],
  }
  )
  sp_dataframe = session.create_dataframe(df)
  
  # Apply the process_dataframe function
  processed_dataframe = process_dataframe(sp_dataframe)
  

  Copy

Contrôles statistiques¶

Les validations statistiques sont appliquées par défaut au type de colonne spécifique lorsque la validation est exécutée en mode Schema ; ces contrôles peuvent être ignorés avec skip_checks.

Ignorer les contrôles¶

Il existe un contrôle granulaire des contrôles, qui vous permet d’ignorer la validation d’une colonne ou des contrôles spécifiques pour une colonne. Avec le paramètre skip_checks, vous pouvez spécifier la colonne particulière et le type de validation que vous souhaitez ignorer. Le nom du contrôle utilisé à ignorer est celui qui est associé au contrôle.

• str_contains

• str_endswith

• str_length

• str_matches

• str_startswith

• in_range

• ​​equal_to

• greater_than_or_equal_to

• greater_than

• less_than_or_equal_to

• less_than

• not_equal_to

• notin

• isin

df = pd.DataFrame(
{
       "COLUMN1": [1, 4, 0, 10, 9],
       "COLUMN2": [-1.3, -1.4, -2.9, -10.1, -20.4],
}
)

schema = DataFrameSchema(
{
       "COLUMN1": Column(int8, Check.between(0, 10, element_wise=True)),
       "COLUMN2": Column(
           float,
           [
               Check.greater_than(-20.5),
               Check.less_than(-1.0),
               Check(lambda x: x < -1.2),
           ],
       ),
}
)

session = Session.builder.getOrCreate()
sp_df = session.create_dataframe(df)
check_dataframe_schema(
   sp_df,
   schema,
   skip_checks={"COLUMN1": [SKIP_ALL], "COLUMN2": ["greater_than", "less_than"]},
)

Contrôles personnalisés¶

Vous pouvez ajouter des contrôles supplémentaires au schéma généré à partir du fichier JSON à l’aide de la propriété custom_checks. Cette opération ajoutera le contrôle au schéma pandera :

df = pd.DataFrame(
 {
       "COLUMN1": [1, 4, 0, 10, 9],
       "COLUMN2": [-1.3, -1.4, -2.9, -10.1, -20.4],
 }
)

session = Session.builder.getOrCreate()
sp_df = session.create_dataframe(df)

# Those check will be added to the schema generate from the JSON file
result = validate_dataframe_checkpoint(
  sp_df,
  "checkpoint-name",
  custom_checks={
       "COLUMN1": [
           Check(lambda x: x.shape[0] == 5),
           Check(lambda x: x.shape[1] == 2),
  ],
  "COLUMN2": [Check(lambda x: x.shape[0] == 5)],
 },
)

Stratégies d’échantillonnage¶

Le processus d’échantillonnage du code fourni est conçu pour valider efficacement de larges DataFrames en prenant un échantillon représentatif des données. Cette approche permet d’effectuer la validation des schémas sans avoir à traiter l’ensemble des données, ce qui peut s’avérer coûteux en temps et en argent.

Paramètres :

• sample_frac : ce paramètre indique la fraction du DataFrame à échantillonner. Par exemple, si sample_frac est défini sur 0.1, 10 % des lignes du DataFrame seront échantillonnées. Ceci est utile lorsque vous souhaitez valider un sous-ensemble de données afin d’économiser les ressources calcul.

• sample_number : ce paramètre indique le nombre exact de lignes à échantillonner dans le DataFrame. Par exemple, si sample_number est défini sur 100, 100 lignes seront échantillonnées dans le DataFrame. Cette fonction est utile lorsque vous souhaitez valider un nombre fixe de lignes, quelle que soit la taille du DataFrame.

Résultat de validation¶

Après l’exécution de tout type de validation, le résultat, qu’il soit positif ou négatif, est enregistré sur checkpoint_validation_results.json. Ce fichier est principalement utilisé pour les fonctionnalités de l’extension VSCode. Il contient des informations sur le statut de la validation, l’horodatage, le nom du point de contrôle, le numéro de la ligne où se produit l’exécution de la fonction et le fichier.

Il consignera également le résultat dans le compte Snowflake par défaut dans une table appelée SNOWPARK_CHECKPOINTS_REPORT, qui contiendra des informations sur le résultat de la validation.

• DATE : horodatage d’exécution de la validation.

• JOB : nom du SnowparkJobContext.

• STATUS : statut de la validation.

• CHECKPOINT : nom du point de contrôle validé.

• MESSAGE : message d’erreur

• DATA : données de l’exécution de la validation.

• EXECUTION_MODE : le mode de validation est exécuté.

Variable d’environnement du point de contrôle¶

Le comportement par défaut du cadre pour trouver le fichier checkpoints.json est de rechercher une variable d’environnement appelée SNOWFLAKE_CHECKPOINT_CONTRACT_FILE_PATH_ENV_VAR. Cette variable contiendra le chemin relatif de checkpoint.json. Il est attribué par l’extension VSCode lorsque vous exécutez le point de contrôle avec les lentilles de code dans le code. Si la variable d’environnement n’est pas attribuée, le cadre essaiera de rechercher le fichier dans le répertoire de travail actuel.

Test unitaire Hypothesis¶

Hypothesis est une puissante bibliothèque de tests pour Python conçue pour améliorer les tests unitaires traditionnels en générant automatiquement un large éventail de données d’entrée. Elle utilise des tests basés sur les propriétés, où au lieu de spécifier des cas de test individuels, vous pouvez décrire le comportement attendu de votre code avec des propriétés ou des conditions. Hypothesis génère des exemples pour tester ces propriétés en profondeur. Cette approche permet de découvrir les cas limites et les comportements inattendus, ce qui la rend particulièrement efficace pour les fonctions complexes. Pour plus d’informations, voir Hypothesis.

Le paquet snowpark-checkpoints-hypothesis étend la bibliothèque Hypothesis pour générer des DataFrames Snowpark synthétiques à des fins de test. En tirant parti de la possibilité qu’offre Hypothesis de générer des données de test diverses et aléatoires, vous pouvez créer des DataFrames Snowpark avec des schémas et des valeurs variés pour simuler des scénarios réels et découvrir des cas limites, en garantissant la robustesse du code et en vérifiant l’exactitude des transformations complexes.

La stratégie d’Hypothesis pour Snowpark s’appuie sur Pandera pour générer des données synthétiques. La fonction dataframe_strategy utilise le schéma spécifié pour générer un DataFrame Pandas qui s’y conforme et le convertit ensuite en un DataFrame Snowpark.

Signature de la fonction :

def dataframe_strategy(
  schema: Union[str, DataFrameSchema],
  session: Session,
  size: Optional[int] = None
) -> SearchStrategy[DataFrame]

Paramètres de fonction :

• schema : le schéma qui définit les colonnes, les types de données et les contrôles auxquels le dataframe Snowpark généré doit correspondre. Le schéma peut être le suivant :

  • Un chemin vers un fichier de schéma JSON généré par la fonction collect_dataframe_checkpoint du paquet snowpark-checkpoints-collectors.

  • Une instance de pandera.api.pandas.container.DataFrameSchema.

• session : une instance de snowflake.snowpark.Session qui sera utilisée pour créer les DataFrames Snowpark.

• size : le nombre de lignes à générer pour chaque DataFrame Snowpark. Si ce paramètre n’est pas fourni, la stratégie générera des DataFrames de tailles différentes.

Sortie de fonction :

Renvoie une SearchStrategy Hypothesis qui génère des DataFrames Snowpark.

Types de données pris en charge et non pris en charge¶

La fonction dataframe_strategy permet de générer les DataFrames Snowpark avec différents types de données. Selon le type de l’argument du schéma transmis à la fonction, les types de données pris en charge par la stratégie varieront. Notez que si la stratégie trouve un type de données non pris en charge, elle lèvera une exception.

Le tableau suivant indique les types de données PySpark pris en charge et non pris en charge par la fonction dataframe_strategy lorsqu’un fichier JSON est transmis en tant qu’argument schema.

La table suivante présente les types de données Pandera pris en charge par la fonction dataframe_strategy lorsqu’elle transmet un objet DataFrameSchema en tant qu’argument schema et les types de données Snowpark auxquels ils sont mappés.

Exemples¶

Le processus typique d’utilisation de la bibliothèque Snowpark pour générer les DataFrames est le suivant :

1. Créez une fonction de test Python standard avec les différentes assertions ou conditions que votre code doit satisfaire pour toutes les entrées.

2. Ajoutez le décorateur Hypothesis @given à votre fonction de test et passez la fonction dataframe_strategy en argument. Pour plus d’informations sur le décorateur @given, voir hypothesis.given.

3. Exécutez la fonction de test. Lors de l’exécution du test, Hypothesis fournira automatiquement les entrées générées comme arguments au test.

Exemple 1 : générer les DataFrames de Snowpark à partir d’un fichier JSON

Vous trouverez ci-dessous un exemple de génération de DataFrames Snowpark à partir d’un fichier de schéma JSON généré par la fonction collect_dataframe_checkpoint du paquet snowpark-checkpoints-collectors.

from hypothesis import given

from snowflake.hypothesis_snowpark import dataframe_strategy
from snowflake.snowpark import DataFrame, Session


@given(
    df=dataframe_strategy(
        schema="path/to/file.json",
        session=Session.builder.getOrCreate(),
        size=10,
    )
)
def test_my_function_from_json_file(df: DataFrame):
    # Test a particular function using the generated Snowpark DataFrame
    ...

Exemple 2 : générer un DataFrame Snowpark à partir d’un objet DataFrameSchema Pandera

Vous trouverez ci-dessous un exemple de la manière de générer les DataFrames Snowpark à partir d’une instance de DataFrameSchema Pandera. Pour plus d’informations, voir DataFrameSchema Pandera.

import pandera as pa

from hypothesis import given

from snowflake.hypothesis_snowpark import dataframe_strategy
from snowflake.snowpark import DataFrame, Session


@given(
    df=dataframe_strategy(
        schema=pa.DataFrameSchema(
            {
                "boolean_column": pa.Column(bool),
                "integer_column": pa.Column("int64", pa.Check.in_range(0, 9)),
                "float_column": pa.Column(pa.Float32, pa.Check.in_range(10.5, 20.5)),
            }
        ),
        session=Session.builder.getOrCreate(),
        size=10,
    )
)
def test_my_function_from_dataframeschema_object(df: DataFrame):
    # Test a particular function using the generated Snowpark DataFrame
    ...

Exemple 3 : personnaliser le comportement d’Hypothesis

Vous pouvez également personnaliser le comportement de votre test à l’aide du décorateur Hypothesis @settings. Ce décorateur vous permet de personnaliser divers paramètres de configuration afin d’adapter le comportement du test à vos besoins. En utilisant le décorateur @settings, vous pouvez contrôler des aspects tels que le nombre maximum de cas de test, la date limite pour chaque exécution de test, les niveaux de verbosité et bien d’autres. Pour plus d’informations, voir Paramètres d’Hypothesis.

from datetime import timedelta

from hypothesis import given, settings
from snowflake.snowpark import DataFrame, Session

from snowflake.hypothesis_snowpark import dataframe_strategy


@given(
    df=dataframe_strategy(
        schema="path/to/file.json",
        session=Session.builder.getOrCreate(),
    )
)
@settings(
    deadline=timedelta(milliseconds=800),
    max_examples=25,
)
def test_my_function(df: DataFrame):
    # Test a particular function using the generated Snowpark DataFrame
    ...

Vue¶

En définissant la propriété des points de contrôle Snowpark sur Enabled, comme expliqué précédemment, vous ouvrirez un nouvel onglet dans l’extension appelé SNOWPARK CHECKPOINTS. Il affiche tous les points de contrôle dans l’espace de travail et permet d’effectuer plusieurs actions, telles que l’activation/désactivation de tous les points de contrôle ou d’un seul d’entre eux, l’effacement de tous les fichiers et, en double-cliquant sur chaque point de contrôle, la navigation vers le fichier et la ligne de code où il est défini.

Basculer tous les points de contrôle¶

Située en haut à droite de l’onglet Snowpark Checkpoints, cette option permet d’activer la propriété dans tous les points de contrôle.

Points de contrôle activés :

La désactivation d’un point de contrôle a pour effet de l’ignorer lors de l’environnement d’exécution.

Nettoyage de tous les points de contrôle¶

Situé dans le coin supérieur droit de l’onglet Snowpark Checkpoints. Cela supprime les points de contrôle de tous les fichiers Python, y compris les Notebooks Jupyter, dans votre espace de travail, mais cela ne les supprime pas du contrat et du panneau. Cela signifie qu’ils peuvent être restaurés à l’aide de la commande Snowflake: Restore All Checkpoints.

Insertion de points de contrôle dans un fichier¶

En cliquant avec le bouton droit de la souris à l’intérieur d’un fichier, vous ferez apparaître un menu contextuel contenant l’option Snowpark Checkpoints, qui permet d’ajouter des points de contrôle Collection et Validation.

Option des points de contrôle Snowpark dans le menu contextuel :

Ajout d’un collecteur/validateur :

Exécution d’un seul point de contrôle¶

Un seul point de contrôle peut être exécuté en cliquant sur l’option de lentille de code affichée au-dessus de chaque point de contrôle. Son exécution fait apparaître une console de sortie montrant la progression et, une fois qu’elle est terminée, la vue des résultats. Même si le point de contrôle est désactivé dans le fichier de contrat, il sera activé juste pour son exécution.

Si un point d’entrée n’est pas déclaré dans le fichier des contrats, le message d’erreur : Point d’entrée non trouvé pour le point de contrôle. s’affiche.

Exécution de tous les points de contrôle Snowpark activés dans un fichier¶

Dans le coin supérieur droit de chaque fichier, le bouton Run all checkpoints from the current file est présent.

En cliquant dessus, vous ferez apparaître un canal de sortie affichant la progression de l’exécution.

Vue de la ligne du temps¶

Affiche une chronologie des résultats de l’exécution des points de contrôle.

Commandes¶

Les commandes suivantes sont disponibles pour les points de contrôle Snowpark. Pour les utiliser, entrez Snowflake: [command name] dans la palette de commandes.

Avertissements¶

• Dupliquer : dans un projet de collecte, si deux points de contrôle portent le même nom, un avertissement s’affiche : « Un autre point de contrôle portant un nom identique a été détecté et sera écrasé. » Les projets de validation peuvent avoir plusieurs points de contrôle partageant le même nom, aucun avertissement ne sera affiché.

• Mauvais type : l’ajout d’un point de contrôle d’un type différent de celui du projet le soulignera avec le message d’erreur suivant : « Veuillez vous assurer que vous utilisez la bonne instruction pour les points de contrôle Snowpark. Cette instruction de point de contrôle particulière est différente des autres utilisées dans ce projet, les instructions qui ne correspondent pas au type de projet seront ignorées lors de leur exécution. »

• Nom de point de contrôle non valide : il existe des façons non valides d’ajouter un paramètre de nom de point de contrôle. Dans ce cas, un message d’avertissement s’affiche : « Nom de point de contrôle non valide. Les noms des points de contrôle doivent commencer par une lettre et ne peuvent contenir que des lettres, des chiffres, des traits d’union et des traits de soulignement ».