Ciblage des valeurs de clé personnalisée

En tant qu’éditeur, vous pouvez avoir des données personnalisées sur vos utilisateurs (âge, sexe, revenu, centres d’intérêt, lieu, etc.) ou du contenu (mots clés de recherche, balises contextuelles, positions publicitaires, etc.) que vous souhaitez utiliser pour produire des offres qui peuvent être d’une valeur pour vos annonceurs. Il existe différentes façons de cibler vos données client pour y parvenir, notamment les chaînes de requête et le ciblage de segments. Une autre méthode consiste à effectuer un ciblage de clé/valeur personnalisé.

Avec le ciblage clé/valeur personnalisé, vous pouvez définir vos propres clés et leurs valeurs correspondantes pour tirer pleinement profit de vos données et aider les annonceurs à atteindre leur public cible. Dans le cadre de notre serveur publicitaire, nous fournissons des services d’API que vous pouvez utiliser pour créer vos propres jeux de valeurs de clé personnalisés.

Prédéfiniter des jeux de valeurs de clé

Le ciblage avec des jeux de clés/valeurs personnalisés implique la création de clés et de valeurs, puis l’utilisation de ces clés et valeurs pour créer des expressions de ciblage. Dans l’API, vous utilisez les services targeting-key et targeting-value pour créer des clés et leurs valeurs associées. Vous utilisez ensuite le service de profil pour créer votre ciblage.

Définition de clés et de valeurs pour

Lorsque vous définissez des clés à l’aide du service de clé de ciblage , ces clés sont disponibles pour cibler dans notre plateforme. Seules les clés que vous avez prédéfinies à l’aide du service de clé de ciblage sont disponibles. Toutefois, vous n’avez pas besoin de prédéfinir des valeurs. L’utilisation du service targeting-value pour prédéfini des valeurs affiche ces valeurs dans. Si vous ne prédéfinisez pas de valeurs, vous pouvez les entrer directement dans ou les importer à partir d’un fichier CSV (valeurs séparées par des virgules) lorsque vous créez votre ciblage. Notez que s’il est possible de définir des clés dans l’interface utilisateur héritée, vous devez utiliser l’API pour définir de nouvelles clés pour la disponibilité dans.

Définition de clés et de valeurs pour le service de profil

Vous n’avez pas besoin de prédéfinifier des clés ou des valeurs pour créer votre ciblage dans le service de profil . L’inclusion de clés et de valeurs dans une expression de ciblage de service de profil sans les définir au préalable avec les services targeting-key et targeting-value cible correctement. Toutefois, lorsque vous interrogez des clés et des valeurs à l’aide des services targeting-key et targeting-value , ces clés et valeurs qui ont été définies dans l’expression ne sont pas incluses dans la sortie de cette requête. Ces clés ne seront pas non plus disponibles pour la création de rapports.

Création d’ensembles de valeurs de clé

La première étape de l’utilisation de l’API pour créer un ciblage de valeur de clé personnalisé consiste à créer une clé. La clé est une catégorie qui contient des valeurs, les éléments de cette catégorie. Par exemple, si vous définissez une clé nommée "fruit", vous pouvez créer des valeurs associées à cette clé nommée "apple" et "orange". Voici un exemple de création d’une "fruit" clé :

$ cat create_targeting_key.json
{
    "targeting-key": {
        "name": "fruit",
        "type": "string"
    }
}
 
$ curl -b cookies -X POST -d '@create_targeting_key.json' 'https://api.appnexus.com/targeting-key'
 
"targeting-key": {
    "id": 4,
    "type": "string",
    "name": "fruit",
    "label": null,
    "state": "active",
    "created_on": "2016-08-26 11:30:55",
    "last_modified": "2016-08-26 11:30:55"
},

Dans cet exemple, nous avons donné à la clé le nom "fruit" et spécifié un type de « chaîne ». Vous pouvez également créer des clés qui auront des valeurs numériques. Par exemple, vous pouvez définir une clé nommée "age" avec les valeurs 21, 30et 45.

Après avoir créé votre clé, vous pouvez associer des valeurs à cette clé. Dans notre exemple, nous allons associer les valeurs "apple" et "orange" à notre "fruit" clé.

