Freigeben über

Dataverse-Suchabfrage

  • Artikel

Der Abfragevorgang gibt Suchergebnisse je nach Suchbegriff zurück.

Zusätzlich zu einem Suchbegriff können die zurückgegebenen Ergebnisse auch durch die Übergabe von Werten für die folgenden Parameter beeinflusst werden:

Name des Dataflows typ Beschreibung Weitere Informationen
search Zeichenfolge Erforderlich Der Text, mit dem Sie suchen. Suchparameter
count Boolesch Ob die gesamte Anzahl der Datensätze zurückgegeben werden soll. count-Parameter
entities Zeichenfolge Beschränkt die Suche auf eine Teilmenge von Tabellen. entities-Parameter
facets Zeichenfolge Facetten unterstützen die Möglichkeit, Detailinformationen anzeigen zu lassen, nachdem die Datenergebnisse abgerufen wurden. facets-Parameter
filter Zeichenfolge Begrenzt den Umfang der zurückgegebenen Suchergebnisse. filter-Parameter
options Zeichenfolge Optionen sind Einstellungen, die für die Suche nach einem Suchbegriff konfiguriert sind. options-Parameter
orderby Zeichenfolge Gibt an, wie die Ergebnisse in der Rangfolge sortiert werden sollen. orderby-Parameter
skip Int Gibt die Anzahl der zu überspringenden Suchergebnisse an. skip- und top-Parameter
top Int Gibt die Anzahl der abzurufenden Suchergebnisse an. skip- und top-Parameter

Parameter

Dieser Abschnitt enthält Einzelheiten zu den in der obigen Tabelle eingeführten Parametern.

search-Parameter

Typ: Zeichenfolge
Optional: falsch

Der Suchparameter enthält den zu durchsuchenden Text. Es ist der einzige erforderliche Parameter. Der Suchbegriff muss mindestens ein Zeichen lang sein und ist auf 100 Zeichen begrenzt.

Einfache Suchsyntax

Standardmäßig unterstützt der search-Parameter eine einfache Suchsyntax, wie in der folgenden Tabelle beschrieben:

Funktionalität Beschreibung
Boolesche Operatoren AND-Operator, durch + angegeben
OR-Operator, durch | angegeben
NOT-Operator, durch - angegeben
Rangfolge-Operatoren Ein Suchbegriff hotel+(wifi | luxury) sucht nach Ergebnissen, die den Begriff hotel sowie entweder wifi oder luxury (oder beides) enthalten.
Platzhalter Nachfolgende Platzhalter werden unterstützt. Alp* sucht beispielsweise nach „Alpin“.
Genaue Übereinstimmungen Eine in Anführungszeichen " " eingeschlossene Abfrage.

Hinweis

Um einen der Suchoperatoren als Teil des Suchtextes zu verwenden, maskieren Sie das Zeichen, indem Sie ihm einen einzelnen Backslash (\) voranstellen. Zu den Sonderzeichen, für die eine Maskierung erforderlich ist, gehören: + - & | ! ( ) { } [ ] ^ " ~ * ? : \ /.

Eine maskierte Telefonnummer könnte beispielsweise so aussehen: \+1\(800\)555\-1234.

Mit dem options-Parameter können Sie die Lucerne-Abfragesyntax aktivieren, die verschiedene Operatoren ermöglicht.

count-Parameter

Typ: boolesch
Optional: wahr

Ob die gesamte Anzahl der Datensätze zurückgegeben werden soll. Wenn Sie diesen Parameter nicht festlegen, lautet die Count-Antworteigenschaft -1.

entities-Parameter

Typ: Zeichenfolge
Optional: wahr

Standardmäßig werden alle für die Suche aktivierten Tabellen durchsucht, es sei denn, Sie legen eine Teilmenge mit dem entities-Parameter fest.

Wenn Sie eine Entität festlegen, können Sie auch angeben, welche Spalten zurückgegeben werden sollen und welche Spalten durchsucht werden sollen. Sie können auch Filterkriterien für die Tabelle einschließen.

Um eine Liste der für die Umgebung aktivierten Tabellen zu erhalten, verwenden Sie die Suchstatus-API und suchen Sie nach den von entitylogicalname und entitystatusresults aufgelisteten Tabellen.

