Configuration du transcodeur

Vous pouvez configurer le transcodeur du connecteur Mainframe en ajoutant la configuration requise dans un fichier JSON. Ce fichier est appelé "fichier de configuration du transcodeur". Vous devez définir la configuration comme indiqué dans la section Configuration. Les commandes qsam encode et qsam decode utilisent le fichier de configuration du transcodeur pour transcoder les données.

Cette page décrit les différentes manières de configurer le transcodeur du connecteur Mainframe.

Configuration

L'objet Configuration est la racine de la configuration du transcodeur. Il contient toutes les options de configuration du transcodeur.

Représentation JSON 
{
    "defaults": object (DefaultsSection),
    "field_overrides": object (FieldOverride),
    "field_suffixes": object (FieldSuffix),
    "header_records_to_skip": long,
    "record_filter_condition": string,
    "schema_validation_mode": enum (SchemaValidationMode),
    "transformations": object (Transformation)
}
Champs
defaults

object (DefaultsSection)

Spécifiez les modificateurs de champ par défaut pour les archétypes Cobol.
field_overrides

object (FieldOverride)

Spécifiez les remplacements de champs.
field_suffixes

object (FieldSuffix)

Spécifiez les suffixes de champ.
header_records_to_skip

long

Spécifiez le nombre de premiers enregistrements à ignorer.
record_filter_condition

string

Spécifiez une condition de filtre pour les enregistrements.

Le filtre est basé sur un sous-ensemble de CEL (Common Expression Language) et accepte les éléments suivants :

  • Accès aux champs : les champs peuvent être référencés par leur nom. Pour les champs imbriqués, utilisez la notation par points (par exemple, PARENT.CHILD).
  • Opérateurs de comparaison : `==`, `!=`, `<`, `<=`, `>`, `>=`.
  • Opérateurs logiques : `&&` (AND), `||` (OR), `!` (NOT).
  • Contenu de la liste : `in` (vérifie si une valeur est présente dans une liste).
  • Opérateurs arithmétiques : `+`, `-`, `*`, `/`, `%`.
  • Fonctions de chaîne et de liste :
    • size() : renvoie la longueur d'une chaîne ou d'une liste.
    • contains(substring) : vérifie si une chaîne contient une sous-chaîne spécifiée.
    • startsWith(prefix) : vérifie si une chaîne commence par un préfixe spécifié.
    • endsWith(suffix) : vérifie si une chaîne se termine par un suffixe spécifié.
  • Constantes de date et de code temporel :
    • date(string) : analyse une date au format ISO (AAAA-MM-JJ). Exemple : date('2025-01-12').
    • date(string, format) : analyse une date à l'aide d'un format personnalisé. Exemple : date('12/01/2025', 'dd/MM/yyyy').
    • timestamp(string) : analyse un code temporel au format ISO. Exemple : timestamp('1999-05-03T02:34:00Z').
Les comparaisons et les opérations doivent être effectuées entre des variables ou des constantes de types de données identiques ou compatibles (par exemple, comparer des nombres à virgule flottante ou utiliser des constantes de date/code temporel pour les champs de date/code temporel).

Exemple :

"record_filter_condition": "(ACCOUNT-GRP.DATE > date('2025-01-12') ) && ((SCORE_A + SCORE_B) > 134) && FLD-STR.startsWith('HE')"
schema_validation_mode

enum (SchemaValidationMode)

Spécifiez le mode de validation du schéma.
transformations

object (Transformation)

Spécifiez les transformations de champ.

DefaultsSection

L'objet DefaultsSection peut être utilisé pour spécifier des modifications par défaut par types COBOL. Ils sont appliqués avant toute modification de suffixe ou de remplacement.

Représentation JSON 
{
    "alpha_numeric_display": object (FieldModifier),
    "binary": object (FieldModifier),
    "dbcs": object (FieldModifier),
    "hexadecimal_floating_point": object (FieldModifier),
    "national": object (FieldModifier),
    "numeric_display": object (FieldModifier),
    "packed_decimal": object (FieldModifier),
    "utf8": object (FieldModifier)
}
Champs
alpha_numeric_display

object (FieldModifier)

Spécifiez les valeurs par défaut pour les champs alphanumériques (PIC X).
binary

