Gestion des erreurs lors du traitement des cubes, partitions et dimensions (SSAS - Multidimensionnel)

Les propriétés de configuration des erreurs sur les objets cube, partition ou dimension déterminent la façon dont le serveur répond lorsque des erreurs d’intégrité des données se produisent pendant le traitement. Les clés dupliquées, les clés manquantes et les valeurs Null d’une colonne clé déclenchent généralement ces erreurs, et bien que l’enregistrement à l’origine de l’erreur ne soit pas ajouté à la base de données, vous pouvez définir des propriétés qui déterminent ce qui se passe ensuite. Par défaut, le traitement s’arrête. Toutefois, pendant le développement de cube, vous souhaiterez peut-être poursuivre le traitement lorsque des erreurs se produisent afin de pouvoir tester les comportements de cube avec des données importées, même s’il est incomplet.

Cette rubrique contient les sections suivantes :

Ordre d’exécution
Comportements par défaut
Propriétés de configuration d’erreur
Où définir les propriétés de configuration d’erreur
Clés manquantes (KeyNotFound)
Clés étrangères nulles dans une table de faits (CléNonTrouvée)
Clés Null dans une dimension
Clés dupliquées résultant de relations incohérentes (KeyDuplicate)
Modifier la limite d’erreur ou l’action de limite d’erreur
Définir le chemin du journal des erreurs
Étape suivante

Ordre d’exécution

Le serveur exécute toujours les règles NullProcessing avant les règles ErrorConfiguration pour chaque enregistrement. Il est important de comprendre cela, car les propriétés de traitement nul qui convertissent les valeurs nulles en zéros peuvent par la suite introduire des erreurs de clé dupliquée lorsque deux ou plusieurs enregistrements d'erreur ont zéro dans une colonne clé.

Comportements par défaut

Par défaut, le traitement s’arrête lors de la première erreur qui implémente une colonne clé. Ce comportement est contrôlé par une limite d’erreur qui spécifie zéro comme nombre d’erreurs autorisées et la directive Stop Processing qui indique au serveur d’arrêter le traitement lorsque la limite d’erreur est atteinte.

Les enregistrements déclenchant une erreur, en raison de valeurs nulles, manquantes ou dupliquées, sont soit assignés au membre inconnu, soit ignorés. Analysis Services n’importe pas les données qui ne respectent pas les contraintes d’intégrité des données.

La conversion en membre inconnu se produit par défaut, en raison du ConvertToUnknown paramètre pour KeyErrorAction. Les enregistrements alloués à un membre inconnu sont mis en quarantaine dans la base de données en tant que preuves d’un problème que vous souhaiterez peut-être examiner une fois le traitement terminé.

Les membres inconnus sont exclus des charges de travail de requête, mais ils sont visibles dans certaines applications clientes si la valeur UnknownMemberVisible est définie.

Si vous souhaitez suivre le nombre de valeurs Null converties en membre inconnu, vous pouvez modifier la NullKeyConvertedToUnknown propriété pour signaler ces erreurs dans le journal ou dans la fenêtre Traitement.
La suppression se produit lorsque vous paramétrez manuellement la propriété KeyErrorAction à DiscardRecord.

Grâce aux propriétés de configuration d’erreur, vous pouvez déterminer la façon dont le serveur répond lorsqu’une erreur se produit. Les options incluent l’arrêt du traitement immédiatement, la poursuite du traitement, mais l’arrêt de la journalisation ou la journalisation des erreurs. Les valeurs par défaut varient en fonction de la gravité de l’erreur.

Le comptage des erreurs suit leur fréquence d'occurrence. Lorsque vous définissez une limite supérieure, la réponse du serveur change lorsque cette limite est atteinte. Par défaut, le serveur cesse de traiter une fois la limite atteinte. La limite par défaut est 0, ce qui entraîne l’arrêt du traitement lors de la première erreur comptabilisée.

Les erreurs à impact élevé, telles qu’une clé manquante ou une valeur Null dans un champ de clé, doivent être traitées rapidement. Par défaut, ces erreurs respectent ReportAndContinue les comportements du serveur, où le serveur intercepte l’erreur, l’ajoute au nombre d’erreurs, puis continuent de traiter (sauf que la limite d’erreur est zéro, donc le traitement s’arrête immédiatement).