SearchEntity-Typ

Verwenden Sie diesen Typ, um das Array von Tabellen zusammenzustellen, das an den entities-Parameter übergeben werden soll.

Feldname typ Beschreibung
name Zeichenfolge Erforderlich. Logischer Name der Tabelle. Gibt den Umfang der Abfrage an.
selectColumns string[] Optional. Liste der Spalten, die projiziert werden müssen, wenn Tabellendokumente als Antwort zurückgegeben werden. Ist hier nichts angegeben, wird nur der primäre Tabellenname zurückgegeben.
searchColumns string[] Optional. Liste der Spalten, auf welche die Abfrage angewendet werden soll. Ist hier nichts angegeben, wird nur nach dem primären Tabellenname gesucht.
filter Zeichenfolge Optional. Auf die Entität angewendete Filter.

Beispiel

Im Folgenden finden Sie ein Beispiel für einige JSON-Daten, die das oben beschriebene Schema verwenden.

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

Um diese Daten zu verwenden, müssen Sie die Zeichenfolge maskieren und als Wert des entities-Parameters im Hauptteil der Anforderung übergeben:

{
    "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-Parameter

Typ: Zeichenfolge
Optional: wahr

Der facet-Parameter ist optional. Die Zeichenfolge kann Parameter zum Anpassen der Facettierung enthalten, die als durch Kommas getrennte Name-Wert-Paare ausgedrückt werden. Verwenden Sie Facetten, um Ihre Suchergebnisse zu gruppieren.

Facettendefinition

Facetten werden als Array von Zeichenfolgen definiert, zum Beispiel:

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

Jedes Element im Array stellt eine andere Möglichkeit dar, die von der Abfrage zurückgegebenen Daten zu gruppieren. Für jede zurückgegebene Eigenschaft können Sie mithilfe der Werte in der folgenden Tabelle eine entsprechende Facettierung angeben:

Facettentyp Beschreibung
count Die maximale Anzahl von Facettenbegriffen. Der Standard ist 10. Es gibt keine Obergrenze
sort Sie kann auf count, -count, value, -value festgelegt werden. Verwenden Sie count, um absteigend nach count zu sortieren. Verwenden Sie -count, um aufsteigend nach count zu sortieren. Verwenden Sie value, um aufsteigend nach value zu sortieren. Verwenden Sie -value, um absteigend nach value zu sortieren.
values Wird auf durch durch senkrechte Striche getrennte numerische oder Edm.DateTimeOffset Werte festgelegt, die einen dynamischen Satz von Facetteneintragswerten angeben. Um die erwarteten Ergebnisse zu erhalten, müssen die Werte in aufsteigender Reihenfolge aufgelistet werden.
interval Ein ganzzahliges Intervall größer als Null für Zahlen oder Minute, Stunde, Tag, Woche, Monat, Quartal, Jahr für Datums-/Uhrzeitwerte.
timeoffset Wird auf ([+-]hh:mm, [+-]hhmm oder [+-]hh) festgelegt. Bei Verwendung muss der timeoffset-Parameter mit der Intervalloption kombiniert werden, und zwar nur, wenn er auf ein Feld vom Typ Edm.DateTimeOffset angewendet wird. Der Wert gibt die UTC-Zeitverschiebung an, die beim Festlegen von Zeitgrenzen berücksichtigt werden soll.

Hinweis

count und sort können in derselben Facettenspezifikation kombiniert werden, sie können jedoch nicht mit interval oder values, und interval und values können nicht miteinander kombiniert werden.

Legen Sie den facets-Wert mit einer maskierten Zeichenfolge fest, die die Definition der Facetten enthält.

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

Weitere Informationen:

filter-Parameter

Typ: Zeichenfolge
Optional: wahr

Filter begrenzen den Umfang der zurückgegebenen Suchergebnisse. Verwenden Sie Filter, um unerwünschte Ergebnisse auszuschließen. Dies ist ein Filter der obersten Ebene, der dabei hilft, gemeinsame Spalten über mehrere Entitäten hinweg zu filtern, z. B. createdon oder modifiedon usw.

Wenden Sie Filter mit dieser Syntax an: <attribute logical name> <filter> wobei der logische Tabellenname die Entität angibt, auf die der Filter angewendet werden soll.

Filter verwenden die folgenden Abfrageoperatoren:

Operator Beschreibung Beispiel
Vergleichsoperatoren    
eq Gleich revenue eq 100000
ne Ungleich revenue ne 100000
gt Größer als revenue gt 100000
ge Größer als oder gleich revenue ge 100000
lt Kleiner als revenue lt 100000
le Kleiner oder gleich revenue le 100000
Logische Operatoren    
and Logisch und revenue lt 100000 and revenue gt 2000
or Logisch oder name eq 'sample' or name eq 'test'
not Logische Negation not name eq 'sample'
Gruppierungsoperatoren    
( ) Rangfolgengruppierung (name eq 'sample') or name eq 'test') and revenue gt 5000