object (FieldModifier)

Spécifiez les valeurs par défaut pour les champs de nombres binaires (COMP).
dbcs

object (FieldModifier)

Valeur par défaut pour les champs dbcs (DISPLAY-1).
hexadecimal_floating_point

object (FieldModifier)

Valeur par défaut pour les champs à virgule flottante hexadécimaux (COMP-1, COMP-2).
national

object (FieldModifier)

Spécifiez les valeurs par défaut pour les champs nationaux (PIC N).
numeric_display

object (FieldModifier)

Spécifiez les valeurs par défaut pour les champs d'affichage numérique (décimal zoné).
packed_decimal

object (FieldModifier)

Spécifiez les valeurs par défaut pour les champs décimaux compressés (COMP-3).
utf8

object (FieldModifier)

Spécifiez les valeurs par défaut pour les champs UTF-8 (PIC U).

FieldModifier

Un modificateur de champ vous permet de modifier l'encodage ou le décodage d'un champ spécifique. Notez que tous les modificateurs ne peuvent pas être appliqués à tous les champs. Pour en savoir plus, consultez la documentation sur les modificateurs spécifiques.

Représentation JSON 
{
    "binary": object (Binary),
    "bytes": object (Bytes),
    "chain": object (ModifierChain),
    "decode_as_null": object (DecodeAsNull),
    "encode_null_as": object (EncodeNullAs),
    "filler": object (Filler),
    "format_date": object (FormatDate),
    "format_timestamp": object (FormatTimestamp),
    "hfp": object (HFP),
    "null_if": object (NullIf),
    "null_if_empty": object (NullIfEmpty),
    "null_if_invalid": object (NullIfInvalid),
    "packed_decimal": object (PackedDecimal),
    "string": object (String),
    "varlen": object (VarLen),
    "zoned_decimal": object (ZonedDecimal)
}
Champs
binary

object (Binary)

Remplace la configuration par défaut des champs numériques binaires.
bytes

object (Bytes)

Traite le champ comme une séquence d'octets bruts, en ignorant les informations de type précédentes.
chain

object (ModifierChain)

Enchaîne plusieurs modificateurs à appliquer de manière séquentielle.
decode_as_null

object (DecodeAsNull)

Définit comment les valeurs nulles doivent être décodées.
encode_null_as

object (EncodeNullAs)

Définit la manière dont les valeurs nulles doivent être encodées.
filler

object (Filler)

Exclut le champ du traitement et de la sortie.
format_date

object (FormatDate)

Formate un champ de chaîne en tant que date.
format_timestamp

object (FormatTimestamp)

Formate un champ de chaîne en tant que code temporel.
hfp

object (HFP)

Interprète le champ comme un nombre à virgule flottante hexadécimal (HFP).
null_if

object (NullIf)

Définit de manière conditionnelle le champ sur "null" en fonction de la valeur d'un autre champ.
null_if_empty

object (NullIfEmpty)

Définit le champ sur "null" si son contenu est considéré comme vide.
null_if_invalid

object (NullIfInvalid)

Définit le champ sur "null" si une erreur de transcodage se produit, ce qui empêche le débordement des enregistrements.
packed_decimal

object (PackedDecimal)

Remplace la configuration par défaut des champs décimaux compressés.
string

object (String)

Remplace la configuration par défaut des champs de chaîne.
varlen

object (VarLen)

Définissez l'enregistrement comme un champ de longueur variable.
zoned_decimal

object (ZonedDecimal)

Remplace la configuration par défaut des champs décimaux zonés.

Binaire

Ignorez les modificateurs précédents et traitez ce champ comme un nombre binaire.

Représentation JSON 
{
    "signedness": enum (BinarySignedness)
}
Champs
signedness

enum (BinarySignedness)

Le signe du nombre.

Octets

Traite le champ comme une séquence d'octets brute. Ce modificateur remplace toutes les informations de type précédentes, ce qui entraîne la conservation des données d'octets bruts du champ telles quelles, sans encodage de caractères ni interprétation numérique spécifiques. Vous pouvez appliquer ce modificateur à n'importe quel champ, quels que soient son type ou sa taille d'origine.

Fournissez un objet JSON vide comme suit :

