Partager via

Requête de recherche Dataverse

  • Article

L’opération de requête renvoie des résultats de recherche basés sur un terme de recherche.

En plus d’un critère de recherche, les résultats renvoyés peuvent être influencés en transmettant des valeurs pour les paramètres suivants :

Nom  Type Description Pour plus d’informations :
search string Obligatoire. Texte à rechercher. paramètre de recherche
count bool Indique s’il faut renvoyer le nombre total d’enregistrements. paramètre count
entities string Limite la portée de la recherche à un sous-ensemble de tables. paramètre d’entités
facets string Les facettes prennent en charge la capacité d’explorer les résultats des données après leur extraction. paramètre de facettes
filter string Limite la portée des résultats de recherche renvoyés. paramètre de filtre
options string Les options sont des paramètres configurés pour rechercher un critère de recherche. paramètre options
orderby string Spécifie comment classer les résultats par ordre de priorité. paramètre orderby
skip int Spécifie le nombre de résultats de recherche à ignorer. paramètres sauter et haut
top int Spécifie le nombre de résultats de recherche à récupérer. paramètres sauter et haut

Paramètres

Cette section comprend des détails sur les paramètres introduits dans le tableau ci-dessus.

search Paramètre

Type : chaîne
Facultatif : faux

Le paramètre de recherche contient le texte à rechercher. C’est le seul paramètre obligatoire. Le terme recherché doit comporter au moins un caractère et est limité à 100 caractères.

Syntaxe de recherche simple

Par défaut, le paramètre de recherche prend en charge une syntaxe de recherche simple, comme décrit dans le tableau suivant :

Fonctionnalité Description
Opérateurs booléens Opérateur AND ; désigné par +
Opérateur OU ; désigné par |
Opérateur NON ; désigné par -
Opérateurs de priorité Un critère de recherche hotel+(wifi | luxury) recherche les résultats contenant le terme hotel et soit wifi ou luxury (ou les deux).
Caractères génériques Les caractères génériques de fin sont pris en charge. Par exemple, Alp* recherche « alpin ».
Concordances exactes Requête entre guillemets " ".

Notes

Pour utiliser l’un des opérateurs de recherche dans le cadre du texte de recherche, échappez le caractère en le préfixant avec une seule barre oblique inverse (\). Les caractères spéciaux qui nécessitent un échappement sont les suivants : + - & | ! ( ) { } [ ] ^ " ~ * ? : \ /.

Par exemple, un numéro de téléphone échappé pourrait ressembler à ceci : \+1\(800\)555\-1234.

À l’aide du paramètre options, vous pouvez activer la syntaxe de requête Lucerne qui active différents opérateurs.

count Paramètre

Type : bool
Facultatif : vrai

Indique s’il faut renvoyer le nombre total d’enregistrements. Si vous ne définissez pas ce paramètre, la propriété de réponse Count est -1.

entities Paramètre

Type : chaîne
Facultatif : vrai

Par défaut, toutes les tables activées pour la recherche sont recherchées sauf si vous spécifiez un sous-ensemble à l’aide du paramètre entities .

Lorsque vous définissez une entité, vous pouvez également spécifier les colonnes que vous souhaitez renvoyer et les colonnes dans lesquelles rechercher. Vous pouvez également inclure des critères de filtre pour le tableau.

Pour obtenir une liste des tables activées pour l’environnement, utilisez l’API Statut de recherche et recherchez les tables répertoriées par entitylogicalname dans entitystatusresults.

Type d’entité de recherche

Utilisez ce type pour composer le tableau de tables à transmettre au paramètre entities .

Nom de champ Type Description
name string Obligatoire. Nom logique de la table. Spécifie la portée de la requête.
selectColumns string[] Facultatif. Liste des colonnes qui doivent être projetées lorsque les documents de table sont renvoyés en réponse. S’il est vide, seul le nom principal de la table est renvoyé.
searchColumns string[] Facultatif. Liste des colonnes sur lesquelles étendre la requête. S’il est vide, seul le nom principal de la table fait l’objet d’une recherche.
filter string Facultatif. Filtres appliqués sur l’entité.

