Compartir a través de

Consulta de búsqueda de Dataverse

  • Artículo

La operación de consulta devuelve resultados de búsqueda basados en un término de búsqueda.

Además de término de búsqueda, los resultados devueltos pueden verse influenciados pasando valores para los siguientes parámetros:

Name Type Description Más información
search string Requerido. El texto con el que se buscará Parámetro de búsqueda
count bool Si se debe devolver el recuento total de registros. parámetro count
entities string Limita el alcance de la búsqueda a un subconjunto de tablas. parámetro entities
facets string Las facetas admiten la capacidad de explorar en profundidad en los resultados de los datos después de que se hayan recuperado. parámetro facets
filter string Limita el alcance de los resultados de búsqueda devueltos. parámetro filter
options string Las opciones son configuraciones configuradas para buscar un término de búsqueda. parámetro options
orderby string Especifica cómo ordenar los resultados en orden de precedencia. parámetro orderby
skip entero Especifica el número de resultados de búsqueda a omitir. parámetros skip y top
top entero Especifica el número de resultados de la búsqueda a recuperar. parámetros skip y top

Parámetros

Esta sección incluye detalles sobre los parámetros presentados en la tabla anterior.

Parámetro search

Tipo: cadena
Opcional: falso

El parámetro de búsqueda contiene el texto a buscar. Es el único parámetro requerido. Término de búsqueda debe tener al menos un carácter y tiene un límite de 100 caracteres.

Sintaxis de búsqueda simple

De forma predeterminada, el parámetro de búsqueda admite una sintaxis de búsqueda simple, como se describe en la siguiente tabla:

Funcionalidad Description
Operadores booleanos Operador AND; denotado mediante +
Operador O; denotado mediante |
Operador NO; denotado mediante -
Operadores de precedencia Un término de búsqueda hotel+(wifi | luxury) busca resultados que contengan el término hotel y wifi o luxury (o ambos).
Comodines Se admiten comodines finales. Por ejemplo, Alp* busca "alpino".
Coincidencias exactas Una consulta entre comillas " ".

Nota

Para usar cualquiera de los operadores de búsqueda como parte del texto de búsqueda, escape el carácter poniéndole el prefijo de sola barra invertida (\). Los caracteres especiales que requieren escape incluyen los siguientes: + - & | ! ( ) { } [ ] ^ " ~ * ? : \ /.

Por ejemplo, un número de teléfono escapado podría verse así: \+1\(800\)555\-1234.

Usando el parámetro options, puede habilitar la sintaxis de consulta de Lucerna que habilita diferentes operadores.

Parámetro count

Tipo: booleano
Opcional: verdadero

Si se debe devolver el recuento total de registros. Si no se establece este parámetro, la propiedad de respuesta Count es -1.

Parámetro entities

Tipo: cadena
Opcional: verdadero

De forma predeterminada, se buscan todas las tablas habilitadas para la búsqueda, a menos que especifique un subconjunto utilizando el parámetro entities.

Cuando configura una entidad, también puede especificar qué columnas desea devolver y qué columnas buscar. También puede incluir criterios de filtro para la tabla.

Para obtener una lista de tablas habilitadas para el entorno, utilice la API Estado de búsqueda y busque las tablas enumeradas por entitylogicalname dentro de entitystatusresults.

Tipo de entidad de búsqueda

Utilice este tipo para componer la matriz de tablas para pasar al parámetro entities.

Nombre de campo Type Description
name string Obligatorio. Nombre lógico de la tabla. Especifica el ámbito de la consulta.
selectColumns string[] Opcional. Lista de columnas que deben proyectarse cuando se devuelven documentos de tabla como respuesta. Si está vacío, solo se devuelve el nombre principal de la tabla.
searchColumns string[] Opcional. Lista de columnas a las que se aplicará el ámbito de la consulta. Si está vacío, solo se busca sobre el nombre principal de la tabla.
filter string Opcional. Filtros aplicados a la entidad.

Ejemplo

A continuación se muestra un ejemplo de algunos datos JSON que utilizan el esquema descrito anteriormente.

[
   {
      "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"
   }
]

