Manage Atlas Search Indexes

#include <mongoc/mongoc.h>
#include <stdlib.h>
int main (void)
{
    mongoc_client_t *client = NULL;
    mongoc_collection_t *collection = NULL;
    mongoc_database_t *database = NULL;
    bson_error_t error;
    bson_t cmd = BSON_INITIALIZER;
    bool ok = true;
    mongoc_init();
    // Connect to your Atlas deployment
    client = mongoc_client_new("<connectionString>");
    if (!client) {
        fprintf(stderr, "Failed to create a MongoDB client.\n");
        ok = false;
        goto cleanup;
    }
    // Access your database and collection
    database = mongoc_client_get_database(client, "<databaseName>");
    collection = mongoc_database_get_collection(database, "<collectionName>");
    // Specify the command and the new index
    const char *cmd_str = BSON_STR({
        "createSearchIndexes" : "<collectionName>",
        "indexes" : [ {
            "name" : "<indexName>",
            "definition" : {
                "analyzer": "<indexAnalyzer>", 
                "searchAnalyzer": "<queryAnalyzer>", 
                "mappings": { 
                    "dynamic": <boolean>, 
                    "fields": { <fieldDefinition> } 
                },
                "numPartitions": <integer>,
                "analyzers": [ <customAnalyzer> ],
                "storedSource": <boolean> | {
                    <storedSourceDefinition>
                },
                "synonyms": [
                    {
                        <synonymMappingDefinition>
                    }
                ] 
            }
	    } ]
	});
    // Convert your command to BSON
    if (!bson_init_from_json(&cmd, cmd_str, -1, &error)) {
        fprintf(stderr, "Failed to parse command: %s\n", error.message);
        ok = false;
        goto cleanup;
    }
    // Create the Atlas search index by running the command
    if (!mongoc_collection_command_simple (collection, &cmd, NULL, NULL, &error)) {
        fprintf(stderr, "Failed to run createSearchIndexes: %s\n", error.message);
        ok = false;
        goto cleanup;
    }
    printf ("Index created!\n");
cleanup:
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_database_destroy (database);
   bson_destroy (&cmd);
   mongoc_cleanup ();
   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}

#include <mongoc/mongoc.h>
#include <stdlib.h>
int main (void)
{
    mongoc_client_t *client = NULL;
    mongoc_collection_t *collection = NULL;
    mongoc_database_t *database = NULL;
    bson_error_t error;
    bson_t cmd = BSON_INITIALIZER;
    bool ok = true;
    mongoc_init();
    // Connect to your Atlas deployment
    client = mongoc_client_new("<connectionString>");
    if (!client) {
        fprintf(stderr, "Failed to create a MongoDB client.\n");
        ok = false;
        goto cleanup;
    }
    // Access your database and collection
    database = mongoc_client_get_database(client, "<databaseName>");
    collection = mongoc_database_get_collection(database, "<collectionName>");
    // Specify the command and the new indexes
    const char *cmd_str = BSON_STR({
        "createSearchIndexes" : "<collectionName>",
        "indexes" : [{
            // Add your search index definition fields here
            "name" : "<firstIndexName>"
        },
        {
            // Add your search index definition fields here
            "name" : "<secondIndexName>"
        }]
    });
    // Convert your command to BSON
    if (!bson_init_from_json(&cmd, cmd_str, -1, &error)) {
        fprintf(stderr, "Failed to parse command: %s\n", error.message);
        ok = false;
        goto cleanup;
    }
    // Create the Atlas search indexes by running the command
    if (!mongoc_collection_command_simple (collection, &cmd, NULL, NULL, &error)) {
        fprintf(stderr, "Failed to run createSearchIndexes: %s\n", error.message);
        ok = false;
        goto cleanup;
    }
    printf ("Indexes created!\n");
cleanup:
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
   mongoc_database_destroy (database);
   bson_destroy (&cmd);
   mongoc_cleanup ();
   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}

#include <bsoncxx/builder/basic/document.hpp>
#include <bsoncxx/builder/basic/kvp.hpp>
#include <mongocxx/client.hpp>
#include <mongocxx/instance.hpp>
#include <mongocxx/search_index_view.hpp>
using bsoncxx::builder::basic::kvp;
using bsoncxx::builder::basic::make_document;
using namespace mongocxx;
int main()
{ 
    try
    {
        // Connect to your Atlas deployment
        mongocxx::instance instance{};
        mongocxx::uri uri("<connectionString>");
        mongocxx::client client(uri); 
        // Access your database and collection
        auto db = client["<databaseName>"];
        auto collection = db["<collectionName>"];
        // Create an index model with your index name and definition
        auto siv = collection.search_indexes();
        auto name = "<indexName>";
        auto definition = make_document(kvp("mappings", make_document(kvp("dynamic", true))));
        auto model = search_index_model(name, definition.view());
        // Create the search index
        siv.create_one(model);
        std::cout << "Index created!" << std::endl;
    }
    catch (const std::exception& e) 
    {
        std::cout<< "Exception: " << e.what() << std::endl;
    }
    return 0;
}

