# Volledige Tekszoeken (Pt 3 - OpenSearch met ASP.NET CoreM SK4

<!--category-- OpenSearch, ASP.NET -->
<datetime class="hidden">2024-08-24T06:40</datetime>

## Inleiding

In de vorige delen van deze serie hebben we het concept 'full text search' geïntroduceerd en hoe het kan worden gebruikt om tekst te zoeken in een database.

Vorige onderdelen:

- [Vol tekst zoeken met Postgres](/blog/textsearchingpt1)
- [Search Box met Postgres](/blog/textsearchingpt11)
- [Inleiding in OpenSearch](/blog/textsearchingpt2)

In dit deel behandelen we hoe je nieuwe glanzende OpenSearch-instances kan beginnen te gebruiken met ASP.NET Core.

[TOC]

## Opstelling

Zodra we de OpenSearch-instance op en in werking hebben, kunnen we ermee interageren. [OpenSearch Kliënt](https://opensearch.org/docs/latest/clients/OSC-dot-net/) voor .NET.
Eerst zetten we de client op in onze Opstellingsverlenging.

```csharp
    var openSearchConfig = services.ConfigurePOCO<OpenSearchConfig>(configuration.GetSection(OpenSearchConfig.Section));
        var config = new ConnectionSettings(new Uri(openSearchConfig.Endpoint))
            .EnableHttpCompression()
            .EnableDebugMode()
            .ServerCertificateValidationCallback((sender, certificate, chain, errors) => true)
            .BasicAuthentication(openSearchConfig.Username, openSearchConfig.Password);
        services.AddSingleton<OpenSearchClient>(c => new OpenSearchClient(config));
```

Dit zet de client op met het eindpunt en credentials. We kunnen ook de ontfoutingsmodus activeren zodat we kunnen zien wat er aan de hand is.

## Index-gegevens

Het kernconcept van OpenSearch is de Index.

Om dit te doen, gebruiken we de '. [OpenSearch Kliënt](https://opensearch.org/docs/latest/clients/OSC-dot-net/) Je kunt dit installeren via NuGet:

Je ziet er twee: - Opensearch.Net en OpenSearch.Client.De eerste zijn de laag niveau dingen zoals verbindingsmanagement,De tweede zijn de hoge niveau dingen als indexeren en zoeken.

Nu we het geïnstalleerd hebben, kunnen we beginnen te kijken naar indexerende data.

Het creëren van een index is semi-vorderwaarts. Je definieert gewoon hoe je index eruit moet zien en dan creëert het.
In de code onder kan je zien dat we 'map' ons Indexmodel ( een vereenvoudigde versie van het blog
Voor elk veld van dit model definiëren we dan welk type het is: (text, datumM SK2 sleutelwoord enz.

De Tipe is belangrijk omdat het definieert hoe de data worden opgeslagen en hoe ze kunnen worden gezocht.. Bijvoorbeeld, wordt een M SK2teks ' veld geanalyseerd en getokeniseerd.

Ook hier Categories is eigenlijk een string.[] maar de sleutelwoordtype begrijpt hoe ze goed te behandelen zijn.

```csharp
   public async Task CreateIndex(string language)
    {
        var languageName = language.ConvertCodeToLanguageName();
        var indexName = GetBlogIndexName(language);

      var response =  await client.Indices.CreateAsync(indexName, c => c
            .Settings(s => s
                .NumberOfShards(1)
                .NumberOfReplicas(1)
            )
            .Map<BlogIndexModel>(m => m
                .Properties(p => p
                    .Text(t => t
                        .Name(n => n.Title)
                        .Analyzer(languageName)
                    )
                    .Text(t => t
                        .Name(n => n.Content)
                        .Analyzer(languageName)
                    )
                    .Text(t => t
                        .Name(n => n.Language)
                    )
                    .Date(t => t
                        .Name(n => n.LastUpdated)
                    )
                    .Date(t => t
                        .Name(n => n.Published)
                    )
                    .Date(t => t
                        .Name(n => n.LastUpdated)
                    )
                    .Keyword(t => t
                        .Name(n => n.Id)
                    )
                    .Keyword(t=>t
                        .Name(n=>n.Slug)
                    )
                    .Keyword(t=>t
                        .Name(n=>n.Hash)
                    )
                    .Keyword(t => t
                        .Name(n => n.Categories)
                    )
                )
            )
        );
        
        if (!response.IsValid)
        {
           logger.LogError("Failed to create index {IndexName}: {Error}", indexName, response.DebugInformation);
        }
    }
```

## Itemen in de Index toevoegen

Zodra we onze index hebben opgezet om er items aan toe te voegen, moeten we er items bij toevoegen.

Je kunt zien dat we in het begin een methode namen die`GetExistingPosts` die alle posten teruggeeft die al in de index zitten. We groeperen dan de posten per taal en filteren de 'ukM SK2 taal uit.
We gebruiken het hash en id om te bepalen of een bericht al in de index zit.

```csharp
    public async Task AddPostsToIndex(IEnumerable<BlogIndexModel> posts)
    {
        var existingPosts = await GetExistingPosts();
        var langPosts = posts.GroupBy(p => p.Language);
        langPosts=langPosts.Where(p => p.Key!="uk");
        langPosts = langPosts.Where(p =>
            p.Any(post => !existingPosts.Any(existing => existing.Id == post.Id && existing.Hash == post.Hash)));
        
        foreach (var blogIndexModels in langPosts)
        {
            
            var language = blogIndexModels.Key;
            var indexName = GetBlogIndexName(language);
            if(!await IndexExists(language))
            {
                await CreateIndex(language);
            }
            
            var bulkRequest = new BulkRequest(indexName)
            {
                Operations = new BulkOperationsCollection<IBulkOperation>(blogIndexModels.ToList()
                    .Select(p => new BulkIndexOperation<BlogIndexModel>(p))
                    .ToList()),
                Refresh = Refresh.True,
                ErrorTrace = true,
                RequestConfiguration = new RequestConfiguration
                {
                    MaxRetries = 3
                }
            };

            var bulkResponse = await client.BulkAsync(bulkRequest);
            if (!bulkResponse.IsValid)
            {
                logger.LogError("Failed to add posts to index {IndexName}: {Error}", indexName, bulkResponse.DebugInformation);
            }
            
        }
    }
```

Nadat we de bestaande posten en onze ontbrekende analyzer hebben gefilterd, creëren we een nieuwe Index (gebaseerd op de naam, in mijn geval.<language>") en dan een grootschalig verzoek maken. Deze grootschalige vraag is een verzameling van operaties om te doen op de index
Dit is efficiënter dan elke item één per één toevoegen.

Je”'” zal dat in de `BulkRequest` We stelden de `Refresh` eigendom aan `true`. Dit betekent dat na het klaarmaken van de bulk-invoeging de index verfrisd wordt.

## De Index zoeken

Een goede manier om te testen wat hier gemaakt is, is in de Dev-Tools op OpenSearch Dashboards te gaan en een zoekvraag uit te voeren.

```json
GET /mostlylucid-blog-*
{}
```

Deze vraag zal ons alle indexen teruggeven die met het patroon overeenkomen. `mostlylucid-blog-*`. (zo al onze indexen tot nu toe

```json
{
  "mostlylucid-blog-ar": {
    "aliases": {},
    "mappings": {
      "properties": {
        "categories": {
          "type": "keyword"
        },
        "content": {
          "type": "text",
          "analyzer": "arabic"
        },
        "hash": {
          "type": "keyword"
        },
        "id": {
          "type": "keyword"
        },
        "language": {
          "type": "text"
        },
        "lastUpdated": {
          "type": "date"
        },
        "published": {
          "type": "date"
        },
        "slug": {
          "type": "keyword"
        },
        "title": {
          "type": "text",
          "analyzer": "arabic"
        }
      }
    },
    "settings": {
      "index": {
        "replication": {
          "type": "DOCUMENT"
..MANY MORE
```

Dev Tools in OpenSearch Dashboards is een geweldige manier om je vragen te testen voordat je ze in je code zet.

![Dev Tools](devtools.png?width=900&quality=25)

## De Index zoeken

Nu kunnen we beginnen te zoeken naar de index. `Search` methode op de client om dit te doen.
Hier komt de echte kracht van OpenSearch in. Het heeft letterlijk [Duizenden verschillende vragentypes.](https://opensearch.org/docs/latest/query-dsl/) Je kan je data gebruiken om te zoeken. Alles van een simpele sleutelwoordzoek naar een complex 'neuralM SK2 zoek

```csharp
    public async Task<List<BlogIndexModel>> GetSearchResults(string language, string query, int page = 1, int pageSize = 10)
    {
        var indexName = GetBlogIndexName(language);
        var searchResponse = await client.SearchAsync<BlogIndexModel>(s => s
                .Index(indexName)  // Match index pattern
                .Query(q => q
                    .Bool(b => b
                        .Must(m => m
                            .MultiMatch(mm => mm
                                .Query(query)
                                .Fields(f => f
                                    .Field(p => p.Title, boost: 2.0) 
                                    .Field(p => p.Categories, boost: 1.5) 
                                    .Field(p => p.Content)
                                )
                                .Type(TextQueryType.BestFields)
                                .Fuzziness(Fuzziness.Auto)
                            )
                        )
                    )
                )
                .Skip((page -1) * pageSize)  // Skip the first n results (adjust as needed)
                .Size(pageSize)  // Limit the number of results (adjust as needed)
        );

        if(!searchResponse.IsValid)
        {
            logger.LogError("Failed to search index {IndexName}: {Error}", indexName, searchResponse.DebugInformation);
            return new List<BlogIndexModel>();
        }
        return searchResponse.Documents.ToList();
    }

```

### Navraagbeschrijving

Deze methode, `GetSearchResults`, is ontworpen om een specifiek OpenSearch-index te vragen om blogposts terug te halen. `language`, `query`, en paginatieparameters `page` en `pageSize`. Hier'is wat het doet :

1. **Keuse**:
   
   - Het haalt de indexnaam terug met behulp van de `GetBlogIndexName` methode gebaseerd op de voorgestelde taal. De index wordt dynamisch gekies volgens de taal .

2. **De zoekvraag**:
   
   - De zoekopdracht gebruikt een `Bool` Een vraag met een `Must` Clause om te zorgen dat de resultaten met bepaalde criteria overeenkomen.
   - Binnen de `Must` clause,a `MultiMatch` query wordt gebruikt om te zoeken over meerdere velden (`Title`, `Categories`, en `Content`).
     - **Stemverhoging**: De `Title` Het veld krijgt een impuls. `2.0`, waardoor het belangrijker is in de zoekopdracht `Categories` Hij heeft een toename van `1.5`. Dit betekent dat documenten waar de zoekvraag in de titel of categorieën verschijnt hoger rangen.
     - **Navraag-type**: Het gebruikt `BestFields`, die probeert het beste passende veld te vinden voor de vraag
     - **Onduidelijkheid**: De `Fuzziness.Auto` parameter laat toe om ongeveer te overeenstemmen (e.gM SK2 manipulatie van kleine typo's ).

3. **paginatie**:
   
   - De gemeenschappelijke wetgeving van het land. `Skip` De methode overslaat de eerste. `n` Resultaten afhankelijk van de paginanummer, berekend als `(page - 1) * pageSize`. Dit helpt bij het navigeren door paginade resultaten.
   - De gemeenschappelijke wetgeving van het land. `Size` De methode beperkt het aantal teruggestuurde documenten tot de specifiek. `pageSize`.

4. **Fout Handling**:
   
   - Als de zoekopdracht mislukt, wordt een fout gelogd en een leeg lijst teruggestuurd.

5. **Resultaat**:
   
   - De methode gee terug een lijst van: `BlogIndexModel` Dokumenten die overeenkomen met de zoek criteria.

Je ziet dat we heel flexibel kunnen zijn in hoe we onze gegevens zoeken.

Eén grote voordeel is de gemakkelijke qith waarmee we meerdere talen kunnen ondersteunen. We hebben een ander index voor elke taal en kunnen zoeken binnen dat index. Dit betekent dat we het juiste analyzer kunnen gebruiken voor iedere taal en de beste resultaten krijgenM SK2

## De nieuwe zoek-API

In tegenstelling tot de Search API die we in de vorige delen van deze serie zagen, kunnen we het zoekproces enorm vereenvoudigen door OpenSearch te gebruiken.

```csharp
   [HttpGet]
    [Route("osearch/{query}")]
   [ValidateAntiForgeryToken]
    public async Task<JsonHttpResult<List<SearchResults>>> OpenSearch(string query, string language = MarkdownBaseService.EnglishLanguage)
    {
        var results = await indexService.GetSearchResults(language, query);
        
        var host = Request.Host.Value;
        var output = results.Select(x => new SearchResults(x.Title.Trim(), x.Slug, @Url.ActionLink("Show", "Blog", new{ x.Slug}, protocol:"https", host:host) )).ToList();
        return TypedResults.Json(output);
    }
```

Zoals je ziet hebben we alle gegevens die we nodig hebben in de index om de resultaten terug te geven. We kunnen dit dan gebruiken om een URL te genereren naar het blogpostje. Dit neemt de lading van onze database af en maakt de zoekprocessen veel sneller.

## In slotting:

In deze post zagen we hoe je een C# client moet schrijven om te interageren met onze OpenSearch voorbeeld.