Define Synonym Mappings in Your MongoDB Search Index

1
{
2
  "name": "default",
3
  "collectionName": "movies",
4
  "database": "sample_mflix",
5
  "mappings": {
6
    "dynamic": false,
7
    "fields": {
8
      "plot": {
9
        "type": "string",
10
        "analyzer": "lucene.english"
11
      }
12
    }
13
  },
14
  "synonyms": [
15
    {
16
      "analyzer": "lucene.english",
17
      "name": "my_synonyms",
18
      "source": {
19
        "collection": "synonymous_terms"
20
      }
21
    }
22
  ]
23
}

1
{
2
  "name": "default",
3
  "collectionName": "movies",
4
  "database": "sample_mflix",
5
  "mappings": {
6
    "dynamic": true
7
  },
8
  "synonyms": [
9
    {
10
      "analyzer": "lucene.standard",
11
      "name": "my_synonyms",
12
      "source": {
13
        "collection": "synonymous_terms"
14
      }
15
    }
16
  ]
17
}

1
#include <mongoc/mongoc.h>
2
#include <stdio.h>
3
4
int main(int argc, char *argv[]) {
5
    mongoc_client_t *client;
6
    mongoc_collection_t *collection;
7
    bson_error_t error;
8
    bson_t cmd;
9
    bson_t *index_definition;
10
    bool success;
11
12
    /* Initialize the MongoDB C Driver. */
13
    mongoc_init();
14
15
    /* Connect to your MongoDB deployment. */
16
    client = mongoc_client_new("<connection-string>");
17
    collection = mongoc_client_get_collection (client, "sample_mflix", "movies");
18
19
    if (!client) {
20
        fprintf(stderr, "Failed to create client.\n");
21
        return 1;
22
    }
23
24
    /* Create the MongoDB Search index definition for the plot field with synonyms. */
25
    char *cmd_str = bson_strdup_printf (
26
        BSON_STR ({
27
            "createSearchIndexes": "%s",
28
            "indexes": [{
29
                "name": "default",
30
                "definition": {
31
                    "mappings": {
32
                        "dynamic": false,
33
                        "fields": {
34
                            "plot": {
35
                                "type": "string",
36
                                "analyzer": "lucene.english"
37
                            }
38
                        }
39
                    },
40
                    "synonyms": [
41
                        {
42
                            "analyzer": "lucene.english",
43
                            "name": "my_synonyms",
44
                            "source": {
45
                                "collection": "synonymous_terms"
46
                            }
47
                        }
48
                    ]
49
                }
50
            }]
51
        }),
52
        "movies"
53
    );
54
    bson_init_from_json (&cmd, cmd_str, -1, &error);
55
    bson_free (cmd_str);
56
57
    if (mongoc_collection_command_simple (collection, &cmd, NULL, NULL, &error)) {
58
        printf ("Index created!\n");
59
    } else {
60
        fprintf (stderr, "Failed to create search index: %s", error.message);
61
    }
62
63
    /* Clean up. */
64
    bson_destroy (&cmd);
65
    mongoc_collection_destroy (collection);
66
    mongoc_client_destroy(client);
67
    mongoc_cleanup();
68
69
    return 0;
70
}