Exemple

Voici un exemple de données JSON qui utilisent le schéma décrit ci-dessus.

[
   {
      "name":"account",
      "selectColumns":["name","address1_city"],
      "searchColumns":["name","address1_city"],
      "filter":"modifiedon ge 2018-01-01T00:00:00Z"
   },
   {
      "name":"contact",
      "selectColumns":["fullname","address1_city"],
      "searchColumns":["fullname","address1_city"],
      "filter":"modifiedon ge 2018-01-01T00:00:00Z"
   }
]

Pour utiliser ces données, vous devez échapper la chaîne et la transmettre comme valeur du paramètre entities dans le corps de la requête :

{
    "search": "maria",
    "entities":"[{\"name\":\"account\",\"selectColumns\":[\"name\",\"address1_city\"],\"searchColumns\":[\"name\",\"address1_city\"],\"filter\":\"modifiedon ge 2018-01-01T00:00:00Z\"},{\"name\":\"contact\",\"selectColumns\":[\"fullname\",\"address1_city\"],\"searchColumns\":[\"fullname\",\"address1_city\"],\"filter\":\"modifiedon ge 2018-01-01T00:00:00Z\"}]"
}

facets Paramètre

Type : chaîne
Facultatif : vrai

Le paramètre de facette est facultatif. La chaîne peut contenir des paramètres permettant de personnaliser le facettage, exprimés sous forme de paires nom-valeur séparées par des virgules. Utilisez des facettes pour regrouper vos résultats de recherche.

Définition de facette

Les facettes sont définies comme un tableau de chaînes, par exemple :

[
"entityname,count:100",
"account:primarycontactid,count:100",
"ownerid,count:100",
"modifiedon,values:2019-04-27T00:00:00|2020-03-27T00:00:00|2020-04-20T00:00:00|2020-04-27T00:00:00",
"createdon,values:2019-04-27T00:00:00|2020-03-27T00:00:00|2020-04-20T00:00:00|2020-04-27T00:00:00"
]

Chaque élément du tableau représente une manière différente de regrouper les données renvoyées par la requête. Pour chaque propriété renvoyée, vous pouvez spécifier les facettes appropriées à l’aide des valeurs du tableau suivant :

Type de facette Description
count Nombre maximum de termes facette. La valeur par défaut est 10. Il n’existe aucune limite supérieure
sort Peut être défini sur count, -count, value, -value. Utilisez count pour trier dans l’ordre décroissant par count. Utilisez -count pour trier dans l’ordre croissant par count. Utilisez value pour trier dans l’ordre croissant par value. Utilisez -value pour trier dans l’ordre décroissant par value.
values Défini sur des valeurs numériques ou Edm.DateTimeOffset délimitées par des barres verticales spécifiant un ensemble dynamique de valeurs d’entrée de facette. Les valeurs doivent être répertoriées par ordre séquentiel et croissant pour obtenir les résultats attendus.
interval Intervalle entier supérieur à zéro pour les nombres, ou minute, heure, jour, semaine, mois, trimestre, année pour les valeurs date/heure.
timeoffset Définissez sur ([+-]hh:mm, [+-]hhmm ou [+-]hh). S’il est utilisé, le paramètre timeoffset doit être combiné avec l’option intervalle, et uniquement lorsqu’il est appliqué à un champ de type Edm.DateTimeOffset. La valeur spécifie le décalage horaire UTC à prendre en compte lors de la définition des limites horaires.

Notes

count et sort peuvent être combinés dans la même spécification de facette, mais ils ne peuvent pas être combinés avec interval ou values, et interval et values ne peuvent pas être combinés.

Définissez la valeur facets avec une chaîne d’échappement contenant la définition des facettes.