Représentation JSON 
{
}

DecodeAsNull

Définit la façon dont les valeurs nulles sont interprétées lors du processus de décodage. Comme COBOL n'est pas compatible de manière native avec les valeurs nulles, ce paramètre spécifie les valeurs qui doivent être traitées comme nulles.

Représentation JSON 
{
    "hex_bytes": string,
    "values": string
}
Champs
hex_bytes

string

Liste de représentations hexadécimales d'un seul octet. Lorsqu'un champ contient des répétitions de l'un de ces octets, il est traité comme une valeur nulle. Par exemple, en utilisant FF pour toutes les valeurs élevées et 00 pour toutes les valeurs faibles (vide).
values

string

Liste de représentations de chaînes. Après le décodage initial du champ sous forme de chaîne, si le contenu du champ correspond à l'une de ces valeurs, il sera traité comme nul.

EncodeNullAs

Définit la façon dont les valeurs nulles sont représentées pendant le processus d'encodage.

Représentation JSON 
{
    "hex_byte": string,
    "value": string
}
Champs
hex_byte

string

Encodez cette séquence d'octets spécifique (représentée sous forme de chaîne hexadécimale) lorsque la valeur source est nulle. Par exemple, FF pour un champ de deux octets avec des valeurs élevées. Vous pouvez appliquer cette méthode à n'importe quel champ dont la taille est connue. Les octets sont répétés pour correspondre à la taille du champ sous-jacent.
value

string

Encodez cette valeur spécifique lorsque la valeur source est nulle. Vérifiez que la chaîne est valide pour le type du champ.

Complément alimentaire

Indique qu'un champ sera ignoré lors du traitement. Le champ ne sera pas décodé à partir de l'entrée ni encodé dans la sortie. Il sera exclu du schéma et de la table de données obtenus lors du décodage. Vous pouvez appliquer ce modificateur à n'importe quel champ dont la taille statique est connue.

Fournissez un objet JSON vide comme suit :

Représentation JSON 
{
}

FormatDate

Formatez un champ de chaîne ou numérique en date à l'aide de l'un des formats compatibles. Vous ne pouvez appliquer ce modificateur qu'aux champs dimensionnés. Les champs numériques sont convertis de manière dynamique en leur représentation sous forme de chaîne (à l'exclusion de tout marqueur de signe) avant la mise en forme. Les valeurs de date sont supposées être positives. Les dates numériques négatives ne sont pas acceptées et ne seront pas analysées. Pendant le processus de décodage, les formats sont testés dans l'ordre jusqu'à ce que l'un d'eux corresponde à la chaîne. Lors du processus d'encodage, le premier format est utilisé et les autres sont ignorés.

Représentation JSON 
{
    "formats": object (DateTimeFormat)
}
Champs
formats

object (DateTimeFormat)

Liste des formats de date.

DateTimeFormat

Taille et format à utiliser lors de la conversion du champ en date.

Représentation JSON 
{
    "pattern": string,
    "size": int
}
Champs
pattern

string

Spécifiez le format de date. Pour en savoir plus sur les formats de mise en forme valides, consultez Class DateTimeFormatter.

Remarque : Les années à deux chiffres (yy) sont mappées à la plage 2000-2099. Par exemple, avec le modèle MM/dd/yy, la valeur 05/03/99 est décodée en tant que 2099-05-03.
size

int

Spécifiez la taille du champ auquel ce modèle s'applique.

FormatTimestamp

Formatez une chaîne en code temporel à l'aide de l'un des formats fournis. Cela ne peut être appliqué qu'aux champs dimensionnés. Lors du décodage, les formats sont testés dans l'ordre jusqu'à ce que l'un d'eux corresponde à la chaîne. Lors de l'encodage, le premier format sera utilisé et les autres seront ignorés.

Représentation JSON 
{
    "formats": object (DateTimeFormat)
}
Champs
formats

object (DateTimeFormat)

Liste des formats de code temporel.

HFP

Définissez ce champ sur "Virgule flottante hexadécimale".

Fournissez un objet JSON vide comme suit :

Représentation JSON 
{
}

ModifierChain

Spécifiez une chaîne de modificateurs pour appliquer plusieurs modificateurs en série. Les modificateurs sont appliqués dans l'ordre dans lequel ils sont spécifiés.