options-Parameter

Typ: Zeichenfolge
Optional: wahr

Optionen sind Einstellungen, die für die Suche nach einem Suchbegriff konfiguriert sind. Legen Sie den options-Wert auf einen serialisierten Dictionary<string, string> dieser Optionen fest, z. B. "{'querytype': 'lucene', 'searchmode': 'all', 'besteffortsearchenabled': 'true', 'grouprankingenabled': 'true'}".

Diese Optionen sind in der folgenden Tabelle aufgeführt:

Option Beschreibung
querytype Die Werte können simple oder lucene Lucerne-Abfragesyntax sein
besteffortsearchenabled Ermöglicht einen intelligenten Abfrageworkflow, um wahrscheinliche Ergebnisse zurückzugeben, wenn keine guten Übereinstimmungen für die Suchbegriffe gefunden werden.
groupranking Aktivieren Sie die Rangfolge der Ergebnisse in der Antwort, die für die Anzeige auf Suchergebnisseiten optimiert ist, wo die Ergebnisse nach Tabellen gruppiert sind.
searchmode Wenn die Suchbegriffe als all spezifiziert sind, müssen sie aufeinander abgestimmt werden, damit das Dokument als Übereinstimmung gezählt wird. Wenn der Wert auf any festgelegt wird, wird standardmäßig jedes Wort im Suchbegriff abgestimmt.

Lucerne-Abfragesyntax

Die Lucene-Abfragesyntax unterstützt die folgenden Funktionen:

Funktionalität Beschreibung
Boolesche Operatoren Bietet einen erweiterten Satz im Vergleich zur einfachen Abfragesyntax.
AND-Operator, durch AND, &&, + angegeben
OR-Operator, durch ein OR, || angegeben
NOT-Operator, durch NOT, !, – angegeben
Platzhalter Unterstützt neben einem nachfolgenden Platzhalter auch einen führenden Platzhalter.
Nachstehender Platzhalter – alp*
Vorstehender Platzhalter – /.*pine/
Fuzzysuche Unterstützt Abfragen, die um bis zu zwei Zeichen false geschrieben sind.
Uniersty~ gibt University zurück
Blue~1 gibt glue, blues zurück
Relevanz eines Begriffs erhöhen Gewichtet bestimmte Begriffe in einer Abfrage unterschiedlich.
Rock^2 electronic gibt Ergebnisse zurück, bei denen die Übereinstimmungen mit rock wichtiger sind als die mit electronic.
Näherungssuche Gibt Ergebnisse zurück, bei denen die Begriffe innerhalb von x Wörtern voneinander liegen, für kontextbezogenere Ergebnisse.
Beispiel: "airport hotel"~5 liefert Ergebnisse, bei denen airport und hotel innerhalb von fünf Wörtern voneinander liegen, und erhöht so die Chancen, ein Hotel in der Nähe eines Flughafens zu finden.
Suche nach regulären Ausdrücken (regex) Beispiel: /[mh]otel/ stimmt mit motel oder hotel überein.

orderby-Parameter

Typ: Zeichenfolge
Optional: wahr

Verwenden Sie den orderby-Parameter, um die Standardreihenfolge zu überschreiben. Standardmäßig werden die Ergebnisse in absteigender Reihenfolge der Relevanzbewertung (@search.score) aufgelistet. Bei Ergebnissen mit identischen Bewertungen ist die Reihenfolge zufällig. Sie können diesen Parameter nur verwenden, wenn der Abfragetyp Lucene mit Platzhalterzeichen in der Abfragezeichenfolge lautet.