1
#include <mongoc/mongoc.h>
2
#include <stdio.h>
3
4
int main(int argc, char *argv[]) {
5
    mongoc_client_t *client;
6
    mongoc_collection_t *collection;
7
    bson_error_t error;
8
    bson_t cmd;
9
    bson_t *index_definition;
10
    bool success;
11
12
    /* Initialize the MongoDB C Driver. */
13
    mongoc_init();
14
15
    /* Connect to your MongoDB deployment. */
16
    client = mongoc_client_new("<connection-string>");
17
    collection = mongoc_client_get_collection (client, "sample_mflix", "movies");
18
19
    if (!client) {
20
        fprintf(stderr, "Failed to create client.\n");
21
        return 1;
22
    }
23
24
    /* Create the MongoDB Search index definition for a dynamic index with synonyms. */
25
    char *cmd_str = bson_strdup_printf (
26
        BSON_STR ({
27
            "createSearchIndexes": "%s",
28
            "indexes": [{
29
                "name": "default",
30
                "definition": {
31
                    "mappings": {
32
                        "dynamic": true
33
                    },
34
                    "synonyms": [
35
                        {
36
                            "analyzer": "lucene.standard",
37
                            "name": "my_synonyms",
38
                            "source": {
39
                                "collection": "synonymous_terms"
40
                            }
41
                        }
42
                    ]
43
                }
44
            }]
45
        }),
46
        "movies"
47
    );
48
    bson_init_from_json (&cmd, cmd_str, -1, &error);
49
    bson_free (cmd_str);
50
51
    if (mongoc_collection_command_simple (collection, &cmd, NULL, NULL, &error)) {
52
        printf ("Index created!\n");
53
    } else {
54
        fprintf (stderr, "Failed to create search index: %s", error.message);
55
    }
56
57
    /* Clean up. */
58
    bson_destroy (&cmd);
59
    mongoc_collection_destroy (collection);
60
    mongoc_client_destroy(client);
61
    mongoc_cleanup();
62
63
    return 0;
64
}

1
#include <iostream>
2
3
#include <bsoncxx/builder/basic/document.hpp>
4
#include <bsoncxx/json.hpp>
5
#include <mongocxx/client.hpp>
6
#include <mongocxx/instance.hpp>
7
#include <mongocxx/uri.hpp>
8
9
using bsoncxx::builder::basic::kvp;
10
using bsoncxx::builder::basic::make_document;
11
12
int main() {
13
    // Initialize the MongoDB C++ driver
14
    mongocxx::instance instance{};
15
16
    // Connect to your MongoDB deployment
17
    mongocxx::uri uri("<connection-string>");
18
    mongocxx::client client(uri);
19
20
    auto db = client["sample_mflix"];
21
    auto collection = db["movies"];
22
    auto siv = collection.search_indexes();
23
24
    // Create the MongoDB Search index definition for the plot field with synonyms
25
    auto name = "default";
26
    auto synonyms = bsoncxx::builder::basic::make_array(
27
        make_document(
28
            kvp("analyzer", "lucene.english"),
29
            kvp("name", "my_synonyms"),
30
            kvp("source", make_document(
31
                kvp("collection", "synonymous_terms")
32
            ))
33
        )
34
    );
35
36
    auto definition = make_document(
37
        kvp("mappings", make_document(
38
            kvp("dynamic", false),
39
            kvp("fields", make_document(
40
                kvp("plot", make_document(
41
                    kvp("type", "string"),
42
                    kvp("analyzer", "lucene.english")
43
                ))
44
            ))
45
        )),
46
        kvp("synonyms", synonyms)
47
    );
48
    auto model = mongocxx::search_index_model(name, definition.view());
49
50
    try {
51
        // Execute the command to create the index
52
        auto result = siv.create_one(model);
53
        std::cout << "New index name: " << result << std::endl;
54
    } catch (const std::exception& e) {
55
        std::cerr << "Error creating Atlas Search index: " << e.what() << std::endl;
56
    }
57
58
}

1
#include <iostream>
2
3
#include <bsoncxx/builder/basic/document.hpp>
4
#include <bsoncxx/json.hpp>
5
#include <mongocxx/client.hpp>
6
#include <mongocxx/instance.hpp>
7
#include <mongocxx/uri.hpp>
8
9
using bsoncxx::builder::basic::kvp;
10
using bsoncxx::builder::basic::make_document;
11
12
int main() {
13
    // Initialize the MongoDB C++ driver
14
    mongocxx::instance instance{};
15
16
    // Connect to your MongoDB deployment
17
    mongocxx::uri uri("<connection-string>");
18
    mongocxx::client client(uri);
19
20
    auto db = client["sample_mflix"];
21
    auto collection = db["movies"];
22
    auto siv = collection.search_indexes();
23
24
    // Define the synonym mapping for the lucene.standard analyzer
25
    auto name = "default";
26
    auto synonyms = bsoncxx::builder::basic::make_array(
27
        make_document(
28
            kvp("analyzer", "lucene.standard"),
29
            kvp("name", "my_synonyms"),
30
            kvp("source", make_document(
31
                kvp("collection", "synonymous_terms")
32
            ))
33
        )
34
    );
35
36
    // Create the MongoDB Search index definition
37
    auto definition = make_document(
38
        kvp("mappings", make_document(
39
            kvp("dynamic", true))
40
        ),
41
        kvp("synonyms", synonyms)
42
    );
43
    auto model = mongocxx::search_index_model(name, definition.view());
44
45
    try {
46
        // Execute the command to create the index
47
        auto result = siv.create_one(model);
48
        std::cout << "New index name: " << result << std::endl;
49
    } catch (const std::exception& e) {
50
        std::cerr << "Error creating Atlas Search index: " << e.what() << std::endl;
51
    }
52
53
}

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
	"log"