Représentation JSON 
{
    "modifiers": object (FieldModifier)
}
Champs
modifiers

object (FieldModifier)

Spécifiez la liste des modificateurs à appliquer.

NullIf

Définissez un champ sur "null" si une condition est remplie. Vous devez spécifier null_value, non_null_value, ou les deux.

Pour créer un champ d'indicateur de valeur nulle, vous pouvez utiliser un FieldSuffix avec un modificateur de champ null_if et définir is_inverse sur true, comme illustré dans les exemples suivants :

Exemple : indicateur de valeur nulle

Pour créer un champ d'indicateur de valeur nulle, nous pouvons utiliser le modificateur de champ null_if comme suit. 

 {
  "field_suffixes": [
   {
     "suffix": "NID",
     "is_inverse": true,
     "modifier": {
     "null_if": {
       "null_value": "?",
       "target_field": "$self"
     }
    }
   }
  ]
 }

Cela permet à tous les champs portant le suffixe NID d'être effectivement des indicateurs de valeur nulle, comme illustré dans l'extrait de copybook suivant : 

 01 REC.
   02 FIELD     PIC X(10).
   02 FIELD-NID PIC X(1).

Exemple : indicateur de valeur nulle binaire

Pour créer un champ d'indicateur de valeur nulle binary, nous pouvons utiliser les modificateurs de champ binary et null_if comme suit. 

 {
  "field_suffixes": [
   {
     "suffix": "NID",
     "modifier": {
       "binary": {}
     }
   },
   {
     "suffix": "NID",
     "is_inverse": true,
     "modifier": {
     "null_if": {
       "null_value": "15",
       "target_field": "$self"
     }
    }
   }
  ]
 }

Cela permet à tous les champs portant le suffixe NID d'être effectivement des indicateurs de valeur nulle binary à l'aide du même copybook que dans l'exemple précédent.

Exemple : Indicateur de valeur nulle pour les octets

Pour créer un champ d'indicateur de valeur nulle bytes, nous pouvons utiliser les modificateurs de champ bytes et null_if comme suit. Les valeurs nulles et non nulles sont exprimées sous la forme HEX. 

 {
  "field_suffixes": [
   {
     "suffix": "NID",
     "modifier": {
       "bytes": {}
     }
   },
   {
     "suffix": "NID",
     "is_inverse": true,
     "modifier": {
     "null_if": {
       "null_value": "FF",
       "target_field": "$self"
     }
    }
   }
  ]
 }

Cela permet à tous les champs avec le suffixe NID d'être effectivement un indicateur de valeur nulle bytes à l'aide du même copybook de l'exemple précédent.

Représentation JSON 
{
    "non_null_value": string,
    "non_null_values": string,
    "null_value": string,
    "null_values": string,
    "target_field": string
}
Champs
non_null_value

string

Lorsqu'il est spécifié, si target_field n'est pas égal à cette valeur, le champ n'est pas décodé ni encodé, et la valeur est définie sur "null".
non_null_values

string

Lorsqu'il est spécifié, si target_field ne correspond à aucune de ces valeurs, le champ n'est pas décodé ni encodé, et la valeur est définie sur "null".
null_value

string

Lorsqu'il est spécifié, si target_field est égal à cette valeur, le champ n'est pas décodé ni encodé, et la valeur est définie sur "null".
null_values

string

Lorsqu'il est spécifié, si target_field est égal à l'une de ces valeurs, le champ n'est pas décodé ni encodé, et la valeur est définie sur "null".
target_field

string

Spécifiez le champ dont vous souhaitez vérifier la valeur. Le champ doit se trouver dans le champ d'application. Pour accéder aux champs imbriqués, vous pouvez utiliser la notation par points (par exemple, "GROUP.FIELD").

NullIfEmpty

Le champ doit être défini sur "null" si tous les octets de ce champ sont définis sur 0.

Fournissez un objet JSON vide comme suit :

Représentation JSON 
{
}

NullIfInvalid

