Refinado de consultas en SharePoint
Aprenda a usar las características de refinamiento de consulta de SharePoint mediante programación cuando se trabaja con las consultas de búsqueda y resultados.
Puede usar las características de refinamiento de consulta para proporcionar a los usuarios finales las opciones de refinamiento que son relevantes para sus consultas. Estas características permiten que el usuario final profundizar en los resultados de búsqueda mediante el uso de datos de refinamiento calculadas para los resultados. Datos de refinamiento se calculan mediante el componente de índice, basándose en la agregación de estadísticas de la propiedad administrada para todos los resultados de una consulta de búsqueda.
Normalmente, se usa el refinamiento de consultas para metadatos asociados con los elementos indizados, como fecha de creación, el autor o tipos de archivo que aparecen en el elemento. Mediante el uso de las opciones de refinamiento, puede restringir la consulta para mostrar sólo los elementos creados durante un período de tiempo determinado o mostrar sólo los elementos de un tipo de archivo específico.
Usar refinadores en el modelo de objetos de consulta
Hay dos consultas implicadas en el refinamiento de consultas:
- Puede solicitar que se devuelva un conjunto de refinadores en los resultados de la búsqueda agregando una especificación de refinador a la consulta del usuario final. Una especificación de refinador es la entrada para la propiedad Refiners . Esta consulta se ejecuta en el índice de búsqueda. Los resultados de búsqueda se componen de resultados relevantes y datos de refinamiento.
- Puede usar los datos de refinamiento para explorar en profundidad los resultados de la búsqueda mediante la creación de una consulta refinada. Agregue la propiedad RefinementFilters a la consulta para que los resultados finales de la búsqueda cumplan los requisitos del texto de consulta original del usuario final y la opción de refinamiento seleccionada de los datos de refinamiento.
En las secciones siguientes se describen estos pasos con detalle y proporcionan ejemplos de código.
Agregar refinadores a la consulta del usuario final con especificaciones de refinador
Puede especificar los refinadores de consultas solicitados mediante la propiedad Refiners de la clase KeywordQuery . Use la siguiente sintaxis para especificar los refinadores de consulta solicitada:
<refiner>[,<refiner>]*
Cada refiner tiene el siguiente formato:
<refiner-name>[(parameter=value[,parameter=value]*)]?
Donde:
<refiner-name>es el nombre de la propiedad administrada asociada con el refinador. Esta propiedad administrada debe establecerse en Refinable o Sortable en el esquema de búsqueda.- La lista opcional de pares
parameter=valueespecifica los valores de configuración no predeterminados para el refinador con nombre. Si un parámetro para un refinador no aparece dentro de los paréntesis, la configuración del esquema de búsqueda proporciona la configuración predeterminada. La tabla 1 se enumeran los valores posibles para los pares deparameter=value.
Nota:
Al especificar refinadores, el requisito mínimo es especificar un refiner-name, que es una propiedad administrada.
Ejemplo
Refiners = "FileType"
O bien, también puede usar la sintaxis avanzada para ajustar la configuración de refinador:
Refiners = "FileType,Write(discretize=manual/2013-01-01/2013-08-22/2013-09-15/2013-09-21/2013-09-22),companies"
Tabla 1: Lista de parámetros para refinadores
| Parámetro | Descripción |
|---|---|
| deephits |
Reemplaza el número de visitas predeterminado que se usa como base para el cálculo de refinamiento. Cuando se producen los refinadores, se evaluará todos los resultados de la consulta. Normalmente, con este parámetro mejorará el rendimiento de la búsqueda. Sintaxis deephits=<integer value> Ejemplo price(deephits=1000) Nota: Este límite se aplica dentro de cada partición de índice. El número real de visitas que se evalúan será mayor que este valor debido a la agregación en particiones de búsqueda. |
| discretize |
Especifica intervalos personalizados (contenedores de refinamiento) para refinadores numéricos. Sintaxis discretize=manual/<threshold>/<threshold>[/<threshold>]* Ejemplo write(discretize=manual/2013-01-01/2013-08-22/2013-09-15/2013-09-21/2013-09-22) El atributo <threshold> especifica el umbral para cada contenedor de refinamiento. Hay un intervalo para todos los elementos que están por debajo del primer umbral especificado, un intervalo entre cada umbral consecutivo y un intervalo para todos los elementos que están por encima del último umbral. Para un refinador de tipo DateTime, especifique el umbral de acuerdo con uno de los siguientes formatos ISO 8601 compatibles:
|
| sort |
Define cómo se ordenan los contenedores dentro de un refinador de cadena. Sintaxis sort=<property>/<direction> Los atributos realizan lo siguiente:
sort=name/ascending Predeterminado: Default frecuencia/descendente. |
| filter |
Define cómo se filtran los contenedores de un refinador de tipo String antes de que se devuelvan al cliente. Sintaxis filter=<bins>/<freq>/<prefix>[<levels>] Los atributos realizan lo siguiente:
|
| cutoff |
Limita los datos que deben transferirse y procesan para los refinadores de cadena profundo. Puede configurar los refinadores para devolver únicamente los valores más relevantes (ubicaciones). Nota: Este filtrado de límite se realiza dentro de cada partición de índice. This differs from the filter parameter, which performs result-side filtering only. You can combine the two parameters. Sintaxis cutoff=<frequency>/<minbins>/<maxbins> Los atributos realizan lo siguiente:
|
Ejemplo: agregar refinadores
En el siguiente ejemplo CSOM muestra cómo solicitar mediante programación tres refinadores: FileType, Writey Companies. Write representa la fecha de última modificación del elemento y usa la sintaxis avanzada para devolver el tamaño fijo papeleras de fecha y hora.
using (var context = new ClientContext("http://<serverName>/<siteCollectionPath>"))
{
var query = new KeywordQuery(context)
{
QueryText = "home",
Refiners = "FileType,Write(discretize=manual/2013-01-01/2013-08-22/2013-09-
15/2013-09-21/2013-09-22),companies"
};
var executor = new SearchExecutor(context);
var results = executor.ExecuteQuery(query);
context.ExecuteQuery();
ResultTable relevantResultsTable = results.Value[0];
ResultTable refinerResultsTable = results.Value[1];
Console.WriteLine(refinerResultsTable.RowCount + " refinement options:");
foreach (var refinementOption in refinerResultsTable.ResultRows)
{
Console.WriteLine("RefinerName: '{0}' RefinementName: '{1}'
RefinementValue: '{2}' RefinementToken: '{3}' RefinementCount: '{4}'",
refinementOption["RefinerName"],
refinementOption["RefinementName"],
refinementOption["RefinementValue"],
refinementOption["RefinementToken"],
refinementOption["RefinementCount"]
);
}
}
Entender los datos de refinamiento en los resultados de la búsqueda
Si ha habilitado el refinamiento de consultas para una propiedad administrada en la consulta, el resultado de la consulta contiene datos de refinamiento divididos en contenedores de refinamiento. Estos datos se encuentran en la tabla RefinementResults ( RefinementResults ) dentro de ResultTableCollection . Un contenedor de refinamiento representa un valor o intervalo de valores específico para la propiedad administrada. La tabla RefinementResults contiene una fila por cada contenedor de refinamiento y contiene las columnas, tal como se especifica en la tabla 2.
Tabla 2. Datos devueltos para cada contenedor de refinamiento
| Parámetro | Descripción |
|---|---|
| RefinerName | El nombre del refinador de consulta. |
| RefinementName | La cadena que representa el contenedor de refinamiento. Esta cadena se suele usar cuando se realiza la presentación de las opciones de refinamiento a los usuarios en una página de resultados de búsqueda. |
| RefinementValue | Una cadena con formato específico de la implementación que representa el refinamiento. Estos datos se devuelven para la depuración y normalmente no es necesarios para el cliente. |
| RefinementToken | Una cadena que representa el contenedor de refinamiento para usar con RefinerName cuando se realiza una consulta refinada. |
| RefinementCount | El número de resultados para este contenedor de refinamiento. Estos datos representan el número de elementos (incluidos los duplicados) en el resultado de búsqueda con un valor para la propiedad administrada determinada que se encuentre en este contenedor de refinamiento. |
Ejemplo: datos de refinamiento
La tabla 3 contiene dos filas de datos de refinamiento. La primera fila contiene los datos de refinamiento de los elementos indizados, donde el tipo de archivo es HTML. La segunda fila contiene datos de los elementos indizados, donde la última vez que modificó son de 2013/09/21 hasta 2013/09/22 de refinamiento.
Tabla 3: Formato y contenido de datos de refinamiento
| RefinerName | RefinementName | RefinementValue | RefinementToken | RefinementCount |
|---|---|---|---|---|
| FileType | HTML | HTML | "????68746d6c" | 50553 |
| Escritura | De 2013-09-21T00:00:00Z hasta 2013-09-22T00:00:00Z | De 2013-09-21T00:00:00Z hasta 2013-09-22T00:00:00Z | intervalo (2013-09-21T00:00:00Z, 2013-09-22T00:00:00Z) | 37 |
Creación de una consulta refinada
Un resultado de búsqueda presenta las opciones de refinamiento en forma de valores de cadena o intervalos de valores. Cada valor de tipo string o un intervalo de valores numéricos se llama a un contenedor de refinamientoy, a continuación, cada contenedor de refinamiento tiene un valor asociado RefinementToken. Una opción de refinamiento está asociada a una propiedad administrada, que es proporcionada por el valor de RefinerName.
Los RefinementTokenRefinerName valores y se concatenen para crear una cadena de refinement filter. Esta cadena representa un filtro que se pueden usar para limitar los elementos de resultado de búsqueda para incluir sólo los elementos que una propiedad administrada tiene un valor dentro de un contenedor de refinamiento. En short:
refinement filter = <RefinerName>:<RefinementToken>
Puede proporcionar uno o varios filtros de refinamiento para una consulta refinada agregando filtros de refinamiento a la propiedad RefinementFilters de la clase KeywordQuery . Varios filtros de refinamiento le permiten proporcionar varios niveles de detalle en los resultados de búsqueda y para aplicar el refinamiento en propiedades multivalor. Por ejemplo, puede restringir la consulta a los elementos que tienen dos autores: cada uno de ellos representado por un contenedor de refinamiento - pero los elementos de exclusión que tienen solo uno de los autores.
Ejemplo 1: crear una consulta refinada para tipos de archivo HTML
El siguiente ejemplo CSOM muestra cómo realizar mediante programación un refinamiento, para limitar los resultados de búsqueda a los de tipo de archivo HTML. Como se mencionó en Ejemplo: Datos de refinamiento, los datos de refinamiento relacionados con esta opción de refinamiento tienen RefinerName establecido en Filetype y RefinementToken establecido en "???? 68746d6c".
using (var context = new ClientContext("http://<serverName>/<siteCollectionPath>"))
{
var query = new KeywordQuery(context)
{
QueryText = "home"
};
query.RefinementFilters.Add("FileType:\\"????68746d6c\\"");
var executor = new SearchExecutor(context);
var results = executor.ExecuteQuery(query);
context.ExecuteQuery();
ResultTable relevantResultsTable = results.Value[0];
var resultCount = 1;
foreach (var relevantResult in relevantResultsTable.ResultRows)
{
Console.WriteLine("Relevant result number {0} has file type {1}.",
resultCount, relevantResult["FileType"]);
resultCount++;
}
}
Ejemplo 2: crear una consulta refinada con datos de refinamiento previamente obtenidos
En el siguiente ejemplo CSOM muestra cómo ejecutar una consulta con una especificación de refinador para crear datos de refinamiento que posteriormente se usan para llevar a cabo el refinamiento. En este ejemplo se simula el proceso de un usuario final selecciona la primera opción de refinamiento.
using (var context = new ClientContext("http://<serverName>/<siteCollectionPath>"))
{
// Step 1: Run the query with refiner spec to provide refinement data in search result
var query = new KeywordQuery(context)
{
QueryText = "home",
Refiners = "FileType,Write(discretize=manual/2013-01-01/2013-08-22/2013-09-15/2013-09-21/2013-09-22),companies"
};
Console.WriteLine("Run query '{0}' with refiner spec '{1}'.", query.QueryText, query.Refiners);
var executor = new SearchExecutor(context);
var results = executor.ExecuteQuery(query);
context.ExecuteQuery();
// The query has been run and we can now look at the refinement data, to view the
// refinement options
ResultTable relevantResultsTable = results.Value[0];
ResultTable refinerResultsTable = results.Value[1];
Console.WriteLine("Got back {0} refinement options in the result:",
refinerResultsTable.RowCount);
foreach (var refinementOption in refinerResultsTable.ResultRows)
{
Console.WriteLine("RefinerName: '{0}' RefinementName: '{1}'
RefinementValue: '{2}' RefinementToken: '{3}' RefinementCount: '{4}'",
refinementOption["RefinerName"],
refinementOption["RefinementName"],
refinementOption["RefinementValue"],
refinementOption["RefinementToken"],
refinementOption["RefinementCount"]
);
}
// Step 2: Run the refined query with refinement filter to drill down into
// the search results. This example uses the first refinement option in the refinement
// data, if available. This simulates an end user selecting this refinement option.
var refinementOptionArray = refinerResultsTable.ResultRows.ToArray();
if (refinementOptionArray.Length > 0)
{
var firstRefinementOption = refinementOptionArray[6];
// Construct the refinement filter by concatenation
var refinementFilter = firstRefinementOption["RefinerName"] + ":" +
firstRefinementOption["RefinementToken"];
var refinedQuery = new KeywordQuery(context)
{
QueryText = query.QueryText
};
refinedQuery.RefinementFilters.Add(refinementFilter);
refinedQuery.SelectProperties.Add("FileType");
refinedQuery.SelectProperties.Add("Write");
refinedQuery.SelectProperties.Add("Companies");
Console.WriteLine("Run query '{0}' with refinement filter '{1}'",
refinedQuery.QueryText, refinementFilter);
var refinedResults = executor.ExecuteQuery(refinedQuery);
context.ExecuteQuery();
ResultTable refinedRelevantResultsTable = refinedResults.Value[0];
var resultCount = 1;
foreach (var relevantResult in refinedRelevantResultsTable.ResultRows)
{
Console.WriteLine("Relevant result number {0} has FileType='{1}',
Write='{2}', Companies='{3}'",
resultCount,
relevantResult["FileType"],
relevantResult["Write"],
relevantResult["Companies"]
);
resultCount++;
}
}
}
Consulte también
- Configurar propiedades del elemento web de refinamiento en SharePoint
- Información general sobre el esquema de búsqueda en SharePoint