Para utilizar estos datos, debe escapar de la cadena y pasarla como el valor del parámetro entities en el cuerpo de la solicitud:

{
    "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\"}]"
}

Parámetro facets

Tipo: cadena
Opcional: verdadero

El parámetro facet es opcional. La cadena puede contener parámetros para personalizar las facetas, expresados como pares de nombre-valor separados por comas. Utilice facetas para agrupar los resultados de su búsqueda.

Definición de faceta

Las facetas se definen como una matriz de cadenas, por ejemplo:

[
"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"
]

Cada elemento de la matriz representa una forma diferente de agrupar los datos devueltos por la consulta. Para cada propiedad devuelta, puede especificar las facetas adecuadas utilizando los valores de la siguiente tabla:

Tipo de faceta Description
count El número máximo de términos facetarios. El valor predeterminado es 10. No hay ningún límite superior.
sort Se puede configurar como count, -count, value, -value. Use count para ordenar descendentemente por count. Use -count para ordenar ascendentemente por count. Use value para ordenar ascendentemente por value. Use -value para ordenar descendentemente por value.
values Se establece en valores numéricos delimitados por barras verticales o Edm.DateTimeOffset que especifican un conjunto dinámico de valores de entrada de faceta. Los valores deben enumerarse en orden secuencial ascendente para obtener los resultados esperados.
interval Un intervalo entero mayor que cero para números, o minutos, horas, días, semanas, meses, trimestres y años para valores de fecha y hora.
timeoffset Configure a ([+-]hh:mm, [+-]hhmmo [+-]hh). Si se usa, el parámetro timeoffset debe combinarse con la opción de intervalo, y solo cuando se aplica a un campo de tipo Edm.DateTimeOffset. El valor especifica el desplazamiento de hora UTC que se debe tener en cuenta al establecer límites de tiempo.

Nota

count y sort se pueden combinar en la misma especificación de faceta, pero no se pueden combinar con interval o values, y interval y values no se pueden combinar entre sí.

Establezca el valor facets con una cadena de escape que contenga la definición de las facetas.

{
    "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\"]"    
}

Más información:

Parámetro filter

Tipo: cadena
Opcional: verdadero

Los filtros limitan el alcance de los resultados de búsqueda devueltos. Usar filtros para excluir resultados que no quiera. Este es un filtro de nivel superior que ayuda a filtrar columnas comunes en múltiples entidades como createdon o modifiedon, etc.

Aplique filtros usando esta sintaxis: <attribute logical name> <filter> donde el nombre lógico de la tabla especifica la entidad a la que se debe aplicar el filtro.

Los filtros usan los siguientes operadores de consulta:

Operator Description Ejemplo
Operadores de comparación    
eq Es igual a revenue eq 100000
ne No es igual a revenue ne 100000
gt Mayor que revenue gt 100000
ge Mayor o igual que revenue ge 100000
lt Menor que revenue lt 100000
le Menor o igual que revenue le 100000
Operadores lógicos    
and Lógico y revenue lt 100000 and revenue gt 2000
or Disyunción lógica name eq 'sample' or name eq 'test'
not Negación lógica not name eq 'sample'
Agrupación de operadores    
( ) Agrupaciones por prioridad (name eq 'sample') or name eq 'test') and revenue gt 5000

Parámetro options

Tipo: cadena
Opcional: verdadero

Las opciones son configuraciones configuradas para buscar un término de búsqueda. Establezca el valor options en un Dictionary<string, string> serializado de estas opciones, como "{'querytype': 'lucene', 'searchmode': 'all', 'besteffortsearchenabled': 'true', 'grouprankingenabled': 'true'}".

La siguiente tabla enumera las opciones:

Opción Description
querytype Los valores pueden ser simple or luceneSintaxis de consulta de Lucerna
besteffortsearchenabled Permite que el flujo de trabajo de consultas inteligente devuelva un conjunto probable de resultados si no se encuentran buenas coincidencias para los términos de la solicitud de búsqueda.
groupranking Habilite la clasificación de resultados en la respuesta optimizada para mostrarse en las páginas de resultados de búsqueda donde los resultados se agrupan por tabla.
searchmode Cuando se especifica como all, todos los términos de búsqueda deben coincidir para que se considere el documento como una coincidencia Si se establece su valor en any se elige por defecto la coincidencia con cualquier palabra en término de búsqueda.