{
    "search": "maria",
    "facets": "[\"entityname,count:100\",\"account:primarycontactid,count:100\",\"ownerid,count:100\",\"modifiedon,values:2019-04-27T00:00:00|2020-03-27T00:00:00|2020-04-20T00:00:00|2020-04-27T00:00:00\",\"createdon,values:2019-04-27T00:00:00|2020-03-27T00:00:00|2020-04-20T00:00:00|2020-04-27T00:00:00\"]"    
}

Pour plus d’informations :

filter Paramètre

Type : chaîne
Facultatif : vrai

Les filtres limitent la portée des résultats de recherche renvoyés. Utilisez des filtres pour exclure les résultats indésirables. Il s’agit d’un filtre de niveau supérieur qui permet de filtrer les colonnes communes sur plusieurs entités telles que createdon ou modifiedon etc.

Appliquez des filtres en utilisant cette syntaxe : <attribute logical name> <filter> où le nom logique de la table spécifie l’entité à laquelle le filtre doit être appliqué.

Les filtres utilisent les opérateurs de requête suivants :

Opérateur Description Exemple
Opérateurs de comparaison    
eq Égal à revenue eq 100000
ne Différent de revenue ne 100000
gt Supérieur(e) à revenue gt 100000
ge Supérieur ou égal à revenue ge 100000
lt Inférieur(e) à revenue lt 100000
le Inférieur ou égal à revenue le 100000
Opérateurs logiques    
and ET logique revenue lt 100000 and revenue gt 2000
or OU logique name eq 'sample' or name eq 'test'
not Négation logique not name eq 'sample'
Opérateurs de groupement    
( ) Groupement de priorité (name eq 'sample') or name eq 'test') and revenue gt 5000

options Paramètre

Type : chaîne
Facultatif : vrai

Les options sont des paramètres configurés pour rechercher un critère de recherche. Définissez la valeur options sur une Dictionary<string, string> sérialisée de ces options, comme "{'querytype': 'lucene', 'searchmode': 'all', 'besteffortsearchenabled': 'true', 'grouprankingenabled': 'true'}".

Le tableau suivant répertorie les options :

Option Description
querytype Les valeurs peuvent être simple ou lucene syntaxe de requête Lucerne
besteffortsearchenabled Permet au flux de travail de requête intelligent de renvoyer un ensemble probable de résultats si aucune bonne correspondance n’est trouvée pour les termes de la demande de recherche.
groupranking Activez le classement des résultats dans la réponse optimisée pour l’affichage dans les pages de résultats de recherche où les résultats sont regroupés par tableau.
searchmode Lorsque l’option est définie sur all, tous les termes de la recherche doivent être mis en correspondance pour que le document soit comptabilisé comme pertinent. Définir sa valeur sur any par défaut pour correspondre à n’importe quel mot du critère de recherche.

Syntaxe de requête Lucerne

La syntaxe de requête Lucene prend en charge les fonctionnalités suivantes :

Fonctionnalité Description
Opérateurs booléens Fournit un ensemble étendu par rapport à une syntaxe de requête simple.
Opérateur AND ; désigné par AND, &&, +
Opérateur OR ; désigné par OR, ||
Opérateur NOT ; désigné par NOT, !, –
Caractères génériques En plus d’un caractère générique de fin, prend également en charge un caractère générique de début.
Caractère générique de fin - alp*
Caractère générique de début - /.*pine/
Recherche approximative Prend en charge les requêtes mal orthographiées jusqu’à 2 caractères.
Uniersty~ retourne University
Blue~1 retourne glue, blues
Mise en avant des termes Pondère différemment certains termes d’une requête.
Rock^2 electronic renvoie des résultats où les concordances de rock sont plus importantes que celles de electronic.
Recherche par proximité Renvoie les résultats où les termes sont à moins de X mots les uns des autres, pour des résultats plus contextuels.
Par exemple, "airport hotel"~5 renvoie les résultats où les mots airport et hotel sont à moins de 5 mots l’un de l’autre, augmentant ainsi les chances de trouver un hôtel situé à proximité d’un aéroport.
Recherche par expression régulière (regex) Par exemple, /[mh]otel/ correspond à motel ou hotel.