7
8
	"go.mongodb.org/mongo-driver/v2/bson"
9
	"go.mongodb.org/mongo-driver/v2/mongo"
10
	"go.mongodb.org/mongo-driver/v2/mongo/options"
11
)
12
13
func main() {
14
	ctx := context.Background()
15
16
	// Replace the placeholder with your MongoDB deployment's connection string
17
	uri := "<connection-string>"
18
	client, err := mongo.Connect(options.Client().
19
		ApplyURI(uri))
20
	if err != nil {
21
		panic(err)
22
	}
23
24
	defer func() {
25
		if err := client.Disconnect(context.TODO()); err != nil {
26
			panic(err)
27
		}
28
	}()
29
30
	coll := client.Database("sample_mflix").Collection("movies")
31
	const indexName = "default"
32
	opts := options.SearchIndexes().SetName(indexName).SetType("search")
33
34
	// Create the search index definition
35
36
	searchIndexModel := mongo.SearchIndexModel{
37
		Definition: bson.M{
38
			"mappings": bson.M{
39
				"dynamic": false,
40
				"fields": bson.M{
41
					"plot": bson.M{
42
						"type":     "string",
43
						"analyzer": "lucene.english",
44
					},
45
				},
46
			},
47
			"synonyms": []bson.M{
48
				{
49
					"analyzer": "lucene.english",
50
					"name":     "my_synonyms",
51
					"source": bson.M{
52
						"collection": "synonymous_terms",
53
					},
54
				},
55
			},
56
		},
57
		Options: opts,
58
	}
59
60
	// Create the index
61
	searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, searchIndexModel)
62
	if err != nil {
63
		log.Fatalf("Failed to create the Atlas Search index: %v", err)
64
	}
65
66
	fmt.Println("Name of index created: " + searchIndexName)
67
}

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
	"log"
7
8
	"go.mongodb.org/mongo-driver/v2/bson"
9
	"go.mongodb.org/mongo-driver/v2/mongo"
10
	"go.mongodb.org/mongo-driver/v2/mongo/options"
11
)
12
13
func main() {
14
	ctx := context.Background()
15
16
	// Replace the placeholder with your MongoDB deployment's connection string
17
	uri := "<connection-string>"
18
	client, err := mongo.Connect(options.Client().
19
		ApplyURI(uri))
20
	if err != nil {
21
		panic(err)
22
	}
23
24
	defer func() {
25
		if err := client.Disconnect(context.TODO()); err != nil {
26
			panic(err)
27
		}
28
	}()
29
30
	coll := client.Database("sample_mflix").Collection("movies")
31
	const indexName = "default"
32
	opts := options.SearchIndexes().SetName(indexName).SetType("search")
33
34
	// Create the search index definition
35
	searchIndexModel := mongo.SearchIndexModel{
36
		Definition: bson.M{
37
			"mappings": bson.M{
38
				"dynamic": true,
39
			},
40
			"synonyms": []bson.M{
41
				{
42
					"analyzer": "lucene.standard",
43
					"name":     "my_synonyms",
44
					"source": bson.M{
45
						"collection": "synonymous_terms",
46
					},
47
				},
48
			},
49
		},
50
		Options: opts,
51
	}
52
53
	// Create the index
54
	searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, searchIndexModel)