Sintaxis de consulta Lucerne

La sintaxis de consulta de Lucene admite la siguiente funcionalidad:

Funcionalidad Descripción
Operadores booleanos Proporciona un conjunto ampliado en comparación con la sintaxis de consulta simple.
Operador AND; denotado mediante AND, &&, +
Operador OR; denotado mediante OR, ||
Operador NOT; denotado mediante NOT, !, –
Comodines Además de un comodín final, también admite un comodín inicial.
Comodín final: alp*
Comodín inicial: /.*pine/
Búsqueda borrosa Admite consultas mal escritas por hasta dos caracteres.
Uniersty~ devuelve University
Blue~1 devuelve glue, blues
Refuerzo de términos Sopesa términos específicos en una consulta de manera diferente.
Rock^2 electronic devuevle resultados donde las coincidencias de rock son más importantes que las coincidencias con electronic.
Búsqueda por proximidad Devuelve resultados donde los términos están a una distancia de menos de x palabras entre sí, para obtener resultados más contextuales.
Por ejemplo, "airport hotel"~5 devuelve resultados en los que airport y hotel distan entre sí un máximo de cinco palabras, con lo que aumentan las posibilidades de encontrar un hotel cerca de un aeropuerto.
Búsqueda de expresión regular (regex) Por ejemplo: /[mh]otel/ coincide con motel o hotel.

Parámetro orderby

Tipo: cadena
Opcional: verdadero

Use el parámetro orderby para anular el orden predeterminado. De forma predeterminada, los resultados se enumeran en orden descendente de puntuación de relevancia (@search.score). Para resultados con puntuaciones idénticas, el orden es aleatorio. Solo puede utilizar este parámetro cuando el tipo de consulta es lucene con caracteres comodín en la cadena de consulta.

Use una lista de cláusulas separadas por comas donde cada cláusula consta de un nombre de columna seguido de asc (ascendente, que es el predeterminado) o desc (descendente).

Para un conjunto de resultados que contienen varios tipos de tablas, la lista de cláusulas para orderby debe ser de aplicación global (por ejemplo, modifiedon, createdon, @search.score). Por ejemplo, para obtener resultados clasificados (en orden de precedencia) por relevancia, seguidos de los registros modificados más recientemente enumerados más arriba:

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

Si la solicitud de consulta incluye un filtro para un tipo de tabla específico, orderby opcionalmente, puede especificar columnas específicas de la tabla.

Parámetros skip y top

Type: int
Opcional: verdadero

Puede utilizar estos parámetros junto con el parámetro count para crear una experiencia paginada.

De forma predeterminada, se devuelven 50 resultados a la vez. Puede usar top para aumentarlo hasta 100, pero más comúnmente usará top para especificar un conjunto de resultados más pequeño, como 10, y luego usará skip para omitir los resultados devueltos anteriormente cuando el usuario pasa a la página siguiente.

Response

La respuesta de la operación de consulta es una cadena de escape que incluye datos JSON.

La respuesta sin escape contiene JSON usando las siguientes propiedades.

Name Type Description
Error ErrorDetail Proporciona información de error de la búsqueda de Azure Cognitive.
Value QueryResult[] Una colección de registros coincidentes.
Facets Dictionary<string,FacetResult[]> Si se solicitaron facetas en la consulta, un diccionario de valores de facetas.
QueryContext QueryContext Esta propiedad se usa pra la búsqueda en el backend. Está incluido para versiones de actualización de características y actualmente no se utiliza.
Count long Si "Count": true se incluye en el cuerpo de la solicitud, el recuento de todos los documentos que coinciden con la búsqueda, ignorando top y skip.

Tipos de respuesta

Esta sección describe los tipos devueltos con la respuesta.

ErrorDetail

Se devolvió el error de búsqueda de Azure Cognitive como parte de la respuesta.