orderby Paramètre

Type : chaîne
Facultatif : vrai

Utilisez le paramètre orderby pour remplacer l’ordre par défaut. Par défaut, les résultats sont répertoriés par ordre décroissant de score de pertinence (@search.score). Pour les résultats avec des scores identiques, le classement sera aléatoire. Vous ne pouvez utiliser ce paramètre que lorsque le type de requête est Lucene avec des caractères génériques dans la chaîne de requête.

Utilisez une liste de clauses séparées par des virgules où chaque clause se compose d’un nom de colonne suivi de asc (croissant, qui est la valeur par défaut) ou desc (décroissant).

Pour un ensemble de résultats contenant plusieurs types de table, la liste des clauses pour orderby doit être globalement applicable (par exemple, modifiedon, createdon, @search.score). Par exemple, pour classer les résultats (par ordre de priorité) par pertinence, suivis des enregistrements les plus récemment modifiés répertoriés le plus haut :

"orderby": ["@search.score desc", "modifiedon desc"]

Si la demande de requête inclut un filtre pour un type de table spécifique, orderby peut éventuellement spécifier des colonnes spécifiques à la table.

Paramètres skip et top

Type : entier
Facultatif : vrai

Vous pouvez utiliser ces paramètres avec le paramètre de comptage pour créer une expérience paginée.

Par défaut, 50 résultats maximum sont renvoyés simultanément. Vous pouvez utiliser top pour l’augmenter jusqu’à 100, mais le plus souvent, vous utiliserez top pour spécifier un jeu de résultats plus petit, tel que 10, puis skip pour contourner les résultats précédemment renvoyés lorsque l’utilisateur passe à la page suivante.

Response

La réponse de l’opération de requête est une chaîne d’échappement qui inclut des données JSON.

La réponse sans échappement contient du JSON utilisant les propriétés suivantes.

Nom  Type Description
Error ErrorDetail Fournit des informations sur les erreurs de la recherche cognitive Azure.
Value QueryResult[] Une collection d’enregistrements correspondants.
Facets Dictionary<string, FacetResult[]> Si des facettes ont été demandées dans la requête, un dictionnaire de valeurs de facettes.
QueryContext QueryContext Cette propriété est utilisée pour la recherche back-end. Il est inclus pour les futures versions de fonctionnalités et n’est pas utilisé actuellement.
Count Entier long Si "Count": true est inclus dans le corps de la demande, le nombre de tous les documents qui correspondent à la recherche, en ignorant le haut et le saut

Types de réponse

Cette section décrit les types renvoyés avec la réponse.

ErrorDetail

L’erreur de recherche cognitive Azure renvoyée dans le cadre de la réponse.

Nom  Type Description
code string Code d’erreur.
message string Message d’erreur.
propertybag Dictionary<string, object> Plus d’informations sur les erreurs.

QueryResult

Chaque élément QueryResult retourné dans la propriété de la réponse Value représente un enregistrement dans Dataverse.

Nom  Type Description
Id string Identificateur de l’enregistrement.
EntityName string Nom logique de la table.
ObjectTypeCode int Code type d’objet de ligne.
Attributes Dictionary<string, object> Attributs de l’enregistrement
Highlights Dictionary<string, string[]> Points clés.
Score double Score du document.

FacetResult

Résultat d’une requête à facettes qui indique le nombre de documents dont le champ se situe dans une plage particulière ou possède une valeur ou un intervalle particulier.

Nom  Type Description
count Long ? Nombre de documents entrant dans le compartiment décrit par cette facette.
from object Valeur indiquant la limite inférieure inclusive de la plage de la facette, ou null pour indiquer qu’il n’y a pas de limite inférieure.
to object Valeur indiquant la limite supérieure exclusive de la plage de la facette, ou null pour indiquer qu’il n’y a pas de limite supérieure.
type Value | Range Type de la facette.
value object Valeur de la facette, ou limite inférieure inclusive s’il s’agit d’une facette d’intervalle.
optionalvalue object Une valeur autre ou facultative de la facette, renseignée lors du facettage lors des recherches.