55
	if err != nil {
56
		log.Fatalf("Failed to create the Atlas Search index: %v", err)
57
	}
58
59
	fmt.Println("Name of index created: " + searchIndexName)
60
}

1
import com.mongodb.client.*;
2
import org.bson.Document;
3
4
import java.util.List;
5
6
public class CreateStaticIndex {
7
    public static void main(String[] args) {
8
        // Replace the placeholder with your MongoDB deployment's connection string
9
        String connectionString = "<connection-string>";
10
11
        try (MongoClient mongoClient = MongoClients.create(connectionString)) {
12
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
13
            MongoCollection<Document> collection = database.getCollection("movies");
14
            String indexName = "default";
15
16
            // Define the synonym mapping for the lucene.english analyzer
17
            List<Document> synonymsList = List.of(
18
                    new Document("analyzer", "lucene.english")
19
                            .append("name", "my_synonyms")
20
                            .append("source", new Document("collection", "synonymous_terms"))
21
            );
22
23
            // Create the MongoDB Search index definition for the plot field with synonyms
24
            Document searchIdx = new Document(
25
                    "mappings",
26
                    new Document("dynamic", false)
27
                            .append("fields",
28
                                    new Document("plot",
29
                                            new Document("type", "string")
30
                                                    .append("analyzer", "lucene.english")
31
                                    )
32
                            )
33
            ).append("synonyms", synonymsList);
34
35
            // Create the index by using the Java Sync Driver
36
            collection.createSearchIndex(indexName, searchIdx);
37
            System.out.println("New index name: " + indexName);
38
        } catch (Exception e) {
39
            System.err.println("Error creating Atlas Search index: " + e.getMessage());
40
        }
41
    }
42
}

1
import com.mongodb.client.*;
2
import org.bson.Document;
3
4
import java.util.List;
5
6
public class CreateDynamicIndex {
7
    public static void main(String[] args) {
8
        // Replace the placeholder with your MongoDB deployment's connection string
9
        String connectionString = "<connection-string>";
10
11
        try (MongoClient mongoClient = MongoClients.create(connectionString)) {
12
            MongoDatabase database = mongoClient.getDatabase("sample_mflix");
13
            MongoCollection<Document> collection = database.getCollection("movies");
14
            String indexName = "default";
15
16
            // Define the synonym mapping for the lucene.standard analyzer
17
            List<Document> synonymsList = List.of(
18
                    new Document("analyzer", "lucene.standard")
19
                            .append("name", "my_synonyms")
20
                            .append("source", new Document("collection", "synonymous_terms"))
21
            );
22
23
            // Create the MongoDB Search index definition
24
            Document searchIdx = new Document(
25
                    "mappings",
26
                    new Document("dynamic", true)
27
            ).append("synonyms", synonymsList);
28
29
            // Create the index by using the Java Sync Driver
30
            collection.createSearchIndex(indexName, searchIdx);
31
            System.out.println("New index name: " + indexName);
32
        } catch (Exception e) {
33
            System.err.println("Error creating Atlas Search index: " + e.getMessage());
34
        }
35
    }
36
}

1
const { MongoClient } = require("mongodb");
2
3
// Replace the connection string with your MongoDB deployment's connection string
4
const uri =  "<connection-string>";
5
6
const client = new MongoClient(uri);
7
8
async function run() {
9
  try {
10
    const database = client.db("sample_mflix");
11
    const collection = database.collection("movies");
12
13
    // Create the MongoDB Search index definition for the plot field with synonyms
14
    const index = {
15
        name: "default",
16
        definition: {
17
            "mappings": {
18
                "dynamic": false,
19
                "fields": {
20
                    "plot": {
21
                        "type": "string",
22
                        "analyzer": "lucene.english"
23
                    }
24
                }
25
            },
26
            "synonyms": [
27
                {
28
                    "analyzer": "lucene.english",
29
                    "name": "my_synonyms",
30
                    "source": {
31
                        "collection": "synonymous_terms"
32
                    }
33
                }
34
            ]
35
        }
36
    }
37
38
    // Create the index
39
    const result = await collection.createSearchIndex(index);
40
    console.log("New index name: " + result);
41
  } finally {
42
    await client.close();
43
  }
44
}
45
46
run().catch(console.dir);