D’autres erreurs sont générées, mais non comptabilisées ou journalisées par défaut (il s’agit du IgnoreError paramètre), car l’erreur ne pose pas nécessairement de problème d’intégrité des données.

Les nombres d’erreurs sont affectés par les paramètres de traitement Null. Pour les attributs de dimension, les options de traitement null déterminent la façon dont le serveur répond lorsque des valeurs Null sont rencontrées. Par défaut, les valeurs Null d’une colonne numérique sont converties en zéros, tandis que les valeurs Null d’une colonne de chaîne sont traitées en tant que chaînes vides. Vous pouvez outrepasser les propriétés NullProcessing pour intercepter les valeurs nulles avant qu'elles ne se transforment en erreurs KeyNotFound ou KeyDuplicate. Voir les clés Null dans une dimension pour plus de détails.

Les erreurs sont consignées dans la boîte de dialogue Processus, mais pas enregistrées. Vous pouvez spécifier un nom de fichier journal d’erreurs clé pour collecter des erreurs dans un fichier texte.

Propriétés de configuration d’erreur

Les propriétés de configuration d'erreur sont au nombre de neuf. Cinq sont utilisés pour déterminer la réponse du serveur lorsqu’une erreur spécifique se produit. Les quatre autres sont limités aux charges de travail de configuration d’erreurs, telles que le nombre d’erreurs à autoriser, ce qu’il faut faire quand cette limite est atteinte, s’il faut collecter des erreurs dans un fichier journal.

Réponse du serveur à des erreurs spécifiques

Propriété	Par défaut	Autres valeurs
`CalculationError` Se produit lors de l’initialisation de la configuration d’erreur.	`IgnoreError` ne consigne ni ne compte l'erreur ; le processus continue tant que la quantité d'erreurs reste sous la limite maximale.	`ReportAndContinue` enregistre et compte l’erreur. `ReportAndStop` signale l’erreur et arrête le traitement immédiatement, quelle que soit la limite d’erreur.
`KeyNotFound` Se produit lorsqu’une clé étrangère dans une table de faits n’a pas de clé primaire correspondante dans une table de dimension associée (par exemple, une table de faits Sales a un enregistrement avec un ID de produit qui n’existe pas dans la table de dimension Product). Cette erreur peut se produire pendant le traitement de partition ou le traitement de dimension des dimensions flocons de neige.	`ReportAndContinue` enregistre et compte l’erreur.	`ReportAndStop` signale l’erreur et arrête le traitement immédiatement, quelle que soit la limite d’erreur. `IgnoreError` ne consigne ni ne compte l'erreur, le traitement se poursuit tant que le nombre d’erreurs reste inférieur à la limite maximale. Les enregistrements qui déclenchent cette erreur sont convertis en membre inconnu par défaut, mais vous pouvez modifier la propriété `KeyErrorAction` pour les éliminer plutôt.
`KeyDuplicate` Se produit lorsque des clés d’attribut dupliquées sont trouvées dans une dimension. Dans la plupart des cas, il est acceptable d’avoir des clés d’attribut en double, mais cette erreur vous informe des doublons afin que vous puissiez vérifier la dimension pour les défauts de conception susceptibles d’entraîner des relations incohérentes entre les attributs.	`IgnoreError` n'enregistre ni ne compte l’erreur ; le traitement se poursuit tant que le nombre d’erreurs est inférieur à la limite maximale.	`ReportAndContinue` enregistre et compte l’erreur. `ReportAndStop` signale l’erreur et arrête le traitement immédiatement, quelle que soit la limite d’erreur.
`NullKeyNotAllowed` Se produit lorsqu’il `NullProcessing` = `Error` est défini sur un attribut de dimension ou lorsqu’il existe des valeurs Null dans une colonne clé d’attribut utilisée pour identifier un membre de manière unique.	`ReportAndContinue` enregistre et compte l’erreur.	`ReportAndStop` signale l’erreur et arrête le traitement immédiatement, quelle que soit la limite d’erreur. `IgnoreError` n'enregistre ni ne compte l'erreur ; le traitement continue tant que le compte d’erreurs est inférieur à la limite maximale. Les enregistrements qui déclenchent cette erreur sont convertis en membre inconnu par défaut, mais vous pouvez définir la propriété `KeyErrorAction` pour les supprimer à la place.
`NullKeyConvertedToUnknown` Se produit lorsque les valeurs Null sont ensuite converties en membre inconnu. La définition `NullProcessing` = `ConvertToUnknown` d’un attribut de dimension déclenche cette erreur.	`IgnoreError` n'enregistre ni ne compte l'erreur ; le traitement continue tant que le nombre d’erreurs est inférieur à la limite maximale.	Si vous considérez que cette erreur est informationnelle, conservez la valeur par défaut. Sinon, vous pouvez choisir `ReportAndContinue` de signaler l’erreur à la fenêtre de traitement et d’inclure l’erreur dans le décompte de la limite d’erreurs. `ReportAndStop` signale l’erreur et arrête le traitement immédiatement, quelle que soit la limite d’erreur.

