How to Index GeoJSON Objects

1
curl --header "Authorization: Bearer ${ACCESS_TOKEN}" \
2
    --header "Accept: application/vnd.atlas.2025-03-12+json" \
3
    --header "Content-Type: application/json" \
4
    -X POST "https://cloud.mongodb.com/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/search/indexes" \
5
    -d '{ "collectionName": "listingsAndReviews",
6
        "database": "sample_airbnb",
7
        "name": "default",
8
        "type": "search",
9
        "definition": {
10
            "mappings": { 
11
              "dynamic": false,
12
              "fields": { 
13
                "address": { 
14
                  "type": "document",
15
                    "fields": {
16
                        "location": {
17
                        "type": "geo",
18
                        "indexShapes": true
19
                        }
20
                    }
21
                } 
22
              }
23
            }
24
        }
25
    }'

1
{
2
  "name": "default",
3
  "collectionName": "listingsAndReviews",
4
  "database": "sample_airbnb",
5
  "mappings": {
6
    "dynamic": false,
7
    "fields": {
8
      "address": {
9
        "type": "document",
10
        "fields": {
11
          "location": {
12
            "type": "geo",
13
            "indexShapes": true 
14
          }
15
        }
16
      }
17
    }
18
  }
19
}

1
{
2
  "mappings": {
3
    "dynamic": false,
4
    "fields": {
5
      "address": {
6
        "type": "document",
7
        "fields": {
8
          "location": {
9
            "type": "geo",
10
            "indexShapes": true
11
          }
12
        }
13
      }
14
    }
15
  }
16
}

1
db.listingsAndReviews.createSearchIndex(
2
    "default",
3
    {
4
    "mappings": { 
5
        "dynamic": false,
6
        "fields": {
7
            "address": {
8
                "fields" : {
9
                    "location": {
10
                        "type": "geo",
11
                        "indexShapes": true
12
                    } 
13
                }
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_airbnb", "listingsAndReviews");
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 geo field. */
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
                            "address": {
35
                                "type": "document",
36
                                "fields": {
37
                                    "location": {
38
                                        "type": "geo",
39
                                        "indexShapes": true
40
                                    }
41
                                }
42
                            }
43
                        }
44
                    }
45
                }
46
            }]
47
        }),
48
        "listingsAndReviews"
49
    );
50
    bson_init_from_json (&cmd, cmd_str, -1, &error);
51
    bson_free (cmd_str);
52
53
    if (mongoc_collection_command_simple (collection, &cmd, NULL, NULL, &error)) {
54
        printf ("Index created!\n");
55
    } else {
56
        fprintf (stderr, "Failed to create search index: %s", error.message);
57
    }
58
59
    /* Clean up. */
60
    bson_destroy (&cmd);
61
    mongoc_collection_destroy (collection);
62
    mongoc_client_destroy(client);
63
    mongoc_cleanup();
64
65
    return 0;
66
}

1
using MongoDB.Bson;
2
using MongoDB.Driver;
3
4
// Replace the connection string with your MongoDB deployment's connection string
5
var uri = "<connection-string>";
6
7
var client = new MongoClient(uri);
8
9
var db = client.GetDatabase("sample_airbnb");
10
var collection = db.GetCollection<BsonDocument>("listingsAndReviews");
11
12
// Create the MongoDB Search index definition for the geo field
13
var index =  new CreateSearchIndexModel(
14
  "default", new BsonDocument
15
  {
16
    { "mappings", new BsonDocument
17
      {
18
        { "dynamic", false },
19
        { "fields", new BsonDocument
20
          {
21
            { "address", new BsonDocument
22
              {
23
                { "type", "document" },
24
                { "fields", new BsonDocument
25
                  {
26
                    { "location", new BsonDocument
27
                      {
28
                        { "type", "geo" },
29
                        { "indexShapes", true }
30
                      }
31
                    }
32
                  }
33
                }
34
              }
35
            }
36
          }
37
        }
38
      }
39
    }
40
  });
41
42
var result = collection.SearchIndexes.CreateOne(index);
43
Console.WriteLine($"New index name: {result}");

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_airbnb"];
21
    auto collection = db["listingsAndReviews"];
22
    auto siv = collection.search_indexes();
23
24
    // Create the MongoDB Search index definition for the geo field
25
    auto name = "default";
26
    auto definition = make_document(
27
        kvp("mappings", make_document(
28
            kvp("dynamic", false),
29
            kvp("fields", make_document(
30
                kvp("address", make_document(
31
                    kvp("type", "document"),
32
                    kvp("fields", make_document(
33
                        kvp("location", make_document(
34
                            kvp("type", "geo"),
35
                            kvp("indexShapes", true)
36
                        ))
37
                    ))
38
                ))
39
            ))
40
        ))
41
    );