$ cat create_targeting_value.json
{
    "targeting-value": {
        "name": "apple"
    }
}
 
$ curl -b cookies -X POST -d @create_targeting_value.json 'https://api.appnexus.com/targeting-value?targeting_key_id=4'

Cet exemple crée une valeur portant le nom "apple". Nous avons spécifié dans targeting_key_id notre chaîne de requête pour associer cette valeur à la "fruit" clé, qui a un ID de 4. Exécutez la même commande, mais avec "orange" comme nom à la place de "apple". Vos valeurs pour la "fruit" clé (targeting_key_id = 4) ressemblent maintenant à ceci :

"targeting-values": [
    {
        "id": 15,
        "targeting_key_id": 4,
        "name": "apple",
        "label": null,
        "created_on": "2016-08-26 11:59:26",
        "last_modified": "2016-08-26 11:59:26"
    },
    {
        "id": 16,
        "targeting_key_id": 4,
        "name": "orange",
        "label": null,
        "created_on": "2016-08-26 11:55:12",
        "last_modified": "2016-08-26 11:55:12"
    }
]

Vous pouvez également effectuer des ajouts en bloc de valeurs de ciblage. Au lieu d’ajouter les valeurs une par une comme nous l’avons fait dans cet exemple, nous aurions pu ajouter plusieurs valeurs à la fois, comme suit :

$ cat create_targeting_value.json
{
    "targeting-values": [
        {
            "name": "apple"
        },
        {
            "name": "orange"
        }
    ]
}
 
$ curl -b cookies -X POST -d @create_targeting_value.json 'https://api.appnexus.com/targeting-value?targeting_key_id=4'

Notez qu’au lieu d’utiliser targeting-value dans notre fichier JSON, nous avons utilisé targeting-values (pluriel) comme tableau.

Mise à jour de votre profil

Maintenant que vos clés et les valeurs associées sont définies, il est temps de les ajouter à un profil. Les combinaisons de clés et de valeurs que vous souhaitez associer à un profil peuvent devenir compliquées. Nous allons commencer par l’exemple le plus simple, puis vous montrer des solutions plus complexes.

Création d’expressions

Vous devez d’abord décider des clés et des valeurs que vous souhaitez cibler. Nous pouvons utiliser l’exemple précédent pour simplifier cette opération et dire que nous voulons cibler tous les fruits qui sont des pommes ou des oranges :

(fruit == pomme) OR (fruit == orange)

C’est assez simple, non ? Mais que se passe-t-il si vous voulez être plus compliqué ? Que se passe-t-il si vous voulez cibler en fonction des fruits et de la ville dans laquelle ils sont consommés ? Quelque chose comme ceci :

(fruit == pomme ET ville == NY) OR (fruit == orange AND (ville == Seattle OU ville == LA))

Maintenant, vous ciblez des pommes à New York, ou des oranges à Seattle ou à LOS.

Une fois que vous savez quelle combinaison de clés et de valeurs vous souhaitez cibler, comment l’obtenir dans votre profil ? En créant une expression de ciblage (et des sous-expressions).

Utilisation d’opérateurs d’expression

Pour créer votre expression de ciblage, vous allez utiliser l’objet exp (expression) sur le service Profil . Voici les éléments au sein de l’objet exp :

Les types valeur doivent correspondre aux noms des champs de valeur. Par exemple, vous recevez une erreur si vous placez une valeur définie sous forme de chaîne dans le vnm champ (valeur numérique). En outre, le type que vous spécifiez dans le vtp champ doit correspondre à votre type de valeur. Si votre vtp valeur est str, votre valeur doit être affectée au vst champ .

Analyse et création d’expressions

Vous allez utiliser les éléments de l’objet exp pour assembler vos expressions de ciblage. Revenons à notre exemple d’origine :

(fruit == pomme) OR (fruit == orange)

Voici comment regrouper cette expression à l’aide de l’objet exp :

{
    "key_value_targets": {
        "kv_expression": {
                "header": {
                        "an_version": "1.0",
                        "client_version": "1.0"
                },
            "exp": {
                "typ": "or",
                "sbe": [
                    {
                        "exp": {
                            "typ": "eq",
                            "key": "fruit",
                            "vtp": "str",
                            "vst": "apple"
                        }
                    },
                    {
                        "exp": {
                            "typ": "eq",
                            "key": "fruit",
                            "vtp": "str",
                            "vst": "orange"
                        }
                    }
                ]
            }
        }
    }  
}