#include <bsoncxx/builder/basic/document.hpp>
#include <bsoncxx/builder/basic/kvp.hpp>
#include <mongocxx/client.hpp>
#include <mongocxx/instance.hpp>
#include <mongocxx/search_index_view.hpp>
using bsoncxx::builder::basic::kvp;
using bsoncxx::builder::basic::make_document;
using namespace mongocxx;
int main()
{ 
    try
    {
        // Connect to your Atlas deployment
        mongocxx::instance instance{};
        mongocxx::uri uri("<connectionString>");
        mongocxx::client client(uri); 
        // Access your database and collection
        auto db = client["<databaseName>"];
        auto collection = db["<collectionName>"];
        // Create index models and add them to a vector
        auto siv = collection.search_indexes();
        std::vector<search_index_model> models;
        auto name1 = "<firstIndexName>";
        auto definition1 = make_document(/* Add search index definition fields here */);
        auto model1 = search_index_model(name1, definition1.view());
        models.push_back(model1);
        
        auto name2 = "<secondIndexName>";
        auto definition2 = make_document(/* Add search index definition fields here */);
        auto model2 = search_index_model(name2, definition2.view());
        models.push_back(model2);
        // Create the search indexes
        siv.create_many(models);
        std::cout << "Indexes created!" << std::endl;
    }
    catch (const std::exception& e) 
    {
        std::cout<< "Exception: " << e.what() << std::endl;
    }
    return 0;
}

1
using MongoDB.Bson;
2
using MongoDB.Driver;
3
4
// connect to your Atlas deployment
5
var uri = "<connection-string>";
6
7
var client = new MongoClient(uri);
8
9
var db = client.GetDatabase("<databaseName>");
10
var collection = db.GetCollection<BsonDocument>("<collectionName>");
11
12
// define your Atlas Search index
13
var index = new BsonDocument
14
{
15
  { "mappings", new BsonDocument
16
    {
17
      { "dynamic", true }
18
    }
19
  }
20
};
21
22
var result = collection.SearchIndexes.CreateOne(index, "<indexName>");
23
Console.WriteLine(result);

1
using MongoDB.Bson;
2
using MongoDB.Driver;
3
4
// connect to your Atlas deployment
5
var uri = "<connection-string>";
6
7
var client = new MongoClient(uri);
8
9
var db = client.GetDatabase("<databaseName>");
10
var collection = db.GetCollection<BsonDocument>("<collectionName>");
11
12
// define your Atlas Search indexes
13
var indexes = new List<CreateSearchIndexModel>
14
{
15
    new CreateSearchIndexModel(
16
        "<firstIndexName>",
17
        new BsonDocument
18
        {
19
            <IndexDefinition>// search index definition fields
20
        }
21
    ),
22
    ...
23
    new CreateSearchIndexModel(
24
        "<lastIndexName>",
25
        new BsonDocument
26
        {
27
            <IndexDefinition> // search index definition fields
28
        }
29
    )
30
};
31
32
var result = collection.SearchIndexes.CreateMany(indexes);

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
public class CreateIndex {
    public static void main(String[] args) {
        // connect to your Atlas cluster
        String uri = "<connection-string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            // set namespace
            MongoDatabase database = mongoClient.getDatabase("<databaseName>");
            MongoCollection<Document> collection = database.getCollection("<collectionName>");
            Document index = new Document("mappings",
                    new Document("dynamic", true));
            collection.createSearchIndex("<index-name>", index);
        }
    }
}

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.SearchIndexModel;
import org.bson.Document;
import java.util.Arrays;
public class CreateIndex {
    public static void main(String[] args) {
        // connect to your Atlas cluster
        String uri = "<connection-string>";
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            // set namespace
            MongoDatabase database = mongoClient.getDatabase("<databaseName>");
            MongoCollection<Document> collection = database.getCollection("<collectionName>");
            SearchIndexModel indexOne = new SearchIndexModel("<first-index-name>",
                    new Document( 
                        // search index definition fields
                    ));
            SearchIndexModel indexTwo = new SearchIndexModel("<second-index-name>",
                    new Document( 
                        // search index definition fields
                    ));
            collection.createSearchIndexes(Arrays.asList(indexOne, indexTwo));
        }
    }
}