QueryContext

Contexte de requête renvoyé dans le cadre de la réponse. Cette propriété est utilisée pour la recherche back-end. Il est inclus pour les futures versions de fonctionnalités et n’est pas utilisé actuellement.

Nom  Type Description
originalquery string La chaîne de requête telle que spécifiée dans la demande.
alteredquery string La chaîne de requête que la recherche Dataverse a utilisée pour effectuer la requête. La recherche Dataverse utilise la chaîne de requête modifiée si la chaîne de requête d’origine contenait des fautes d’orthographe ou n’a pas donné de résultats optimaux.
reason string[] Les raisons derrière la requête modifient la décision par recherche Dataverse.
spellsuggestions string[] La suggestion d’orthographe qui correspond aux mots probables qui représentent l’intention de l’utilisateur. Rempli uniquement lorsque Dataverse modifie la recherche de requête en raison de la vérification orthographique.

Examples

Les exemples suivants montrent comment utiliser l’opération de requête. Ces exemples effectuent une opération de recherche sur les colonnes name et fullname des tables de comptes et de contacts, respectivement, pour les enregistrements créés après le 15 août 2022 et classe les sept premiers résultats en fonction du champ createdon, dans l’ordre décroissant.

Cet exemple est tiré de l’exemple du SDK pour les opérations de recherche .NET sur GitHub. La méthode statique OutputSearchQuery accepte une valeur pour le paramètre de recherche.

/// <summary>
/// Demonstrate query API
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance to use.</param>
/// <param name="searchTerm">The term to search for</param>
/// <returns></returns>
static void OutputSearchQuery(IOrganizationService service, string searchTerm)
{
    Console.WriteLine("OutputSearchQuery START\n");

    searchqueryRequest request = new() { 
        search = searchTerm,
        count = true,
        top = 7,
        entities = JsonConvert.SerializeObject(new List<SearchEntity>()
        {
            new SearchEntity()
            {
                Name = "account",
                SelectColumns = new List<string>() { "name", "createdon" },
                SearchColumns = new List<string>() { "name" },
                Filter = "statecode eq 0"
            },
            new SearchEntity()
            {
                Name = "contact",
                SelectColumns = new List<string>() { "fullname", "createdon" },
                SearchColumns = new List<string>() { "fullname" },
                Filter = "statecode eq 0"
            }
        }),
        orderby = JsonConvert.SerializeObject(new List<string>() { "createdon desc" }),
        filter = "createdon gt 2022-08-15"

    };
    
    var searchqueryResponse = (searchqueryResponse)service.Execute(request);

    var queryResults = JsonConvert.DeserializeObject<SearchQueryResults>(searchqueryResponse.response);
  

    Console.WriteLine($"\tCount:{queryResults.Count}");
    Console.WriteLine("\tValue:");
    queryResults.Value.ForEach(result =>
    {

        Console.WriteLine($"\t\tId:{result.Id}");
        Console.WriteLine($"\t\tEntityName:{result.EntityName}");
        Console.WriteLine($"\t\tObjectTypeCode:{result.ObjectTypeCode}");
        Console.WriteLine("\t\tAttributes:");
        foreach (string key in result.Attributes.Keys)
        {
            Console.WriteLine($"\t\t\t{key}:{result.Attributes[key]}");
        }
        Console.WriteLine("\t\tHighlights:");
        foreach (string key in result.Highlights.Keys)
        {
            Console.WriteLine($"\t\t\t{key}:");

            foreach (string value in result.Highlights[key])
            {
                Console.WriteLine($"\t\t\t\t{value}:");
            }
        }
        Console.WriteLine($"\t\tScore:{result.Score}\n");

    });
    Console.WriteLine("OutputSearchQuery END\n");
}

Sortie