Nous commençons par l’objet key_value_targets , suivi du kv_expression champ . Dans ce champ se trouve votre expression entière. Étant donné que nous ciblons des pommes OU des oranges, nous avons défini la valeur du champ d’expression typ sur "or".

Ensuite, nous ajoutons un en-tête. L’objet header contient des informations de contrôle de version sur votre expression. Comme vous le verrez dans notre exemple suivant, ces expressions peuvent prendre une certaine quantité de travail à planifier et à implémenter. Vous ne souhaitez donc pas vous soucier de sa rupture ultérieure en raison des mises à jour de l’API. Pour éviter tout problème, vous devez ajouter un en-tête à votre key_value_targets champ avec vos informations de contrôle de version. L’objet header a deux champs :

Ces champs sont obligatoires sur PUT et POST appels. Vous devez entrer les valeurs indiquées ici pour que votre expression soit évaluée correctement. Entrez vos informations d’en-tête exactement comme indiqué dans l’exemple, y compris les valeurs.

Enfin, nous définissons nos sous-expressions (sbe) auxquelles s’applique le "or" . Notre première sous-expression est fruit == pomme. Nous avons un typ de "eq" (égal à), une clé de "fruit", notre vtp (type valeur) est une chaîne "str"et notre vst (valeur de chaîne) est "apple". Nous faisons ensuite la même chose avec la sous-expression fruit == orange. En d’autres termes :

Nous allons maintenant essayer notre exemple plus compliqué :

(fruit == pomme ET ville == NY) OR (fruit == orange AND (ville == Seattle OU ville == LA))

Cela peut sembler un peu intimidant si vous essayez de commencer à chaîner des expressions. Nous vous recommandons de commencer par créer une structure de vos expressions, semblable à celle-ci :

Une fois notre expression dessinée, nous pouvons commencer à la créer dans notre profil de ciblage. Nous allons commencer par le bas à droite et travailler notre chemin vers le haut.

Voici les expressions pour city == Seattle et city == LA :

               "exp": {
                        "typ": "eq",
                        "key": "city",
                        "vtp": "str",
                        "vst": "Seattle"
                },
                "exp": {
                        "typ": "eq",
                        "key": "city",
                        "vtp": "str",
                        "vst": "LA"
                }

Ensuite, nous passons d’un niveau à l’instruction OR, où nous créons ville == Seattle OR city == LA.

Pour ce faire, nous mettons les deux expressions dans une seule sous-expression (sbe). Cette sous-expression se trouve dans une autre expression qui définit la relation des deux expressions au sein de la sous-expression en tant que "or" relation ("typ": "or"). En d’autres termes, il existe une "or" relation entre la ville == Seattle et la ville == LA :

       "exp": {
                "typ": "or",
                "sbe": [
                        {
                                "exp": {
                                        "typ": "eq",
                                        "key": "city",
                                        "vtp": "str",
                                        "vst": "Seattle"
                                }
            },
            {
                                "exp": {
                                        "typ": "eq",
                                        "key": "city",
                                        "vtp": "str",
                                        "vst": "LA"
                                }
                        }
                ]
        }

L’expression précédente peut également être créée sous forme de tableau. Nous avons créé les exemples ici pour vous guider tout au long du processus de création d’expressions et de sous-expressions, mais l’utilisation de tableaux peut souvent simplement vos équations, ainsi que réduire vos niveaux d’expression. Consultez Utilisation de tableaux ci-dessous pour obtenir des exemples de ce à quoi les expressions ici ressembleraient en tant que tableaux.

Notez qu’étant donné qu’il s’agit d’une instruction OR, elle peut également être construite à l’aide d’un tableau. Cette même expression peut être créée à l’aide de tableaux. Jusqu’à ce stade, nous vous avons appris à créer plusieurs exp. Notez que l’expression ci-dessus peut également être construite en tant que tableau. L’utilisation d’un tableau est la méthode recommandée, car elle aplatit votre structure, ce qui peut être important si vous commencez à manquer de niveaux. (Pour plus d’informations, consultez les niveaux d’expression ci-dessous). Pour créer cette même expression qu’un tableau, utilisez les éléments suivants :

