private async Task CreateIndexAsync( CancellationToken ct) { var index = AzureIndexDefinition.Create(searchClient.IndexName); await indexClient.CreateOrUpdateIndexAsync(index, true, true, ct); }
static async Task CreateIndexAsync(SearchIndexClient clientIndex) { Console.WriteLine("Creating (or updating) search index"); SearchIndex index = new BookSearchIndex(SEARCH_INDEX_NAME); var result = await clientIndex.CreateOrUpdateIndexAsync(index); Console.WriteLine(result); }
private static async Task CreateIndex(string indexName, SearchIndexClient adminClient) { FieldBuilder fieldBuilder = new FieldBuilder(); var searchFields = fieldBuilder.Build(typeof(Review)); var definition = new SearchIndex(indexName, searchFields); await adminClient.CreateOrUpdateIndexAsync(definition); }
public async Task CreateIndexAsync(SearchIndex index) { try { await _searchIndexClient.CreateOrUpdateIndexAsync(index); } catch (Exception) { throw new Exception("Cognitive Search APIs -> Failed To Create Index!"); } }
private async Task <SearchClient> CreateOrUpdateIndexAsync <T>(string indexName = null) { indexName = string.IsNullOrEmpty(indexName) ? typeof(T).Name : indexName; var fieldBuilder = new FieldBuilder(); var searchFields = fieldBuilder.Build(typeof(T)); var definition = new SearchIndex(indexName, searchFields); await _searchIndexClient.CreateOrUpdateIndexAsync(definition); return(_searchIndexClient.GetSearchClient(indexName)); }
public static async Task Create(SearchIndexClient indexClient, SearchIndexName searchIndexName) { var fieldBuilder = new FieldBuilder(); IList <SearchField>?searchFields = fieldBuilder.Build(typeof(IndexableProduct)); var definition = new SearchIndex(searchIndexName.Value, searchFields); var suggester = new SearchSuggester("sg", new[] { nameof(IndexableProduct.Title), nameof(IndexableProduct.Description) }); definition.Suggesters.Add(suggester); var _ = await indexClient.CreateOrUpdateIndexAsync(definition); }
public async Task CreateIndexAsync(string indexName) { Azure.Search.Documents.Indexes.FieldBuilder fieldBuilder = new Azure.Search.Documents.Indexes.FieldBuilder(); var searchFields = fieldBuilder.Build(typeof(Hotel)); var definition = new SearchIndex(indexName, searchFields); var suggester = new SearchSuggester("sg", new[] { "HotelName", "Category", "Address/City", "Address/StateProvince" }); definition.Suggesters.Add(suggester); var index = await _indexClient.CreateOrUpdateIndexAsync(definition); }
private Task CreateIndexAsync(string indexName) { var suggester = new SearchSuggester("sg", new[] { "Name", "FacilityName" }); var definition = new SearchIndex(indexName) { Fields = new List <SearchField> { new SearchField("Id", SearchFieldDataType.String) { IsKey = true }, new SearchField("FacilityId", SearchFieldDataType.Int32) { IsFilterable = true }, new SearchField("Name", SearchFieldDataType.String) { IsSearchable = true, AnalyzerName = LexicalAnalyzerName.EnMicrosoft }, new SearchField("Description", SearchFieldDataType.String) { IsSearchable = true, AnalyzerName = LexicalAnalyzerName.EnMicrosoft }, new SearchField("FacilityName", SearchFieldDataType.String) { IsSearchable = true, AnalyzerName = LexicalAnalyzerName.EnMicrosoft }, new SearchField("FacilityDescription", SearchFieldDataType.String) { IsSearchable = true, AnalyzerName = LexicalAnalyzerName.EnMicrosoft }, new SearchField("Location", SearchFieldDataType.GeographyPoint) { IsFilterable = true }, new SearchField("RoomCount", SearchFieldDataType.Int32) { IsFilterable = true }, new SearchField("Images", SearchFieldDataType.Collection(SearchFieldDataType.String)) { IsFilterable = false } } }; definition.Suggesters.Add(suggester); return(client.CreateOrUpdateIndexAsync(definition)); }
public async Task RunAsync() { try { AnsiConsole.MarkupLine("[green]Seeding azure search...[/]"); var fields = new FieldBuilder().Build(typeof(ProductDocument)); var index = new SearchIndex(nameof(ProductDocument).ToLower(), fields); await _searchIndexClient.CreateOrUpdateIndexAsync(index); var searchClient = _searchIndexClient.GetSearchClient(nameof(ProductDocument).ToLower()); await Task.WhenAll(_seedData.Select(async product => await IndexProduct(searchClient, product))); } catch (Exception exception) { AnsiConsole.WriteException(exception, ExceptionFormats.ShortenEverything); } finally { AnsiConsole.MarkupLine("[green]Seeded azure search.[/]"); } }
public async Task <int> BuildIndexAsync(IEnumerable <SearchLocationIndex> searchLocations) { logger.LogInformation($"Starting to build index for {searchLocations.Count()}"); try { var searchIndexClient = new SearchIndexClient(azureSearchIndexConfig.EndpointUri, GetAzureKeyCredential()); var searchClient = new SearchClient(azureSearchIndexConfig.EndpointUri, azureSearchIndexConfig.LocationSearchIndex, GetAzureKeyCredential()); var fieldBuilder = new FieldBuilder(); var searchFields = fieldBuilder.Build(typeof(SearchLocationIndex)); var definition = new SearchIndex(azureSearchIndexConfig.LocationSearchIndex, searchFields); var suggester = new SearchSuggester(suggestorName, new[] { nameof(SearchLocationIndex.LocationName) }); definition.Suggesters.Add(suggester); logger.LogInformation("created search objects and creating index"); await searchIndexClient.CreateOrUpdateIndexAsync(definition).ConfigureAwait(false); logger.LogInformation("Created search index and uploading documents"); var batch = IndexDocumentsBatch.Upload(searchLocations); IndexDocumentsResult result = await searchClient.IndexDocumentsAsync(batch).ConfigureAwait(false); var failedRecords = result.Results.Where(r => !r.Succeeded); if (failedRecords.Any()) { var sampleFailedRecord = failedRecords.FirstOrDefault(); var sampleMessage = $"{failedRecords.Count()} have failed to upload to the index, sample failed record message {sampleFailedRecord.ErrorMessage}, Status = {sampleFailedRecord.Status}"; logger.LogError(sampleMessage); throw new DfcIndexUploadException("sampleMessage"); } logger.LogInformation($"Created search index and uploaded {result.Results.Count} documents"); return(result.Results.Count); } catch (Exception ex) { logger.LogError("Building index had an error", ex); throw; } }
//public static SearchIndex CreateSearchIndex(string key, string endpoint, string indexName, IList<SearchField> fields) //{ // // Create a service client // AzureKeyCredential credential = new AzureKeyCredential(key); // SearchIndexClient client = new SearchIndexClient(new Uri(endpoint), credential); // // Create the index using FieldBuilder. // SearchIndex index = new SearchIndex(indexName, fields); // return client.CreateIndex(index).Value; public static async Task <SearchIndex> CreateSearchIndexAsync(string key, string endpoint, string indexName, IList <SearchField> fields) { // Create a service client AzureKeyCredential credential = new AzureKeyCredential(key); SearchIndexClient client = new SearchIndexClient(new Uri(endpoint), credential); // Create the index using FieldBuilder. SearchIndex index = new SearchIndex(indexName, fields); try { var result = await client.CreateOrUpdateIndexAsync(index); return(result.Value); } catch (Exception ex) { Console.WriteLine("Failed to create index\n Exception message: {0}\n", ex.Message); ExitProgram("Cannot continue without a search index"); } return(null); }
static async Task CreateSearchResources(AppSettings settings) { SearchIndexClient indexClient = new SearchIndexClient(settings.SearchEndpointUri, settings.SearchKeyCredential); Console.WriteLine("Deleting search index {0} if exists...", SEARCH_ACL_INDEX_NAME); try { await indexClient.GetIndexAsync(SEARCH_ACL_INDEX_NAME); await indexClient.DeleteIndexAsync(SEARCH_ACL_INDEX_NAME); } catch (RequestFailedException) { // Index didn't exist - continue } Console.WriteLine("Creating search index {0}...", SEARCH_ACL_INDEX_NAME); await indexClient.CreateOrUpdateIndexAsync( new SearchIndex(SEARCH_ACL_INDEX_NAME, fields : new[] { new SearchField("key", SearchFieldDataType.String) { IsKey = true }, new SearchField("metadata_storage_path", SearchFieldDataType.String), new SearchField("content", SearchFieldDataType.String) })); Console.WriteLine("Creating search data source {0}...", SEARCH_ACL_DATASOURCE_NAME); SearchIndexerClient indexerClient = new SearchIndexerClient(settings.SearchEndpointUri, settings.SearchKeyCredential); await indexerClient.CreateOrUpdateDataSourceConnectionAsync( new SearchIndexerDataSourceConnection( name : SEARCH_ACL_DATASOURCE_NAME, type : SearchIndexerDataSourceType.AzureBlob, connectionString : "ResourceId=" + settings.DataLakeResourceID, container : new SearchIndexerDataContainer(name : DATA_LAKE_FILESYSTEM_NAME))); Console.WriteLine("Deleting search indexer {0} if exists...", SEARCH_ACL_INDEXER_NAME); try { await indexerClient.GetIndexerAsync(SEARCH_ACL_INDEXER_NAME); await indexerClient.DeleteIndexerAsync(SEARCH_ACL_INDEXER_NAME); } catch (RequestFailedException) { // Indexer didn't exist - continue } Console.WriteLine("Creating search indexer {0}...", SEARCH_ACL_INDEXER_NAME); await indexerClient.CreateIndexerAsync( new SearchIndexer( name : SEARCH_ACL_INDEXER_NAME, dataSourceName : SEARCH_ACL_DATASOURCE_NAME, targetIndexName : SEARCH_ACL_INDEX_NAME) { Parameters = new IndexingParameters { MaxFailedItems = -1, IndexingParametersConfiguration = new IndexingParametersConfiguration { ParsingMode = BlobIndexerParsingMode.Text } } }); }
static async Task Main(string[] args) { var serviceName = Environment.GetEnvironmentVariable("AzureSearchName"); var indexName = "models"; var apiKey = Environment.GetEnvironmentVariable("AzureSearchKey"); var serviceEndpoint = new Uri($"https://{serviceName}.search.windows.net/"); var credential = new AzureKeyCredential(apiKey); var searchIndexClient = new SearchIndexClient(serviceEndpoint, credential); var searchClient = new SearchClient(serviceEndpoint, indexName, credential); if (AnsiConsole.Capabilities.SupportLinks) { AnsiConsole.MarkupLine( $"[link=https://github.com/bovrhovn/azure-search-lang-synonym-sample/tree/main/src/ASDemo]Demo for index {indexName}[/]!"); } var index = new SearchIndex(indexName) { Fields = { new SimpleField("uniqueId", SearchFieldDataType.String) { IsKey = true, IsFilterable= true, IsSortable = true }, new SearchableField("name") { IsFilterable = true, IsSortable = true }, new SearchableField("polishName") { IsFilterable = true, IsSortable = true }, new SimpleField("updated", SearchFieldDataType.DateTimeOffset) { IsFilterable = true, IsSortable = true }, new SearchableField("keyPhrases", true) { IsFilterable = true } } }; HorizontalRule("Creating index"); AnsiConsole.WriteLine("Creating or updating index, if changed"); await searchIndexClient.CreateOrUpdateIndexAsync(index); AnsiConsole.WriteLine("Operation completed!"); var addingData = Environment.GetEnvironmentVariable("AddingData"); bool.TryParse(addingData, out bool addData); if (addData) { HorizontalRule("Adding data to the index"); AnsiConsole.WriteLine($"Adding data to the search index in {indexName}"); await AddDataAsync(searchClient); AnsiConsole.WriteLine("Completed adding data"); } HorizontalRule("Executing search queries"); AnsiConsole.WriteLine("Query #1: Using OData queries"); var queryManager = new QueryManager(); var response = await queryManager.QueryDataAsync(searchClient, "*", new SearchOptions { Filter = "name eq 'styles'", IncludeTotalCount = true }); WriteDocuments(response); HorizontalRule("Query #2: search with polish version"); response = await queryManager.QueryDataAsync(searchClient, "plik", new SearchOptions { Filter = "", OrderBy = { "updated desc" }, IncludeTotalCount = true }); WriteDocuments(response); HorizontalRule("Query #3: search keywords"); response = await queryManager.QueryDataAsync(searchClient, "EF04", new SearchOptions { OrderBy = { "updated desc" }, IncludeTotalCount = true }); WriteDocuments(response); HorizontalRule("Query #4: fuzzy search"); response = await queryManager.QueryDataAsync(searchClient, "sytles~", new SearchOptions { SearchMode = SearchMode.Any, QueryType = SearchQueryType.Full, OrderBy = { "updated desc" }, IncludeTotalCount = true }); WriteDocuments(response); HorizontalRule("Query #5: fielded search"); response = await queryManager.QueryDataAsync(searchClient, "keyPhrases:cycle OR keyPhrases:tag", new SearchOptions { SearchMode = SearchMode.Any, QueryType = SearchQueryType.Full, OrderBy = { "updated desc" }, IncludeTotalCount = true }); WriteDocuments(response); AnsiConsole.WriteLine("--> press any field to exit"); System.Console.Read(); }
// This sample shows how ETags work by performing conditional updates and deletes // on an Azure Search index. static async Task Main(string[] args) { IConfigurationBuilder builder = new ConfigurationBuilder().AddJsonFile("appsettings.json"); IConfigurationRoot configuration = builder.Build(); SearchIndexClient indexClient = CreateSearchIndexClient(configuration); Console.WriteLine("Deleting index...\n"); DeleteTestIndexIfExists(indexClient); // Every top-level resource in Azure Search has an associated ETag that keeps track of which version // of the resource you're working on. When you first create a resource such as an index, its ETag is // empty. SearchIndex index = DefineTestIndex(); Console.WriteLine( $"Test searchIndex hasn't been created yet, so its ETag should be blank. ETag: '{index.ETag}'"); // Once the resource exists in Azure Search, its ETag will be populated. Make sure to use the object // returned by the SearchIndexClient! Otherwise, you will still have the old object with the // blank ETag. //Console.WriteLine("Creating index...\n"); index = indexClient.CreateIndex(index); Console.WriteLine($"Test index created; Its ETag should be populated. ETag: '{index.ETag}'"); // ETags let you do some useful things you couldn't do otherwise. For example, by using an If-Match // condition, we can update an index using CreateOrUpdateIndexAsync() and be guaranteed that the update will only // succeed if the index already exists. index.Fields.Add(new SearchField("name", SearchFieldDataType.String) { AnalyzerName = LexicalAnalyzerName.EnMicrosoft }); index = indexClient.CreateOrUpdateIndex(index); index = await indexClient.CreateOrUpdateIndexAsync(index); Console.WriteLine( $"Test searchIndex updated; Its ETag should have changed since it was created. ETag: '{index.ETag}'"); // More importantly, ETags protect you from concurrent updates to the same resource. If another // client tries to update the resource, it will fail as long as all clients are using the right // access conditions. SearchIndex indexForClientUpdate = index; SearchIndex indexForClientUpdateFailed = indexClient.GetIndex("test"); Console.WriteLine("Simulating concurrent update. To start, both clients see the same ETag."); Console.WriteLine($"ClientUpdate ETag: '{indexForClientUpdate.ETag}' ClientUpdateFailed ETag: '{indexForClientUpdateFailed.ETag}'"); // indexForClientUpdate successfully updates the index. indexForClientUpdate.Fields.Add(new SearchField("a", SearchFieldDataType.Int32)); indexForClientUpdate = indexClient.CreateOrUpdateIndex(indexForClientUpdate); Console.WriteLine($"Test index updated by ClientUpdate; ETag: '{indexForClientUpdate.ETag}'"); // indexForClientUpdateFailed tries to update the index, but fails, thanks to the ETag check. try { indexForClientUpdateFailed.Fields.Add(new SearchField("b", SearchFieldDataType.Boolean)); indexClient.CreateOrUpdateIndex(indexForClientUpdateFailed); Console.WriteLine("Whoops; This shouldn't happen"); Environment.Exit(1); } catch (RequestFailedException e) when(e.Status == 400) { Console.WriteLine("ClientUpdateFailed failed to update the index, as expected."); } // You can also use access conditions with Delete operations. For example, you can implement an // atomic version of the DeleteTestIndexIfExists method from this sample like this: Console.WriteLine("Deleting index...\n"); indexClient.DeleteIndex("test"); // This is slightly better than using the Exists method since it makes only one round trip to // Azure Search instead of potentially two. It also avoids an extra Delete request in cases where // the resource is deleted concurrently, but this doesn't matter much since resource deletion in // Azure Search is idempotent. // And we're done! Bye! Console.WriteLine("Complete. Press any key to end application...\n"); Console.ReadKey(); }
public void CreateDataSource() { //creating index SearchIndexClient indexClient = new SearchIndexClient(Uri, keyCredential); SearchIndexerClient indexerClient = new SearchIndexerClient(Uri, keyCredential); Console.WriteLine("Creating index..."); FieldBuilder fieldBuilder = new FieldBuilder(); var searchFields = fieldBuilder.Build(typeof(InteractionDetails)); var searchIndex = new SearchIndex("interaction-sql-idx", searchFields); // If we have run the sample before, this index will be populated // We can clear the index by deleting it if it exists and creating // it again CleanupSearchIndexClientResources(indexClient, searchIndex); indexClient.CreateOrUpdateIndexAsync(searchIndex); //Creating data source Console.WriteLine("Creating data source..."); var dataSource = new SearchIndexerDataSourceConnection( "interaction-sql-ds", SearchIndexerDataSourceType.AzureSql, azureSQLConnectionStr, new SearchIndexerDataContainer("[Interaction]")); indexerClient.CreateOrUpdateDataSourceConnection(dataSource); //Creating indexer Console.WriteLine("Creating Azure SQL indexer..."); //var schedule = new IndexingSchedule(TimeSpan.FromDays(1)) //{ // StartTime = DateTimeOffset.Now //}; var parameters = new IndexingParameters() { BatchSize = 100, MaxFailedItems = 0, MaxFailedItemsPerBatch = 0 }; // Indexer declarations require a data source and search index. // Common optional properties include a schedule, parameters, and field mappings // The field mappings below are redundant due to how the Hotel class is defined, but // we included them anyway to show the syntax var indexer = new SearchIndexer("interaction-sql-idxr", dataSource.Name, searchIndex.Name) { Description = "Data indexer", Schedule = new IndexingSchedule(TimeSpan.FromMinutes(5)), Parameters = parameters, }; indexerClient.CreateOrUpdateIndexerAsync(indexer); Console.WriteLine("Running Azure SQL indexer..."); try { indexerClient.RunIndexerAsync(indexer.Name); } catch (CloudException e) when(e.Response.StatusCode == (HttpStatusCode)429) { Console.WriteLine("Failed to run indexer: {0}", e.Response.Content); } // Wait 5 seconds for indexing to complete before checking status Console.WriteLine("Waiting for indexing...\n"); System.Threading.Thread.Sleep(5000); }