Verwenden Xie eine Liste von durch Kommas getrennten Klauseln, wobei jede Klausel aus einem Spaltennamen gefolgt von asc (aufsteigend, was die Standardeinstellung ist) oder desc (absteigend) besteht.

Für eine Reihe von Ergebnissen, die mehrere Tabellentypen enthalten, die Liste der Klauseln für orderby muss global anwendbar sein (z. B. modifiedon, createdon, @search.score). So erhalten Sie beispielsweise Ergebnisse, die (in der angegebenen Rangfolge) nach Relevanz geordnet sind, gefolgt von den zuletzt geänderten Datensätzen, die höher in der Folge aufgeführt sind:

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

Wenn die Abfrageanforderung einen Filter für einen bestimmten Tabellentyp enthält, kann orderby optional tabellenspezifische Spalten angeben.

skip- und top-Parameter

Typ: Integer
Optional: wahr

Sie können diese Parameter zusammen mit dem count-Parameter verwenden, um ein ausgelagertes Ergebnis zu schaffen.

Standardmäßig werden bis zu 50 Ergebnisse gleichzeitig zurückgegeben. Sie können top verwenden, um dies auf bis zu 100 zu erhöhen. Normalerweise verwenden Sie top jedoch, um eine kleinere Ergebnismenge anzugeben, z. B. 10, und verwenden dann skip, um zuvor zurückgegebene Ergebnisse zu umgehen, wenn der Benutzende zur nächsten Seite wechselt.

Antworten

Die Antwort des Abfragevorgangs ist eine maskierte Zeichenfolge, die JSON-Daten enthält.

Die Antwort ohne maskierte Zeichen enthält JSON mit den folgenden Eigenschaften.

Name des Dataflows typ Beschreibung
Error ErrorDetail Stellt Fehlerinformationen aus der Azure Cognitive Search bereit.
Value QueryResult[] Eine Sammlung übereinstimmender Datensätze.
Facets Dictionary<string, FacetResult[]> Ein Wörterbuch mit Facettenwerten, wenn in der Abfrage Facetten angefordert wurden.
QueryContext QueryContext Diese Eigenschaft wird für die Back-End-Suche verwendet. Es ist für zukünftige Featurereleases enthalten und wird derzeit nicht verwendet.
Count long Wenn "Count": true im Hauptteil der Anforderung enthalten ist, stimmt die Anzahl aller Dokumente mit der Suche überein, wobei „top“ und „skip“ ignoriert werden

Antworttypen

In diesem Abschnitt werden die mit der Antwort zurückgegebenen Typen beschrieben.

ErrorDetail

Der Azure Cognitive Search-Fehler wurde als Teil der Antwort zurückgegeben.

Name des Dataflows typ Beschreibung
code Zeichenfolge Der Fehlercode.
message Zeichenfolge Die Fehlermeldung
propertybag Dictionary<string, object> Weitere Informationen zum Fehler.

QueryResult

Jedes QueryResult-Element, das in der Value-Eigenschaft der Antwort zurückgegeben wurde, steht für einen Datensatz in Dataverse.

Name des Dataflows typ Beschreibung
Id Zeichenfolge Der Bezeichner des Datensatzes.
EntityName Zeichenfolge Der logische Name der Tabelle.
ObjectTypeCode Int Der Typcode des Objekts.
Attributes Dictionary<string, object> Datensatzattribute
Highlights Dictionary<string, string[]> Die Highlights.
Score doppelt Der Dokumentwert.

FacetResult

Ein Facettenabfrageergebnis, das die Anzahl der Dokumente angibt, bei denen ein Feld in einen bestimmten Bereich fällt oder einen bestimmten Wert bzw. ein solches Intervall aufweist.

Name des Dataflows typ Beschreibung
count Lang? Die Anzahl der Dokumente, die in den von dieser Facette beschriebenen Bereich fallen.
from object Wert, der die inklusive Untergrenze des Bereichs der Facette angibt, oder null, was anzeigt, dass es keine Untergrenze gibt.
to object Wert, der die exklusive Obergrenze des Bereichs der Facette angibt, oder null, was anzeigt, dass es keine Obergrenze gibt.
type Value | Range Art der Facette.
value object Wert der Facette oder die inklusive Untergrenze, wenn es sich um eine Intervallfacette handelt.
optionalvalue object Ein weiterer oder optionaler Wert der Facette, der beim Facettieren bei Suchvorgängen ausgefüllt wird.