Nous avons maintenant terminé le coin inférieur droit de notre diagramme (ville == Seattle OU ville == LA).

Nous allons maintenant définir notre expression fruit == orange :

"exp": {
                "typ": "eq",
                "key": "fruit",
                "vtp": "str",
                "vst": "orange"
        }

C’était assez simple. Nous allons maintenant tout mettre en place avec une expression pour créer fruit "and" = orange AND (ville == Seattle OR city == LA) :

 "exp": {
                "typ": "and",
                "sbe": [
                        {
                                "exp": {
                                        "typ": "eq",
                                        "key": "fruit",
                                        "vtp": "str",
                                        "vst": "orange"
                                }
            },
            {
                                "exp": {
                                        "typ": "or",
                                        "sbe": [
                                                {
                                                        "exp": {
                                                                "typ": "eq",
                                                                "key": "city",
                                                                "vtp": "str",
                                                                "vst": "Seattle"
                                                        }
                        },
                        {
                                                        "exp": {
                                                                "typ": "eq",
                                                                "key": "city",
                                                                "vtp": "str",
                                                                "vst": "LA"
                                                        }
                                                }
                                        ]
                                }
                        }
                ]
        }

Cela complète tout le côté droit de notre diagramme.

Passons maintenant au côté gauche : fruit == pomme ET ville == NY :

 "exp": {
        "typ": "and",
        "sbe": [
                {
                        "exp": {
                                "typ": "eq",
                                "key": "fruit",
                                "vtp": "str",
                                "vst": "apple"
                        }
        },
        {
                        "exp": {
                                "typ": "eq",
                                "key": "city",
                                "vtp": "str",
                                "vst": "NY"
                        }
                }
        ]
}

Maintenant que nous avons eu un peu de pratique, cette expression est allée assez vite, n’est-ce pas ? Nous avons créé un exp avec un typ"and" qui a combiné les sous-expressions fruit == pomme et ville == NY.

Nous avons maintenant parcouru les deux côtés de notre diagramme ; nous avons créé (fruit == pomme ET ville == NY), et nous avons créé fruit == orange AND (ville == Seattle OU ville == LA). Il est temps d’ajouter le niveau "or"supérieur :

Nous lient l’ensemble de l’expression au niveau supérieur en la plaçant dans le key_value_targets champ :

       "key_value_targets": {
                "kv_expression": {
                        "header": {
                                "an_version": "1.0",
                                "client_version": "1.0"
                        },
                        "exp": {
                                "typ": "or",
                                "sbe": [
                                        {

Comme vous pouvez le voir, nous avons placé l’expression à l’intérieur de l’objet key_value_targets et de l’objet kv_expression , et nous avons ajouté notre header objet (décrit précédemment). N’oubliez pas d’ajouter toutes vos accolades fermante.

Enfin, voici à quoi ressemble l’expression de ciblage complet :

{
        "key_value_targets": {
                "kv_expression": {
                        "header": {
                                "an_version": "1.0",
                                "client_version": "1.0"
                        },
                        "exp": {
                                "typ": "or",
                                "sbe": [
                                        {
                                                "exp": {
                                                        "typ": "and",
                                                        "sbe": [
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "fruit",
                                                                                "vtp": "str",
                                                                                "vst": "apple"
                                                                        }
                                                                },
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "city",
                                                                                "vtp": "str",
                                                                                "vst": "NY"
                                                                        }
                                                                }
                                                        ]
                                                }
                                        },
                                        {
                                                "exp": {
                                                        "typ": "and",
                                                        "sbe": [
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "fruit",
                                                                                "vtp": "str",
                                                                                "vst": "orange"
                                                                        }
                                                                },
                                                                {
                                                                        "exp": {
                                                                                "typ": "or",
                                                                                "sbe": [
                                                                                        {
                                                                                                "exp": {
                                                                                                        "typ": "eq",
                                                                                                        "key": "city",
                                                                                                        "vtp": "str",
                                                                                                        "vst": "Seattle"
                                                                                                }
                                                                                        },
                                                                                        {
                                                                                                "exp": {
                                                                                                        "typ": "eq",
                                                                                                        "key": "city",
                                                                                                        "vtp": "str",
                                                                                                        "vst": "LA"
                                                                                                }
                                                                                        }
                                                                                ]
                                                                        }
                                                                }
                                                        ]
                                                }
                                        }
                                ]
                        }
                }
        }
}