Traiter la valeur comme nulle si le transcodage échoue. Vous ne pouvez appliquer ce modificateur qu'aux champs dimensionnés. Par défaut, lorsqu'un champ ne parvient pas à être décodé, l'enregistrement entier est déplacé vers l'ensemble de données de débordement (erreur) et exclu de la sortie, tandis que le reste du chargement se termine avec les enregistrements valides. Lorsque vous définissez le modificateur null_if_invalid, le connecteur Mainframe conserve l'enregistrement non valide et définit ce champ sur "null". Utilisez-la uniquement lorsque vous souhaitez conserver ces lignes avec une valeur nulle, et pas seulement pour réussir un chargement, car les enregistrements incorrects sont déjà ignorés par défaut. L'erreur est ignorée et n'est pas consignée dans l'ensemble de données de débordement. Pendant le processus de décodage, la valeur de ce champ sera nulle pour cet enregistrement. Pendant le processus d'encodage, si les données ne peuvent pas être écrites, l'intégralité du champ sera remplie d'octets nuls.

Fournissez un objet JSON vide comme suit :

Représentation JSON 
{
}

PackedDecimal

Définissez ce champ sur PackedDecimal.

Représentation JSON 
{
    "logical_type": enum (DecimalLogicalType),
    "negative_sign_nibble": enum (PackedDecimalNegativeNibble)
}
Champs
logical_type

enum (DecimalLogicalType)

Remplacez le type logique. Par défaut, le connecteur Mainframe utilise le type logique optimal en fonction de la précision et de l'échelle.
negative_sign_nibble

enum (PackedDecimalNegativeNibble)

Spécifie le demi-octet à utiliser pour les signes négatifs. Bien que x'B' et x'D' soient tous deux des signes négatifs valides, certains systèmes ou applications mainframe peuvent avoir une convention qui nécessite l'un plutôt que l'autre.

Chaîne

Définit les différentes options liées au décodage et à l'encodage des chaînes. Ne peut être appliqué qu'à un champ de chaîne.

Représentation JSON 
{
    "encoding": string,
    "pad_char": string,
    "trim_suffix": boolean
}
Champs
encoding

string

Encodage avec lequel le champ est encodé.
pad_char

string

Lorsqu'il est défini, les chaînes d'exportation sont complétées avec pad_char. Si ce paramètre est défini, la longueur de pad_char doit être de 1. pad_char n'affecte que l'encodage, le décodage ignore pad_char.
trim_suffix

boolean

Si cette valeur est définie sur "true", tous les espaces blancs à la fin de la chaîne sont supprimés. "trim_suffix" n'affecte que le décodage. L'encodage ignore "trim_suffix". Notez que les chaînes composées uniquement d'espaces blancs deviendront des chaînes vides.

VarLen

Représente un champ de longueur variable.

Un champ de longueur variable se compose de trois parties :

  1. Élément de groupe contenant deux sous-champs.
  2. Champ de l'élément de groupe qui contient la longueur des données de transaction.
  3. Champ de l'élément de groupe qui contient les données.

Le nom du champ de longueur variable sera le nom du groupe.

Fournissez un objet JSON vide comme suit :

Représentation JSON 
{
}

ZonedDecimal

Définit différentes options liées à l'encodage et au décodage des décimales zonées. Vous ne pouvez appliquer ce modificateur qu'à un champ décimal.

Représentation JSON 
{
    "encoding": enum (ZonedDecimalEncoding),
    "logical_type": enum (DecimalLogicalType)
}
Champs
encoding

enum (ZonedDecimalEncoding)

Encodage avec lequel le champ est encodé.
logical_type

enum (DecimalLogicalType)

Spécifiez le type logique à utiliser lors du décodage ou de l'encodage du champ.

FieldOverride

Remplacez ou modifiez la chaîne de décodage et d'encodage pour le champ spécifié.

Représentation JSON 
{
    "field": string,
    "modifier": object (FieldModifier)
}
Champs
field

string

Spécifiez le nom du champ auquel appliquer le modificateur.
modifier

object (FieldModifier)

Spécifiez le modificateur à appliquer au champ correspondant.

FieldSuffix

Les suffixes de champ s'appliquent à tous les champs qui en comportent un.

Les champs sont mis en correspondance s'ils se terminent par un trait d'union (-) ou un trait de soulignement (_) suivi du suffixe.