Propriétés générales

Propriété	Valeurs
`KeyErrorAction`	Il s’agit de l’action effectuée par le serveur lorsqu’une `KeyNotFound` erreur se produit. Les réponses valides à cette erreur incluent `ConvertToUnknown` ou `DiscardRecord`.
`KeyErrorLogFile`	Il s’agit d’un nom de fichier défini par l’utilisateur qui doit avoir une extension de fichier .log, située dans un dossier sur lequel le compte de service dispose d’autorisations en lecture-écriture. Ce fichier journal contient uniquement les erreurs générées pendant le traitement. Utilisez l’enregistreur de vol si vous avez besoin d’informations plus détaillées.
`KeyErrorLimit`	Il s’agit du nombre maximal d’erreurs d’intégrité des données que le serveur autorise avant d’échouer le traitement. Une valeur de -1 indique qu’il n’existe aucune limite. La valeur par défaut est 0, ce qui signifie que le traitement s’arrête après la première erreur. Vous pouvez également le définir sur un nombre entier.
`KeyErrorLimitAction`	Il s’agit de l’action effectuée par le serveur lorsque le nombre d’erreurs clés a atteint la limite supérieure. Avec l’arrêt du traitement, le traitement se termine immédiatement. Avec l’arrêt de la journalisation, le traitement continue, mais les erreurs ne sont plus signalées ou comptées.

Où définir les propriétés de configuration d’erreur

Utilisez les pages de propriétés dans SQL Server Management Studio une fois la base de données déployée ou dans le projet de modèle dans SQL Server Data Tools. Les mêmes propriétés se trouvent dans les deux outils. Vous pouvez également définir des propriétés de configuration d’erreur dans le fichier msmdrsrv.ini pour modifier les valeurs par défaut du serveur pour la configuration des erreurs et dans Batch et Process les commandes si le traitement s’exécute en tant qu’opération de script.

Vous pouvez définir une configuration d’erreur sur n’importe quel objet pouvant être traité en tant qu’opération autonome.

SQL Server Management Studio

Dans l’Explorateur d’objets, cliquez sur Propriétés l’un des objets suivants : dimension, cube ou partition.
Dans Propriétés, cliquez sur Configuration d’erreur.

Outils de données SQL Server

Dans l’Explorateur de solutions, double-cliquez sur une dimension ou un cube. ErrorConfiguration apparaît dans Propriétés dans le volet ci-dessous.
Sinon, pour une seule dimension, cliquez avec le bouton droit sur la dimension dans l’Explorateur de solutions, choisissez Process, puis choisissez Modifier les paramètres dans la boîte de dialogue Dimension de processus. Les options de configuration d’erreur s’affichent sous l’onglet Erreurs de clé de dimension.

Clés manquantes (KeyNotFound)

Les enregistrements avec une valeur de clé manquante ne peuvent pas être ajoutés à la base de données, pas même lorsque les erreurs sont ignorées ou que la limite d’erreur est illimitée.

Le serveur génère l’erreur lors du KeyNotFound traitement de partition, lorsqu’un enregistrement de table contient une valeur de clé étrangère, mais que la clé étrangère n’a pas d’enregistrement correspondant dans une table de dimension associée. Cette erreur se produit également lors du traitement des tables de dimension associées ou en flocon, où un enregistrement dans une dimension spécifie une clé étrangère qui n'existe pas dans la dimension correspondante.