Utilisation de tableaux

L’exemple précédent a été créé à l’aide de valeurs de chaîne. Vous pouvez également utiliser des valeurs numériques pour le ciblage de clé/valeur, et vous pouvez utiliser des tableaux. Les tableaux peuvent simplifier votre expression et aplatir votre structure si votre expression devient trop longue. (Voir Niveaux d’expression ci-dessous.) Dans notre premier exemple, nous avions une expression qui ressemblait à ceci :

{
    "key_value_targets": {
        "kv_expression": {
                "header": {
                        "an_version": "1.0",
                        "client_version": "1.0"
                },
            "exp": {
                "typ": "or",
                "sbe": [
                    {
                        "exp": {
                            "typ": "eq",
                            "key": "fruit",
                            "vtp": "str",
                            "vst": "apple"
                        }
                    },
                    {
                        "exp": {
                            "typ": "eq",
                            "key": "fruit",
                            "vtp": "str",
                            "vst": "orange"
                        }
                    }
                ]
            }
        }
    }  
}

Comme il s’agit d’une expression OR, nous pouvons facilement la simplifier en une seule expression de tableau :

{
    "key_value_targets": {
        "kv_expression": {
                "header": {
                        "an_version": "1.0",
                        "client_version": "1.0"
                },
            "exp": {
                "typ": "in",
                "key": "fruit",
                "vtp": "sta",
                "vsa": ["apple","orange"]
            }
        }
    }  
}

Notez quelques différences clés :

• Suppression de l’externe exp avec le "or" type . "Or" est implicite avec le tableau.
• Sans expression externe, nous n’avons plus besoin d’une sous-expression (sbe) contenant les deux jeux de chaînes clé/valeur (fruit = pomme, fruit = orange)
• Le typ dans l’expression a été remplacé par "in""eq" . Nous disons « n’importe quelle valeur pour les fruits qui sont dans la pomme de tableau, orange ».
• est vtp maintenant sta (tableau de chaînes) plutôt que str (chaîne).
• La valeur est spécifiée en tant que vsa (valeur du tableau de chaînes) plutôt que vst (valeur de chaîne).

Voici notre expression complète simplifiée pour utiliser des tableaux plutôt que des valeurs de chaîne distinctes. Notez que les "and" expressions sont restées, seule l’expression "or" a été modifiée pour utiliser un tableau.

{
        "key_value_targets": {
                "kv_expression": {
                        "header": {
                                "an_version": "1.0",
                                "client_version": "1.0"
                        },
                        "exp": {
                                "typ": "or",
                                "sbe": [
                                        {
                                                "exp": {
                                                        "typ": "and",
                                                        "sbe": [
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "fruit",
                                                                                "vtp": "str",
                                                                                "vst": "apple"
                                                                        }
                                                                },
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "city",
                                                                                "vtp": "str",
                                                                                "vst": "NY"
                                                                        }
                                                                }
                                                        ]
                                                }
                                        },
                                        {
                                                "exp": {
                                                        "typ": "and",
                                                        "sbe": [
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "fruit",
                                                                                "vtp": "str",
                                                                                "vst": "orange"
                                                                        }
                                                                },
                                                                {
                                                                        "exp": {
                                                                                "typ": "in",
                                                                                "key": "city",
                                                                                "vtp": "sta",
                                                                                "vsa": ["Seattle","LA"]
                                                                        }
                                                                }
                                                        ]
                                                }
                                        }
                                ]
                        }
                }
        }
}

Restrictions d’expression

Il existe des restrictions quant à la façon dont votre expression peut être détaillée.

Niveaux d’expression

La profondeur logique (le nombre de niveaux d’expressions logiques) de votre expression peut être au maximum de 5. Un niveau logique est toute expression avec un type et, ou pas. Ou, en termes de l’objet exp , il s’agit d’une expression (exp) avec une sous-expression (sbe). Dans l’exemple que nous venons de parcourir, notre profondeur logique est 3, comme illustré dans le diagramme suivant :