Les suffixes ne sont pas sensibles à la casse.

Le modificateur FieldSuffix est appliqué après le modificateur FieldOverride.

Par exemple, le modificateur défini pour le suffixe NID sera appliqué au champ nommé FLD-NID, mais pas au champ FUNID.

Représentation JSON 
{
    "is_inverse": boolean,
    "modifier": object (FieldModifier),
    "suffix": string
}
Champs
is_inverse

boolean

Indiquez si le modificateur est un modificateur de champ inverse ou non. Un modificateur de champ inverse applique le modificateur à un autre champ portant le même nom que le champ avec le modificateur, mais sans le modificateur. Par exemple, si les champs FLD-NID et FLD existent tous deux dans le même enregistrement, le modificateur sera appliqué à FLD.

Lorsque vous utilisez un modificateur de champ inverse, l'identifiant spécial $self peut être utilisé chaque fois qu'un nom de champ peut traditionnellement être utilisé pour faire référence au champ avec le suffixe.

Par exemple, pour créer un champ d'indicateur de valeur nulle, vous pouvez utiliser le modificateur de champ null_if avec is_inverse défini sur true. Pour en savoir plus, consultez NullIf.
modifier

object (FieldModifier)

Spécifiez le modificateur à appliquer aux champs correspondants.
suffix

string

Le modificateur sera appliqué au champ portant ce suffixe.

Transformation

Les transformations de vue permettent de modifier la relation entre la table et le fichier QSAM. Les transformations sont toujours formulées du point de vue des données. Le concept est similaire à celui des tables de vues dans BigQuery.

Représentation JSON 
{
    "exclude": object (Exclude),
    "move": object (Move),
    "rename": object (Rename),
    "split": object (Split),
    "target_table": string,
    "unnest": object (Unnest)
}
Champs
exclude

object (Exclude)
move

object (Move)
rename

object (Rename)
split

object (Split)
target_table

string

Facultatif. Spécifiez le nom de la table cible (vue) à laquelle appliquer la transformation.

Par défaut, les transformations s'appliquent à la table principale (_main) ou globalement, le cas échéant. Si vous avez des vues fractionnées (créées par une transformation split), vous pouvez cibler une table fractionnée spécifique par son nom.

Remarque : Les transformations de fractionnement elles-mêmes ne peuvent pas être ciblées et génèrent une erreur si target_table est défini.
unnest

object (Unnest)

Exclure

Excluez un champ de la table obtenue, mais effectuez tout de même le décodage ou l'encodage. Cela est utile lorsque le champ n'a pas besoin d'être transféré vers la table, mais qu'il est requis pour le transcodage. Par exemple, les champs d'indicateur ou de longueur de valeur nulle peuvent être omis de la table.

Pour contourner complètement le transcodage, appliquez le modificateur de remplissage.

Représentation JSON 
{
    "field": string
}
Champs
field

string

Spécifiez le champ à exclure.

Déplacer

Déplacez un champ dans l'enregistrement.

Représentation JSON 
{
    "field": string,
    "offset": int
}
Champs
field

string

Spécifiez le champ à déplacer.
offset

int

Spécifiez le nombre de places, vers l'avant ou vers l'arrière, dont le champ doit être déplacé.

Renommer

Renommez un ou plusieurs champs en fonction d'une correspondance d'expression régulière.

Par exemple, pour remplacer tous les traits d'union par des traits de soulignement, utilisez le format JSON suivant : {"find": "\\-", "replace":"_"}.

Représentation JSON 
{
    "find": string,
    "replace": string
}
Champs
find

string

Spécifie un modèle d'expression régulière Java pour identifier le ou les champs à renommer.

Le modèle est mis en correspondance avec le nom complet du champ. Si le modèle correspond à une partie du nom du champ, le champ est considéré comme correspondant.