Lorsqu’une KeyNotFound erreur se produit, l’enregistrement incriminé est alloué au membre inconnu. Ce comportement est contrôlé par le biais de l’action clé, défini sur ConvertToUnknown, afin que vous puissiez afficher les enregistrements alloués pour une investigation plus approfondie.

Clés étrangères null dans une table de faits (KeyNotFound)

Par défaut, une valeur Null dans une colonne clé étrangère d’une table de faits est convertie en zéro. En supposant que zéro n’est pas une valeur de clé étrangère valide, l’erreur KeyNotFound est enregistrée et comptabilisée vers la limite d’erreur égale à zéro par défaut.

Pour permettre le traitement de continuer, vous pouvez gérer la valeur Null avant qu’elle ne soit convertie et vérifiée pour les erreurs. Pour ce faire, affectez NullProcessing à Error.

Définir la propriété NullProcessing sur une mesure

Dans SQL Server Data Tools, dans l’Explorateur de solutions, double-cliquez sur le cube pour l’ouvrir dans le Concepteur de cube.
Cliquez avec le bouton droit sur une mesure dans le volet Mesures et choisissez Propriétés.
Dans Propriétés, développez Source pour afficher la NullProcessing propriété. Elle est définie sur Automatique par défaut, qui, pour les éléments OLAP, convertit les valeurs Null en zéros pour les champs contenant des données numériques.
Modifiez la valeur à Error afin d'exclure tous les enregistrements ayant une valeur NULL, et évitez la conversion de NULL en numérique (zéro). Cette modification vous permet d’éviter les erreurs de clé en double liées à plusieurs enregistrements ayant zéro dans la colonne clé, et d’éviter KeyNotFound les erreurs lorsqu’une clé étrangère à valeur nulle n’a pas d’équivalent de clé primaire dans une table de dimension associée.

Clés null dans une dimension

Pour continuer le traitement lorsque des valeurs Null sont trouvées dans des clés étrangères dans une dimension floconnée, gérez d’abord les valeurs Null en définissant NullProcessing sur l’attribut KeyColumn de dimension. Cela ignore ou convertit l’enregistrement, avant que l’erreur KeyNotFound puisse se produire.

Vous avez deux options pour gérer les valeurs Null sur l’attribut de dimension :

Définissez NullProcessing=UnknownMember pour allouer des enregistrements avec des valeurs Null au membre inconnu. Cela génère l’erreur NullKeyConvertedToUnknown , qui est ignorée par défaut.
Définir NullProcessing=Error pour exclure les enregistrements avec des valeurs Null. Cela génère l’erreur NullKeyNotAllowed , qui est journalisée et compte vers la limite d’erreur de clé. Vous pouvez définir la propriété de configuration d’erreur sur la clé Null non autorisée pour IgnoreError autoriser le traitement à continuer.

Les valeurs Null peuvent être problématiques pour les champs non clés, dans ce cas, les requêtes MDX retournent des résultats différents selon que la valeur Null est interprétée comme zéro ou vide. Pour cette raison, Analysis Services fournit des options de traitement null qui vous permettent de prédéfinir le comportement de conversion souhaité. Pour plus d'informations, consultez Définition des propriétés du membre inconnu et de traitement des valeurs nulles NullProcessing pour plus de détails.

Définir la propriété NullProcessing sur un attribut de dimension

Dans SQL Server Data Tools, dans l’Explorateur de solutions, double-cliquez sur la dimension pour l’ouvrir dans le Concepteur de dimensions.
Cliquez avec le bouton droit sur un attribut dans le volet Attributs et choisissez Propriétés.
Dans Propriétés, développez KeyColumns pour voir la propriété NullProcessing. Elle est définie sur Automatique par défaut, ce qui convertit les valeurs Null en zéros pour les champs contenant des données numériques. Modifiez la valeur pour qu'elle soit soit Error, soit UnknownMember.

Cette modification supprime les conditions sous-jacentes qui se déclenchent KeyNotFound en ignorant ou en convertissant l’enregistrement avant qu'il ne soit vérifié pour les erreurs.