1
const { MongoClient } = require("mongodb");
2
3
// Replace the connection string with your MongoDB deployment's connection string
4
const uri =  "<connection-string>";
5
6
const client = new MongoClient(uri);
7
8
async function run() {
9
  try {
10
    const database = client.db("sample_mflix");
11
    const collection = database.collection("movies");
12
13
    // Create the MongoDB Search index definition with dynamic mapping and synonyms
14
    const index = {
15
        name: "default",
16
        definition: {
17
            "mappings": {
18
                "dynamic": true
19
            },
20
            "synonyms": [
21
                {
22
                    "analyzer": "lucene.standard",
23
                    "name": "my_synonyms",
24
                    "source": {
25
                        "collection": "synonymous_terms"
26
                    }
27
                }
28
            ]
29
        }
30
    }
31
32
    // Create the index
33
    const result = await collection.createSearchIndex(index);
34
    console.log("New index name: " + result);
35
  } finally {
36
    await client.close();
37
  }
38
}
39
40
run().catch(console.dir);

1
from pymongo import MongoClient
2
from pymongo.operations import SearchIndexModel
3
4
# Connect to your Atlas deployment
5
uri = "<connection-string>"
6
client = MongoClient(uri)
7
8
database = client["sample_mflix"]
9
collection = database["movies"]
10
11
# Create the MongoDB Search index definition for the plot field with synonyms
12
search_index_model = SearchIndexModel(
13
    definition={
14
        "mappings": {
15
            "dynamic": False,
16
            "fields": {
17
                "plot": {
18
                    "type": "string",
19
                    "analyzer": "lucene.english"
20
                }
21
            }
22
        },
23
        "synonyms": [
24
            {
25
                "analyzer": "lucene.english",
26
                "name": "my_synonyms",
27
                "source": {
28
                    "collection": "synonymous_terms"
29
                }
30
            }
31
        ]
32
    },
33
    name="default",
34
)
35
36
# Create the index
37
result = collection.create_search_index(model=search_index_model)
38
print(f"New index name: {result}")

1
from pymongo import MongoClient
2
from pymongo.operations import SearchIndexModel
3
4
# Connect to your Atlas deployment
5
uri = "<connection-string>"
6
client = MongoClient(uri)
7
8
database = client["sample_mflix"]
9
collection = database["movies"]
10
11
# Create the MongoDB Search index definition
12
search_index_model = SearchIndexModel(
13
    definition={
14
        "mappings": {
15
            "dynamic": True,
16
        },
17
        "synonyms": [
18
            {
19
                "analyzer": "lucene.standard",
20
                "name": "my_synonyms",
21
                "source": {
22
                    "collection": "synonymous_terms"
23
                }
24
            }
25
        ]
26
    },
27
    name="default",
28
)
29
30
# Create the index
31
result = collection.create_search_index(model=search_index_model)
32
print(f"New index name: {result}")

1
{
2
  "name": "default",
3
  "collectionName": "movies",
4
  "database": "sample_mflix",
5
  "mappings": {
6
    "dynamic": false,
7
    "fields": {
8
      "plot": {
9
        "type": "string",
10
        "analyzer": "lucene.english"
11
      }
12
    }
13
  },
14
  "synonyms": [
15
    {
16
      "analyzer": "lucene.english",
17
      "name": "my_synonyms",
18
      "source": {
19
        "collection": "synonymous_terms"
20
      }
21
    }
22
  ]
23
}

1
{
2
  "name": "default",
3
  "collectionName": "movies",
4
  "database": "sample_mflix",
5
  "mappings": {
6
    "dynamic": true
7
  },
8
  "synonyms": [
9
    {
10
      "analyzer": "lucene.standard",
11
      "name": "my_synonyms",
12
      "source": {
13
        "collection": "synonymous_terms"
14
      }
15
    }
16
  ]
17
}