Name Type Description
code string Código de error.
message string El mensaje de error.
propertybag Dictionary<string, object> Más información de error.

QueryResult

Cada elemento de QueryResult devuelto en la respuesta de la propiedad Value representa un registro en Dataverse.

Name Type Description
Id string El identificador del registro.
EntityName string Nombre lógico de la tabla.
ObjectTypeCode entero El código de tipo de objeto de fila.
Attributes Dictionary<string, object> Atributos del registro
Highlights Dictionary<string, string[]> Marcadores para destacados.
Score doble La puntuación del documento.

FacetResult

Un resultado de consulta de faceta que informa la cantidad de documentos con un campo que se encuentra dentro de un rango particular o que tiene un valor o intervalo particular.

Name Type Description
count long? El recuento de documentos que se encuentran dentro del grupo descrito por esta faceta.
from objeto Valor que indica el límite inferior inclusivo del rango de la faceta o nulo para indicar que no hay un límite inferior.
to objeto Valor que indica el límite superior exclusivo del rango de la faceta o nulo para indicar que no hay un límite superior.
type Value | Range Tipo de la faceta.
value objeto Valor de la faceta o el límite inferior inclusivo si es una faceta de intervalo.
optionalvalue objeto Otro valor u opcional de la faceta, que se completa durante las facetas en las búsquedas.

QueryContext

El contexto de la consulta se devolvió como parte de la respuesta. Esta propiedad se usa pra la búsqueda en el backend. Está incluido para versiones de actualización de características y actualmente no se utiliza.

Name Type Description
originalquery string La cadena de consulta tal como se especifica en la solicitud.
alteredquery string La cadena de consulta que la búsqueda de Dataverse usó para realizar la consulta. La búsqueda de Dataverse utiliza la cadena de consulta modificada si la cadena de consulta original contenía errores ortográficos o no produjo resultados óptimos.
reason string[] Las razones detrás de la consulta alteran la decisión de la búsqueda de Dataverse.
spellsuggestions string[] La sugerencia de ortografía, que son las palabras probables que representan la intención del usuario. Se rellena solo cuando Dataverse altera la búsqueda de consultas debido al corrector ortográfico.

Ejemplos

Los siguientes ejemplos muestran cómo usar la operación de consultar. Estos ejemplos realizan una operación de búsqueda en las tablas de cuentas y contactan con las columnas name y fullname respectivamente para registros creados después del 15 de agosto de 2022 y ordenan los siete resultados principales por campo de createdon, descendente.

Este ejemplo es de la muestra de SDK para operaciones de búsqueda de .NET en GitHub. El método estático OutputSearchQuery acepta un valor para el parámetro de búsqueda.

/// <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");
}

Salida

Cuando invoca el método OutputSearchQuery con una instancia autenticada de la clase ServiceClient con searchTerm establecido en "Contoso":

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

El resultado deberá ser ahora similar a esto:

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

Clases de apoyo

El método OutputSearchQuery depende de las siguientes clases de soporte para enviar la solicitud y procesar el resultado:

Clases searchqueryRequest y searchqueryResponse

Estas clases se generan usando el comando Power Platform CLI pac modelbuilder build como se describe en Generar clases enlazadas anticipadamente para el SDK para .NET.

Clase SearchEntity

Se utiliza para componer datos de tipo SearchEntity datos.

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; }
}
Clase SearchQueryResults

Úsela para deserializar datos JSON de la propiedad de cadena 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; }
}
Clase ErrorDetail

Se utiliza para deserializar los datos 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; }
}
Clase QueryResult

Se utiliza para deserializar los datos 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; }
}
Clase FacetResult

Se utiliza para deserializar los datos 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; }
}
Clase FacetType

Especifica el tipo de resultado de una consulta de faceta.

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,
}
Clase QueryContext

Se utiliza para deserializar los datos 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; }
}

Consulte también

Buscar registros de Dataverse
Sugerencia de búsqueda de Dataverse
Autocompletado de búsqueda de Dataverse
Estadísticas y estado de búsqueda de Dataverse
Búsqueda heredada de Dataverse