Souvent, une seule expression peut être écrite de plusieurs façons différentes (différentes combinaisons de et, ou, égale, non égale, etc., peuvent souvent produire des résultats identiques). Si vous constatez que vos expressions dépassent cinq niveaux logiques, vous devez rechercher des moyens de simplifier l’expression ou de tenter de la réécrire de manière à « aplatir » la structure.

Nombre maximal de caractères

Une expression peut contenir jusqu’à 500 000 caractères (sans espace blanc). Si votre expression dépasse 500 000 caractères, elle ne fonctionnera pas comme prévu. Vous pouvez essayer de reconfigurer votre expression si vous avez besoin de la raccourcir.

Pour plus d’informations sur les limitations et les exigences de clé/valeur individuelles, consultez les sections « Exigences » sous Service de ciblage de clé et Service de valeur de ciblage.

Valeurs maximales par clé

Chaque clé peut avoir un maximum de 999 valeurs. Il est possible d’augmenter le nombre de valeurs en créant plusieurs expressions clé/valeur pour la même clé et en utilisant OU pour les lier. Par exemple, si key1 a 999 valeurs, vous pouvez ajouter une autre clé1 à votre expression avec jusqu’à 999 valeurs supplémentaires. Voici un exemple simple qui montre comment combiner plusieurs ensembles de valeurs pour la même clé :