Lorsque vous appelez la méthode OutputSearchQuery avec une instance authentifiée de la classe ServiceClient avec le searchTerm défini sur Contoso :

OutputSearchQuery(service: serviceClient, searchTerm: "Contoso");

Le résultat ressemble à ce qui suit :

OutputSearchQuery START

        Count:1
        Value:
                Id:8b35eda1-ef69-ee11-9ae7-000d3a88a4a2
                EntityName:account
                ObjectTypeCode:0
                Attributes:
                        @search.objecttypecode:1
                        name:Contoso Pharmaceuticals (sample)
                        createdon:10/13/2023 5:41:21 PM
                        createdon@OData.Community.Display.V1.FormattedValue:10/13/2023 5:41 PM
                Highlights:
                        name:
                                {crmhit}Contoso{/crmhit} Pharmaceuticals (sample):
                Score:4.986711

OutputSearchQuery END

Classes de soutien

La méthode OutputSearchQuery dépend des classes de soutien suivantes pour envoyer la requête et traiter le résultat :

Classes searchqueryRequest et searchqueryResponse

Ces classes sont générées à l’aide de la commande de CLI Power Platform pac modelbuilder build comme décrit dans Générer des classes à liaison anticipée pour le SDK pour .NET.

Classe SearchEntity

Utilisée pour composer des données de type SearchEntity .

public sealed class SearchEntity
{
    /// <summary>
    /// Gets or sets the logical name of the table. Specifies scope of the query.
    /// </summary>
    [DataMember(Name = "name", IsRequired = true)]
    public string Name { get; set; }

    /// <summary>
    /// Gets or sets the list of columns that needs to be projected when table documents are returned in response. 
    /// If empty, only PrimaryName will be returned.
    /// </summary>
    [DataMember(Name = "selectcolumns")]
    public List<string> SelectColumns { get; set; }

    /// <summary>
    /// Gets or sets the list of columns to scope the query on.
    /// If empty, only PrimaryName will be searched on. 
    /// </summary>
    [DataMember(Name = "searchcolumns")]
    public List<string> SearchColumns { get; set; }

    /// <summary>
    /// Gets or sets the filters applied on the entity.
    /// </summary>
    [DataMember(Name = "filter")]
    public string Filter { get; set; }
}
Classe SearchQueryResults

À utiliser pour désérialiser les données JSON de la propriété de chaîne searchqueryResponse.response.

public sealed class SearchQueryResults
{
    /// <summary>
    /// Provides error information from Azure Cognitive search.
    /// </summary>
    public ErrorDetail? Error { get; set; }

    /// <summary>
    /// A collection of matching records.
    /// </summary>
    public List<QueryResult>? Value { get; set; }

    /// <summary>
    /// If facets were requested in the query, a dictionary of facet values.
    /// </summary>
    public Dictionary<string, IList<FacetResult>>? Facets { get; set; }

    /// <summary>
    /// The query context returned as part of response. This property is used for backend search. It is included for future feature releases and is not currently used.
    /// </summary>
    public QueryContext? QueryContext { get; set; }

    /// <summary>
    /// If `"Count": true` is included in the body of the request, the count of all documents that match the search, ignoring top and skip.
    /// </summary>
    public long Count { get; set; }
}
Classe ErrorDetail

Utilisée pour désérialiser les données ErrorDetail.

public sealed class ErrorDetail
{
    /// <summary>
    /// Gets or sets the error code.
    /// </summary>
    [DataMember(Name = "code")]
    public string Code { get; set; }

    /// <summary>
    /// Gets or sets the error message.
    /// </summary>
    [DataMember(Name = "message")]
    public string Message { get; set; }

    /// <summary>
    /// Gets or sets additional error information.
    /// </summary>
    [DataMember(Name = "propertybag")]
    public Dictionary<string, object> PropertyBag { get; set; }
}
Classe QueryResult

Utilisée pour désérialiser les données QueryResult.

public sealed class QueryResult
{
    /// <summary>
    /// Gets or sets the identifier of the record
    /// </summary>
    public string Id { get; set; }