Selon la configuration des erreurs, l’une de ces actions peut entraîner une erreur signalée et comptabilisée. Vous devrez peut-être ajuster des propriétés supplémentaires, telles que la définition de KeyNotFound sur ReportAndContinue ou de KeyErrorLimit sur une valeur non nulle, pour permettre au traitement de continuer lorsque ces erreurs sont signalées et comptabilisées.

Clés dupliquées résultant de relations incohérentes (KeyDuplicate)

Par défaut, la présence d’une clé en double n’arrête pas le traitement, mais l’erreur est ignorée et l’enregistrement en double est exclu de la base de données.

Pour modifier ce comportement, réglez KeyDuplicate sur ReportAndContinue ou ReportAndStop pour signaler l’erreur. Vous pouvez ensuite examiner l’erreur pour déterminer les défauts potentiels dans la conception de dimension.

Modifier la limite d’erreurs ou l’action à prendre en cas de dépassement de la limite d'erreurs

Vous pouvez augmenter la limite d’erreur pour autoriser davantage d’erreurs pendant le traitement. Il n’existe aucune aide pour augmenter la limite d’erreur ; la valeur appropriée varie en fonction de votre scénario. Les limites d’erreur sont spécifiées comme KeyErrorLimit dans ErrorConfiguration les propriétés de SQL Server Data Tools, ou sous forme de nombre d’erreurs dans l’onglet Configuration des erreurs pour les propriétés des dimensions, des cubes ou des groupes de mesures dans SQL Server Management Studio.

Une fois la limite d’erreur atteinte, vous pouvez spécifier que le traitement s’arrête ou que la journalisation s’arrête. Par exemple, supposons que vous définissez l’action StopLogging sur une limite d’erreur de 100. Sur la 101e erreur, le traitement se poursuit, mais les erreurs ne sont plus journalisées ou comptées. Les actions de limite d’erreur sont spécifiées comme KeyErrorLimitAction dans les propriétés de ErrorConfiguration SQL Server Data Tools, ou comme Action en cas d’erreur dans l’onglet Configuration des erreurs pour des propriétés, telles que des dimensions, des cubes ou bien des groupes de mesures, dans SQL Server Management Studio.

Définir le chemin du journal des erreurs

Vous pouvez spécifier un fichier pour stocker les messages d’erreur liés à la clé signalés pendant le traitement. Par défaut, les erreurs sont visibles pendant le traitement interactif dans la fenêtre Processus, puis ignorées lorsque vous fermez la fenêtre ou la session. Le journal contient uniquement des informations d’erreur relatives aux clés, identiques aux erreurs signalées dans les boîtes de dialogue de traitement.

Les erreurs sont consignées dans un fichier texte et doivent avoir .log extension de fichier. Le fichier est vide, sauf si des erreurs se produisent. Par défaut, un fichier est créé dans le dossier DATA. Vous pouvez spécifier un autre dossier tant que le compte de service Analysis Services peut écrire à cet emplacement.

Étape suivante

Déterminez si les erreurs arrêtent le traitement ou sont ignorées. N’oubliez pas que seule l’erreur est ignorée. L'enregistrement qui a provoqué l'erreur n'est pas ignoré; il est soit supprimé, soit converti en membre inconnu. Les enregistrements qui violent les règles d’intégrité des données ne sont jamais ajoutés à la base de données. Par défaut, le traitement s’arrête lorsque la première erreur se produit, mais vous pouvez le modifier en augmentant la limite d’erreur. Dans le développement de cubes, il est souvent utile d’assouplir les règles de configuration des erreurs, ce qui permet au processus de continuer, pour avoir des données à tester.

Déterminez s’il faut modifier les comportements de traitement null par défaut. Par défaut, les valeurs Null d’une colonne de chaîne sont traitées en tant que valeurs vides, tandis que les valeurs Null d’une colonne numérique sont traitées comme zéro. Consultez Définition des propriétés de traitement de membre inconnu et null pour obtenir des instructions sur la définition du traitement Null sur un attribut.

Voir aussi

Propriétés du journal
Définition des propriétés de traitement de membre inconnu et de null

Last updated on 2017-06-13

Partager via