"kv_expression": {
    "exp": {
        "sbe": [
            {
                "exp": {
                    "key": "key1",
                    "typ": "in",
                    "vsa": [
                        "1",
                        "2",
                        "3"
                    ],
                    "vtp": "sta"
                }
            },
            {
                "exp": {
                    "key": "key1",
                    "typ": "in",
                    "vsa": [
                        "4",
                        "5",
                        "6"
                    ],
                    "vtp": "sta"
                }
            },
            {
                "exp": {
                    "key": "key1",
                    "typ": "in",
                    "vsa": [
                        "7",
                        "8",
                        "9"
                    ],
                    "vtp": "sta"
                }
            }
        ],
        "typ": "or"
    },

Utilisation de caractères génériques

Vous pouvez utiliser le symbole générique * pour cibler plusieurs valeurs dans une seule expression. Par exemple, supposons que plutôt que de cibler des pommes, vous vouliez cibler des types spécifiques de pommes. Vous pourriez avoir une clé de fruit avec des valeurs qui incluent la pomme granny smith, la pomme délicieuse rouge, la pomme honeycrisp. Pour cibler un type spécifique de pomme, vous devez utiliser l’expression fruit == pomme honeycrisp. Si vous décidez de cibler toutes les pommes, vous utiliserez un caractère générique : fruit == *pomme. Dans notre exp objet qui ressemblerait à ceci :

"exp": {
        "typ": "eq",
        "key": "fruit",
        "vtp": "str",
        "vst": "*apple"
}

Vous pouvez utiliser jusqu’à deux caractères génériques dans une valeur. Ainsi, si, pour une raison quelconque, vos valeurs avaient été entrées comme de délicieux pommes rouges et délicieux pommes dorées, vous pourriez trouver toutes les pommes délicieuses avec l’expression fruit == pomme délicieuse*, et toutes les pommes de tout type avec l’expression fruit == *pomme*.

Résolution des problèmes

Vous avez probablement déjà compris qu’il est assez facile que quelque chose se passe mal dans la création d’une équation. Vous pouvez suivre quelques étapes qui peuvent vous aider à résoudre les problèmes de vos équations.

Expression JSON non valide

Le service de profil fournit une gestion des erreurs qui vous aidera à déterminer la cause des problèmes que vous pourriez rencontrer avec votre expression JSON. Toutefois, vous ne recevrez pas de rapport complet de tous les problèmes en même temps. Le service parcourt l’équation de la même façon que nous l’avons parcourue dans ce document. Il commence à l’équation la plus interne (le bas de l’arborescence d’équations) et vérifie cette équation. S’il existe des erreurs dans cette partie de l’équation, ces erreurs sont signalées. Une fois que vous avez corrigé ces erreurs et réexécuté le service, il passe au niveau suivant dans l’arborescence et case activée à nouveau les erreurs.

Expression non modifiable dans

Il est possible de créer une expression dans l’API qui ne peut pas être affichée ou modifiée dans . Si vous souhaitez pouvoir modifier des expressions via une fois que vous les avez créées avec l’API, vous devez suivre ces instructions :

Ne créez pas une expression de plus de deux niveaux de profondeur

Bien que vous puissiez créer une expression jusqu’à cinq niveaux en profondeur via l’API, ne peut fonctionner qu’avec jusqu’à deux niveaux. Vous devez simplifier vos expressions et les conserver à un maximum de deux niveaux pour pouvoir les modifier. Pour obtenir une description des niveaux de profondeur, consultez Restrictions d’expression.

Niveaux AND et OR alternatifs

Dans nos exemples ci-dessus, nous avons alterné les niveaux AND et OR :

"exp": {
        "typ": "or",
        "sbe": [
                {
                        "exp": {
                                "typ": "and",
                                "sbe": [

Vous pouvez créer des expressions où vous répétez des opérateurs aux niveaux suivants. Par exemple, dans cette expression, vous pouvez voir que nous commençons par un AND, suivi immédiatement d’un autre AND :

"exp": {
        "typ": "and",
        "sbe": [
                {
                        "exp": {
                                "typ": "and",
                                "sbe": [
                                        {
                                                "exp": {
                                                        "typ": "eq",
                                                        "key": "fruit",
                                                        "vtp": "str",
                                                        "vst": "apple"
                                                }
                                        },
                                        {
                                                "exp": {
                                                        "typ": "eq",
                                                        "key": "city",
                                                        "vtp": "str",
                                                        "vst": "NY"
                                                }
                                        }
                                ]
                        }
                },
                {
                        "exp": {
                                "typ": "and",
                                "sbe": [
                                        {
                                                "exp": {
                                                        "typ": "eq",
                                                        "key": "fruit",
                                                        "vtp": "str",
                                                        "vst": "orange"
                                                }
                                        },
                                        {
                                                "exp": {
                                                        "typ": "eq",
                                                        "key": "city",
                                                        "vtp": "str",
                                                        "vst": "LA"
                                                }
                                        }
                                ]
                        }
                }
        }
}

Toutefois, ces expressions ne seront pas modifiables dans. Essayez de simplifier vos expressions : si vous imbriquez les expressions AND suivantes, vous n’aurez peut-être pas besoin de les imbriquer. L’expression précédente, écrite, ressemble à ceci :

(fruit == pomme ET ville == NY) AND (fruit = orange AND city == LA)

Il peut être simplifié - et rendu modifiable dans - en l’écrivant comme suit :

 "exp": {
        "typ": "and",
        "sbe": [
                {
                        "exp": {
                                "typ": "eq",
                                "key": "fruit",
                                "vtp": "str",
                                "vst": "apple"
                        }
        },
        {
                        "exp": {
                                "typ": "eq",
                                "key": "city",
                                "vtp": "str",
                                "vst": "NY"
                        }
                }
                {
                        "exp": {
                                "typ": "eq",
                                "key": "fruit",
                                "vtp": "str",
                                "vst": "orange"
                        }
        },
        {
                        "exp": {
                                "typ": "eq",
                                "key": "city",
                                "vtp": "str",
                                "vst": "LA"
                        }
                }
        ]
}

Ciblage incorrect

Vous avez suivi les étapes précédentes et le service de profil s’exécute sans erreurs, mais votre ciblage ne fournit pas les résultats attendus. Voici quelques étapes à suivre pour déterminer le problème :

• Double-case activée votre équation : Êtes-vous anding où vous devriez être ORing ? Avez-vous des doubles négatifs (pas (x neq y)) qui pourraient retourner les résultats opposés de ce que vous aviez pensé ?
• Dessiner l’arborescence d’équations : si vous n’avez pas réellement dessiné d’arborescence d’équations, nous vous suggérons de l’essayer. Ce format peut être très utile pour parcourir chaque étape de l’équation.
• Comparez votre arborescence d’équations à votre équation : parcourez un nœud à la fois et assurez-vous que vous avez tous vos eq et neq et et et ou tout l’endroit où ils appartiennent.

Voir aussi

• Service de clé de ciblage
• Service de valeur de ciblage