Exemples :

  • "\\-" (correspond à tout champ contenant un trait d'union)
  • "^field_name$" (correspond aux champs portant exactement le nom field_name)
  • "^field_(.*)$" (correspond à tous les champs commençant par field_ et capture le reste)
  • "part_of_name" (correspond à n'importe quel champ contenant part_of_name)
replace

string

Spécifie le nouveau nom du ou des champs correspondants.

Les groupes de capture de l'expression régulière find peuvent être utilisés dans la chaîne replace à l'aide de références arrière telles que $1, $2. Cela permet d'effectuer des transformations plus complexes en fonction de parties du nom de champ d'origine.

Exemples :

  • "new_field_name" (remplace le champ par un nom fixe)
  • "new_$1" (utilise le premier groupe de capture de find)
  • "${1}_new" (syntaxe alternative pour les groupes de capture)
  • "prefix_$1_suffix" (utilise un groupe de capture et ajoute des préfixes/suffixes)

Diviser

Représentation JSON 
{
    "field": string,
    "foreign_key": string,
    "primary_key": string
}
Champs
field

string

Spécifiez le champ que vous souhaitez diviser.
foreign_key

string

Spécifiez le nom du champ qui sera ajouté au nouveau schéma où la valeur de la clé primaire sera stockée. Si aucune valeur n'est spécifiée, le nom de la clé primaire est utilisé.
primary_key

string

Spécifiez le nom du champ qui sera utilisé comme clé primaire.

Désimbriquer

Annulez l'imbrication du champ.

Représentation JSON 
{
    "field": string,
    "format": string
}
Champs
field

string

Spécifier le champ à annuler l'imbrication
format

string

Spécifiez le nouveau format de champ.

${parent} sera remplacé par le nom du champ dont l'imbrication est annulée.

Pour les structures non imbriquées, ${field} est remplacé par le nom du champ de la structure.

Pour les tableaux et les listes non imbriqués, ${index} est remplacé par les index du tableau.

Enums

BinarySignedness

Enums
SIGNED Le nombre binaire est signé.
UNSIGNED Le nombre binaire n'est pas signé.
UNSPECIFIED Essayez de déduire le signe de la chaîne existante.

DecimalLogicalType

Type logique à utiliser pour un champ décimal.

Enums
AUTO Utilisez le type le plus optimal en fonction de l'échelle et de la précision.
BIG_DECIMAL Stockez la valeur sous forme de valeur décimale non limitée. Il s'agit de l'option la plus lente, mais elle accepte n'importe quelle décimale, quelle que soit la précision et l'échelle.
BIG_INTEGER Stockez la valeur sous forme de valeur entière non limitée. Il s'agit de l'option la plus lente, mais elle accepte n'importe quel entier de n'importe quelle précision.
DECIMAL64 Utilisez 64 bits pour stocker la valeur. Ce modificateur ne fonctionne que pour les nombres dont la précision est inférieure ou égale à 18.
LONG Utilisez 64 bits pour stocker la valeur. Ce modificateur ne fonctionne que pour les nombres dont la précision est inférieure ou égale à 18 et l'échelle est de 0.

PackedDecimalNegativeNibble

Enums
NIBBLE_B La valeur par défaut est x'B'.
NIBBLE_D Utilisez x'D' pour le demi-octet de signe négatif.

SchemaValidationMode

Spécifiez le mode de validation de schéma à utiliser lors de la compilation du copybook. Ce mode vérifie la compatibilité avec un format de données cible spécifique.

Enums
BIG_QUERY Mode de validation du schéma pour la compatibilité avec BigQuery. Ce mode étend la validation par défaut pour vérifier que le schéma du copybook est compatible avec les types de données de BigQuery.
DEFAULT Mode de validation de schéma par défaut. Ce mode vérifie que les noms de champs uniques se trouvent dans le copybook.
MYSQL Mode de validation du schéma pour la compatibilité MySQL. Ce mode étend la validation par défaut pour vérifier que le schéma du copybook est compatible avec les types de données MySQL.
POSTGRES Mode de validation du schéma pour la compatibilité PostgreSQL. Ce mode étend la validation par défaut pour vérifier que le schéma du copybook est compatible avec les types de données PostgreSQL.

ZonedDecimalEncoding

Spécifiez l'encodage à utiliser lors du décodage ou de l'encodage d'un champ décimal zoné.

Enums
ASCII Utilisez l'encodage ASCII.
EBCDIC Utilisez l'encodage EBCDIC.
UNSPECIFIED Conservez l'encodage spécifié dans la chaîne de modificateurs. Si aucun modificateur n'est spécifié, EBCDIC est utilisé.