QueryContext

Der als Teil der Antwort zurückgegebene Abfragekontext. Diese Eigenschaft wird für die Back-End-Suche verwendet. Es ist für zukünftige Featurereleases enthalten und wird derzeit nicht verwendet.

Name des Dataflows typ Beschreibung
originalquery Zeichenfolge Die in der Anforderung angegebene Abfragezeichenfolge.
alteredquery Zeichenfolge Die Abfragezeichenfolge, welche die Dataverse-Suche zum Ausführen der Abfrage verwendet hat. Die Dataverse-Suche verwendet die geänderte Abfragezeichenfolge, wenn die ursprüngliche Abfragezeichenfolge Rechtschreibfehler enthalten oder keine optimalen Ergebnisse geliefert hat.
reason string[] Die Gründe für die Entscheidung zur Abfrageänderung durch die Dataverse-Suche.
spellsuggestions string[] Der Rechtschreibvorschlag besteht aus den wahrscheinlichen Wörtern, die die Absicht des Benutzers wiedergeben. Wird nur ausgefüllt, wenn Dataverse die Abfragesuche aufgrund der Rechtschreibprüfung ändert.

Beispiele

Im folgenden Beispiel wird gezeigt, wie diese Abfragevorgänge verwendet werden. In diesen Beispielen wird ein Suchvorgang für die Spalten name und fullname der Konto- bzw. Kontakttabelle durchgeführt und zwar jeweils für Datensätze, die nach dem 15. August 2022 erstellt wurden. Die sieben besten Ergebnisse werden nach dem Feld createdon absteigend geordnet.

Dieses Beispiel stammt aus dem Beispiel für das SDK für den .NET-Suchvorgang auf GitHub. Die statische OutputSearchQuery Methode akzeptiert einen Wert für den Suchparameter.

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

Ausgabe

Wenn Sie die OutputSearchQuery-Methode mit einer authentifizierten Instanz der ServiceClient-Klasse aufrufen, wobei searchTerm auf „Contoso“ gesetzt ist:

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

Die Ausgabe sieht ungefähr wie folgt aus:

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

Unterstützende Klassen

Die OutputSearchQuery-Methode hängt von den folgenden unterstützenden Klassen ab, um die Anfrage zu senden und das Ergebnis zu verarbeiten:

searchqueryRequest- und searchqueryResponse-Klassen

Diese Klassen werden mit dem Power Platform CLI-Befehl pac modelbuilder uild generiert, wie unter Generieren von Klassen mit früher Bindung für das SDK für .NET beschrieben.

SearchEntity-Klasse

Wird zum Zusammenstellen von Daten vom Typ SearchEntity verwendet.

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

Wird zum Deserialisieren von JSON-Daten aus der Zeichenfolgeneigenschaft searchqueryResponse.response verwendet.

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; }
}
ErrorDetail-Klasse

Wird zum Deserialisieren der ErrorDetail-Daten verwendet.

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; }
}
QueryResult-Klasse

Wird zum Deserialisieren der QueryResult-Daten verwendet.

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; }
}
FacetResult-Klasse

Wird zum Deserialisieren der FacetResult-Daten verwendet.

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; }
}
FacetType-Klasse

Gibt den Typ eines Facettenabfrageergebnisses an.

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

Wird zum Deserialisieren der QueryContext-Daten verwendet.

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

Siehe auch

Nach Dataverse-Datensätzen suchen
Dataverse-Suchvorschlag
Dataverse AutoVervollständigen-Suche
Dataverse-Suchstatistiken und -Status
Dataverse Legacy-Suche

Hinweis

Können Sie uns Ihre Präferenzen für die Dokumentationssprache mitteilen? Nehmen Sie an einer kurzen Umfrage teil. (Beachten Sie, dass diese Umfrage auf Englisch ist.)

Die Umfrage dauert etwa sieben Minuten. Es werden keine personenbezogenen Daten erhoben. (Datenschutzbestimmungen).