    /// <summary>
    /// Gets or sets the logical name of the table
    /// </summary>
    public string EntityName { get; set; }

    /// <summary>
    /// Gets or sets the object type code
    /// </summary>
    public int ObjectTypeCode { get; set; }

    /// <summary>
    /// Gets or sets the record attributes
    /// </summary>
    public Dictionary<string, object> Attributes { get; set; }

    /// <summary>
    /// Gets or sets the highlights
    /// </summary>
    public Dictionary<string, string[]> Highlights { get; set; }

    // Gets or sets the document score
    public double Score { get; set; }
}
Classe FacetResult

Utilisée pour désérialiser les données FacetResult.

public sealed class FacetResult
{
    /// <summary>
    /// Gets or sets the count of documents falling within the bucket described by this facet.
    /// </summary>
    [DataMember(Name = "count")]
    public long? Count { get; set; }

    /// <summary>
    /// Gets or sets value indicating the inclusive lower bound of the facet's range, or null to indicate that there is no lower bound.
    /// </summary>
    [DataMember(Name = "from")]
    public object From { get; set; }

    /// <summary>
    /// Gets or sets value indicating the exclusive upper bound of the facet's range, or null to indicate that there is no upper bound.
    /// </summary>
    [DataMember(Name = "to")]
    public object To { get; set; }

    /// <summary>
    /// Gets or sets type of the facet - Value or Range.
    /// </summary>
    [DataMember(Name = "type")]
    public FacetType Type { get; set; }

    /// <summary>
    /// Gets or sets value of the facet, or the inclusive lower bound if it's an interval facet.
    /// </summary>
    [DataMember(Name = "value")]
    public object Value { get; set; }

    /// <summary>
    /// Gets or sets additional/ Optional value of the facet, will be populated while faceting on lookups.
    /// </summary>
    [DataMember(Name = "optionalvalue")]
    public object OptionalValue { get; set; }
}
Classe FacetType

Spécifie le type de résultat d’une requête de facettes.

public enum FacetType
{
    /// <summary>
    /// The facet counts documents with a particular field value.
    /// </summary>
    [EnumMember(Value = "value")]
    Value = 0,

    /// <summary>
    /// The facet counts documents with a field value in a particular range.
    /// </summary>
    [EnumMember(Value = "range")]
    Range = 1,
}
Classe QueryContext

Utilisée pour désérialiser les données QueryContext.

public sealed class QueryContext
{
    /// <summary>
    /// Gets or sets the query string as specified in the request.
    /// </summary>
    [DataMember(Name = "originalquery")]
    public string OriginalQuery { get; set; }

    /// <summary>
    /// Gets or sets the query string that Dataverse search used to perform the query. 
    /// Dataverse search uses the altered query string if the original query string contained spelling mistakes or did not yield optimal results.
    /// </summary>
    [DataMember(Name = "alteredquery")]
    public string AlteredQuery { get; set; }

    /// <summary>
    /// Gets or sets the reason behind query alter decision by Dataverse search.
    /// </summary>
    [DataMember(Name = "reason")]
    public List<string> Reason { get; set; }

    /// <summary>
    /// Gets or sets the spell suggestion that are the likely words that represent user's intent. 
    /// This will be populated only when the query was altered by Dataverse search due to spell check.
    /// </summary>
    [DataMember(Name = "spellsuggestions")]
    public List<string> SpellSuggestions { get; set; }
}

Voir aussi

Rechercher des enregistrements Dataverse
Suggestion de recherche Dataverse
Recherche par exécution automatique Dataverse
Statistiques et statut de recherche Dataverse
Recherche héritée Dataverse

Notes

Pouvez-vous nous indiquer vos préférences de langue pour la documentation ? Répondez à un court questionnaire. (veuillez noter que ce questionnaire est en anglais)

Le questionnaire vous prendra environ sept minutes. Aucune donnée personnelle n’est collectée (déclaration de confidentialité).