42
    auto model = mongocxx::search_index_model(name, definition.view());
43
44
    try {
45
        // Execute the command to create the index
46
        auto result = siv.create_one(model);
47
        std::cout << "New index name: " << result << std::endl;
48
    } catch (const std::exception& e) {
49
        std::cerr << "Error creating Atlas Search index: " << e.what() << std::endl;
50
    }
51
    
52
}

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
	uri := "mongodb+srv://<username>:<password>@<cluster-url>/myDatabase?retryWrites=true&w=majority"
16
	client, err := mongo.Connect(options.Client().
17
		ApplyURI(uri))
18
	if err != nil {
19
		panic(err)
20
	}
21
22
	defer func() {
23
		if err := client.Disconnect(context.TODO()); err != nil {
24
			panic(err)
25
		}
26
	}()
27
28
	coll := client.Database("sample_airbnb").Collection("listingsAndReviews")
29
	const indexName = "default"
30
	opts := options.SearchIndexes().SetName(indexName).SetType("search")
31
32
	// Define the MongoDB Search index for the geo field
33
	searchIndexModel := mongo.SearchIndexModel{
34
		Definition: bson.D{
35
			{"mappings", bson.D{
36
				{"dynamic", false},
37
				{"fields", bson.D{
38
					{"address", bson.D{
39
						{"type", "document"},
40
						{"fields", bson.D{
41
							{"location", bson.D{
42
								{"type", "geo"},
43
								{"indexShapes", true},
44
							}},
45
						}},
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
public class CreateIndex {
5
    public static void main(String[] args) {
6
        // Replace the connection string with your MongoDB deployment's connection string
7
        String connectionString = "<connection-string>";
8
        
9
        try (MongoClient mongoClient = MongoClients.create(connectionString)) {
10
            MongoDatabase database = mongoClient.getDatabase("sample_airbnb");
11
            MongoCollection<Document> collection = database.getCollection("listingsAndReviews");
12
            String indexName = "default";
13
14
            // Create the MongoDB Search index definition for the geo field
15
            Document searchIdx = new Document(
16
                    "mappings",
17
                    new Document("dynamic", false)
18
                            .append("fields",
19
                                    new Document("address",
20
                                            new Document("type", "document")
21
                                                    .append("fields", new Document("location",
22
                                                            new Document("type", "geo")
23
                                                                    .append("indexShapes", true)))))
24
            );
25
            collection.createSearchIndex(indexName, searchIdx);
26
            System.out.println("New index name: " + indexName);
27
        } catch (Exception e) {
28
            System.err.println("Error creating Atlas Search index: " + e.getMessage());
29
        }
30
    }
31
}

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_airbnb");
11
    const collection = database.collection("listingsAndReviews");
12
13
    // Create the MongoDB Search index definition for the geo field
14
    const index = {
15
        name: "default",
16
        definition: {
17
            "mappings": {
18
                "dynamic": false,
19
                "fields": {
20
                    "address": {
21
                        "type": "document",
22
                        "fields": {
23
                            "location": {
24
                                "type": "geo",
25
                                "indexShapes": true
26
                            }
27
                        }
28
                    }
29
                }
30
            }
31
        }
32
    }
33
34
    // Create the index
35
    const result = await collection.createSearchIndex(index);
36
    console.log("New index name: " + result);
37
  } finally {
38
    await client.close();
39
  }
40
}
41
42
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_airbnb"]
9
collection = database["listingsAndReviews"]
10
11
# Create the MongoDB Search index definition for the geo field
12
search_index_model = SearchIndexModel(
13
    definition={
14
        "mappings": {
15
            "dynamic": false,
16
            "fields": {
17
                "address": {
18
                    "type": "document",
19
                    "fields": {
20
                        "location": {
21
                            "type": "geo",
22
                            "indexShapes": true
23
                        }
24
                    }
25
                }
26
            }
27
        },
28
    },
29
    name="default",
30
)
31
32
# Create the index
33
result = collection.create_search_index(model=search_index_model)
34
print(f"New index name: {result}")

1
{
2
  "name": "default",
3
  "collectionName": "listingsAndReviews",
4
  "database": "sample_airbnb",
5
  "mappings": {
6
    "dynamic": false,
7
    "fields": {
8
      "address": {
9
        "type": "document",
10
        "fields": {
11
          "location": {
12
            "type": "geo",
13
            "indexShapes": true 
14
          }
15
        }
16
      }
17
    }
18
  }
19
}