geoWithin Operator

{
  "$search": {
    "geoWithin": {
      "path": "address.location",
      "box": {
        "bottomLeft": {
          "type": "Point",
          "coordinates": [112.467, -55.050]
        },
        "topRight": {
          "type": "Point",
          "coordinates": [168.000, -9.133]
        }
      }
    }
  }
}

1
db.listingsAndReviews.aggregate([
2
  {
3
    "$search": {
4
      "geoWithin": {
5
        "path": "address.location",
6
        "box": {
7
          "bottomLeft": {
8
            "type": "Point",
9
            "coordinates": [112.467, -55.050]
10
          },
11
          "topRight": {
12
            "type": "Point",
13
            "coordinates": [168.000, -9.133]
14
          }
15
        }
16
      }
17
    }
18
  },
19
  {
20
    "$limit": 3
21
  },
22
  {
23
    "$project": {
24
      "_id": 0,
25
      "name": 1,
26
      "address": 1
27
    }
28
  }
29
])

1
using MongoDB.Bson;
2
using MongoDB.Bson.Serialization.Attributes;
3
using MongoDB.Bson.Serialization.Conventions;
4
using MongoDB.Driver;
5
using MongoDB.Driver.GeoJsonObjectModel;
6
using MongoDB.Driver.Search;
7
8
public class GeoBoxQuery
9
{
10
    // Make sure your password is URL encoded if it contains special characters
11
    // Replace with your actual connection string with correct credentials
12
    private const string MongoConnectionString = "<connection-string>";
13
14
    public static void Main(string[] args)
15
    {
16
        // allow automapping of the camelCase database fields to our PropertyDocument
17
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
18
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
19
20
        // connect to your Atlas cluster
21
        var mongoClient = new MongoClient(MongoConnectionString);
22
        var airbnbDatabase = mongoClient.GetDatabase("sample_airbnb");
23
        var listingsCollection = airbnbDatabase.GetCollection<PropertyDocument>("listingsAndReviews");
24
25
        // define and run pipeline
26
        var results = listingsCollection.Aggregate()
27
            .Search(Builders<PropertyDocument>.Search.GeoWithin(
28
                property => property.Address!.Location,
29
                new GeoWithinBox<GeoJson2DCoordinates>(
30
                    new GeoJsonPoint<GeoJson2DCoordinates>(new GeoJson2DCoordinates(112.467, -55.050)),
31
                    new GeoJsonPoint<GeoJson2DCoordinates>(new GeoJson2DCoordinates(168.000, -9.133))
32
                )
33
            ))
34
            .Limit(3)
35
            .Project<PropertyDocument>(Builders<PropertyDocument>.Projection
36
                .Include(property => property.Name)
37
                .Include(property => property.Address)
38
                .Exclude(property => property.Id))
39
            .ToList();
40
41
        // print results
42
        foreach (var property in results)
43
        {
44
            Console.WriteLine(property.ToJson());
45
        }
46
    }
47
}
48
49
[BsonIgnoreExtraElements]
50
public class PropertyDocument
51
{
52
    [BsonIgnoreIfDefault]
53
    public ObjectId Id { get; set; }
54
    public string? Name { get; set; }
55
    public AddressDocument? Address { get; set; }
56
}
57
58
[BsonIgnoreExtraElements]
59
public class AddressDocument
60
{
61
    public GeoJsonPoint<GeoJson2DCoordinates>? Location { get; set; }
62
    public string? Street { get; set; }
63
    public string? Country { get; set; }
64
}

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
	"time"
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
// define structure of listingsAndReviews collection
14
type Property struct {
15
	Name    string `bson:"name"`
16
	Address struct {
17
		Location struct {
18
			Type        string    `bson:"type"`
19
			Coordinates []float64 `bson:"coordinates"`
20
		} `bson:"location"`
21
		Street  string `bson:"street"`
22
		Country string `bson:"country"`
23
	} `bson:"address"`
24
}
25
26
func main() {
27
	var err error
28
	// connect to the Atlas cluster
29
	ctx := context.Background()
30
	client, err := mongo.Connect(options.Client().SetTimeout(5*time.Second).ApplyURI("<connection-string>"))
31
	if err != nil {
32
		panic(err)
33
	}
34
	defer client.Disconnect(ctx)
35
	// set namespace
36
	collection := client.Database("sample_airbnb").Collection("listingsAndReviews")
37
	// define pipeline
38
	searchStage := bson.D{{Key: "$search", Value: bson.M{
39
		"geoWithin": bson.M{
40
			"path": "address.location",
41
			"box": bson.M{
42
				"bottomLeft": bson.M{
43
					"type":        "Point",
44
					"coordinates": []float64{112.467, -55.050},
45
				},
46
				"topRight": bson.M{
47
					"type":        "Point",
48
					"coordinates": []float64{168.000, -9.133},
49
				},
50
			},
51
		},
52
	}}}
53
	limitStage := bson.D{{Key: "$limit", Value: 3}}
54
	projectStage := bson.D{{Key: "$project", Value: bson.D{{Key: "_id", Value: 0}, {Key: "name", Value: 1}, {Key: "address", Value: 1}}}}
55
	// run pipeline
56
	cursor, err := collection.Aggregate(ctx, mongo.Pipeline{searchStage, limitStage, projectStage})
57
	if err != nil {
58
		panic(err)
59
	}
60
	// print results
61
	var results []Property
62
	if err = cursor.All(context.TODO(), &results); err != nil {
63
		panic(err)
64
	}
65
	for _, result := range results {
66
		fmt.Println(result)
67
	}
68
}

1
import java.util.Arrays;
2
import static com.mongodb.client.model.Aggregates.limit;
3
import static com.mongodb.client.model.Aggregates.project;
4
import static com.mongodb.client.model.Projections.excludeId;
5
import static com.mongodb.client.model.Projections.fields;
6
import static com.mongodb.client.model.Projections.include;
7
import com.mongodb.client.MongoClient;
8
import com.mongodb.client.MongoClients;
9
import com.mongodb.client.MongoCollection;
10
import com.mongodb.client.MongoDatabase;
11
import org.bson.Document;
12
13
public class GeoBoxQuery {
14
	public static void main( String[] args ) {
15
16
        // define query
17
		Document agg = new Document("$search",
18
		new Document("geoWithin", 
19
			new Document("path", "address.location")
20
				.append("box", 
21
				new Document("bottomLeft", 
22
					new Document("type", "Point")
23
						.append("coordinates", Arrays.asList(112.467, -55.050)))
24
				.append("topRight", 
25
					new Document("type", "Point")
26
						.append("coordinates", Arrays.asList(168.000, -9.133))))));
27
28
		// specify connection
29
		String uri = "<connection-string>";
30
31
        // establish connection and set namespace
32
		try (MongoClient mongoClient = MongoClients.create(uri)) {
33
			MongoDatabase database = mongoClient.getDatabase("sample_airbnb");
34
			MongoCollection<Document> collection = database.getCollection("listingsAndReviews");
35
			// run query and print results
36
			collection.aggregate(Arrays.asList(agg, 
37
				limit(3), 
38
				project(fields(excludeId(), include("name", "address")))))
39
            .forEach(doc -> System.out.println(doc.toJson()));	
40
		}
41
	}
42
}

1
import com.mongodb.client.model.Aggregates.limit
2
import com.mongodb.client.model.Aggregates.project
3
import com.mongodb.client.model.Projections.*
4
import com.mongodb.kotlin.client.coroutine.MongoClient
5
import kotlinx.coroutines.runBlocking
6
import org.bson.Document
7
8
fun main() {
9
    // establish connection and set namespace
10
    val uri = "<connection-string>"
11
    val mongoClient = MongoClient.create(uri)
12
    val database = mongoClient.getDatabase("sample_airbnb")
13
    val collection = database.getCollection<Document>("listingsAndReviews")
14
15
    runBlocking {
16
        // define query
17
        val agg = Document(
18
            "\$search",
19
            Document("geoWithin",
20
                Document("path", "address.location")
21
                    .append("box",
22
                        Document("bottomLeft",
23
                            Document("type", "Point")
24
                                .append("coordinates", listOf(112.467, -55.050)))
25
                        .append("topRight",
26
                            Document("type", "Point")
27
                                .append("coordinates", listOf(168.000, -9.133)))))
28
        )
29
30
        // run query and print results
31
        val resultsFlow = collection.aggregate<Document>(
32
            listOf(
33
                agg,
34
                limit(3),
35
                project(fields(excludeId(), include("name", "address")))
36
            )
37
        )
38
        resultsFlow.collect { println(it) }
39
    }
40
    mongoClient.close()
41
}

1
const { MongoClient } = require("mongodb");
2
3
// connect to your Atlas cluster
4
const uri = "<connection-string>";
5
6
const client = new MongoClient(uri);
7
8
async function run() {
9
    try {
10
        await client.connect();
11
12
        // set namespace
13
        const database = client.db("sample_airbnb");
14
        const coll = database.collection("listingsAndReviews");
15
16
        // define pipeline
17
        const agg = [
18
            {
19
              '$search': {
20
                'geoWithin': {
21
                  'path': 'address.location',
22
                  'box': {
23
                    'bottomLeft': {
24
                      'type': 'Point',
25
                      'coordinates': [112.467, -55.050]
26
                    },
27
                    'topRight': {
28
                      'type': 'Point',
29
                      'coordinates': [168.000, -9.133]
30
                    }
31
                  }
32
                }
33
              }
34
            }, {
35
              '$limit': 3
36
            }, {
37
              '$project': {
38
                '_id': 0,
39
                'name': 1,
40
                'address': 1
41
              }
42
            }
43
        ];
44
45
        // run pipeline
46
        const result = coll.aggregate(agg);
47
48
        // print results
49
        await result.forEach((doc) => console.log(doc));
50
    } finally {
51
        await client.close();
52
    }
53
}
54
run().catch(console.dir);

1
import pymongo
2
import dns.resolver
3
4
# connect to your Atlas cluster
5
client = pymongo.MongoClient("<connection-string>")
6
7
# define pipeline
8
pipeline = [
9
    {
10
        "$search": {
11
            "geoWithin": {
12
                "path": "address.location",
13
                "box": {
14
                    "bottomLeft": {
15
                        "type": "Point",
16
                        "coordinates": [112.467, -55.050]
17
                    },
18
                    "topRight": {
19
                        "type": "Point",
20
                        "coordinates": [168.000, -9.133]
21
                    }
22
                }
23
            }
24
        }
25
    },
26
    {
27
        "$limit": 3
28
    },
29
    {
30
        "$project": {
31
            "_id": 0,
32
            "name": 1,
33
            "address": 1
34
        }
35
    }
36
]
37
38
# run pipeline
39
result = client.sample_airbnb.listingsAndReviews.aggregate(pipeline)
40
41
# print results
42
for i in result:
43
    print(i)

{
  "$searchMeta": {
    "facet": {
      "operator": {
        "geoWithin": {
          "path": "address.location",
          "box": {
            "bottomLeft": {
              "type": "Point",
              "coordinates": [112.467, -55.050]
            },
            "topRight": {
              "type": "Point",
              "coordinates": [168.000, -9.133]
            }
          }
        }
      },
      "facets": {
        "propertyTypeFacet": {
          "type": "string",
          "path": "property_type"
        }
      }
    }
  }
}

1
db.listingsAndReviews.aggregate([
2
  {
3
    "$searchMeta": {
4
      "facet": {
5
        "operator": {
6
          "geoWithin": {
7
            "path": "address.location",
8
            "box": {
9
              "bottomLeft": {
10
                "type": "Point",
11
                "coordinates": [112.467, -55.050]
12
              },
13
              "topRight": {
14
                "type": "Point",
15
                "coordinates": [168.000, -9.133]
16
              }
17
            }
18
          }
19
        },
20
        "facets": {
21
          "propertyTypeFacet": {
22
            "type": "string",
23
            "path": "property_type"
24
          }
25
        }
26
      }
27
    }
28
  }
29
])

1
// establish connection and set namespace  
2
using MongoDB.Bson;
3
using MongoDB.Driver;
4
5
var client = new MongoClient("<connection-string>");
6
var database = client.GetDatabase("sample_airbnb");
7
var collection = database.GetCollection<BsonDocument>("listingsAndReviews");
8
9
// define query
10
var agg = new BsonDocument("$searchMeta",
11
    new BsonDocument("facet",
12
        new BsonDocument
13
        {
14
            ["operator"] = new BsonDocument("geoWithin",
15
                new BsonDocument
16
                {
17
                    ["path"] = "address.location",
18
                    ["box"] = new BsonDocument
19
                    {
20
                        ["bottomLeft"] = new BsonDocument
21
                        {
22
                            ["type"] = "Point",
23
                            ["coordinates"] = new BsonArray { 112.467, -55.050 }
24
                        },
25
                        ["topRight"] = new BsonDocument
26
                        {
27
                            ["type"] = "Point", 
28
                            ["coordinates"] = new BsonArray { 168.000, -9.133 }
29
                        }
30
                    }
31
                }),
32
            ["facets"] = new BsonDocument("propertyTypeFacet",
33
                new BsonDocument
34
                {
35
                    ["type"] = "string",
36
                    ["path"] = "property_type"
37
                })
38
        }));
39
40
// run query and print results
41
var cursor = collection.Aggregate<BsonDocument>(
42
    new BsonDocument[] { agg }
43
);
44
foreach (var result in cursor.ToEnumerable())
45
{
46
    Console.WriteLine(result);
47
}

1
// run-geo-box-metadata-query.go
2
3
package main
4
5
import (
6
	"context"
7
	"fmt"
8
	"log"
9
10
	"go.mongodb.org/mongo-driver/bson"
11
	"go.mongodb.org/mongo-driver/mongo"
12
	"go.mongodb.org/mongo-driver/mongo/options"
13
)
14
15
func main() {
16
	// establish connection and set namespace
17
	client, err := mongo.Connect(context.TODO(),
18
		options.Client().ApplyURI("<connection-string>"))
19
	if err != nil {
20
		log.Fatal(err)
21
	}
22
	defer client.Disconnect(context.TODO())
23
	
24
	collection := client.Database("sample_airbnb").Collection("listingsAndReviews")
25
26
	// define query
27
	searchStage := bson.D{{"$searchMeta", bson.D{
28
		{"facet", bson.D{
29
			{"operator", bson.D{
30
				{"geoWithin", bson.D{
31
					{"path", "address.location"},
32
					{"box", bson.D{
33
						{"bottomLeft", bson.D{
34
							{"type", "Point"},
35
							{"coordinates", bson.A{112.467, -55.050}},
36
						}},
37
						{"topRight", bson.D{
38
							{"type", "Point"},
39
							{"coordinates", bson.A{168.000, -9.133}},
40
						}},
41
					}},
42
				}},
43
			}},
44
			{"facets", bson.D{
45
				{"propertyTypeFacet", bson.D{
46
					{"type", "string"},
47
					{"path", "property_type"},
48
				}},
49
			}},
50
		}},
51
	}}}
52
53
	// run query and print results
54
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage})
55
	if err != nil {
56
		log.Fatal(err)
57
	}
58
	defer cursor.Close(context.TODO())
59
	
60
	for cursor.Next(context.TODO()) {
61
		var result bson.M
62
		if err := cursor.Decode(&result); err != nil {
63
			log.Fatal(err)
64
		}
65
		fmt.Println(result)
66
	}
67
}

1
import org.bson.Document;
2
import com.mongodb.client.MongoClient;
3
import com.mongodb.client.MongoClients;
4
import com.mongodb.client.MongoCollection;
5
import com.mongodb.client.MongoDatabase;
6
import java.util.Arrays;
7
8
public class GeoBoxMetadataQuery {
9
    public static void main(String[] args) {
10
        // establish connection and set namespace
11
        String uri = "<connection-string>";
12
        
13
        try (MongoClient mongoClient = MongoClients.create(uri)) {
14
            MongoDatabase database = mongoClient.getDatabase("sample_airbnb");
15
            MongoCollection<Document> collection = database.getCollection("listingsAndReviews");
16
17
            // define query
18
            Document agg = new Document("$searchMeta",
19
                new Document("facet",
20
                    new Document()
21
                        .append("operator", new Document("geoWithin",
22
                            new Document()
23
                                .append("path", "address.location")
24
                                .append("box", new Document()
25
                                    .append("bottomLeft", new Document()
26
                                        .append("type", "Point")
27
                                        .append("coordinates", Arrays.asList(112.467, -55.050)))
28
                                    .append("topRight", new Document()
29
                                        .append("type", "Point")
30
                                        .append("coordinates", Arrays.asList(168.000, -9.133))))))
31
                        .append("facets", new Document("propertyTypeFacet",
32
                            new Document()
33
                                .append("type", "string")
34
                                .append("path", "property_type")))));
35
36
            // run query and print results
37
            collection.aggregate(Arrays.asList(agg))
38
                .forEach(doc -> System.out.println(doc.toJson()));
39
        }
40
    }
41
}

1
import com.mongodb.client.model.Aggregates.limit
2
import com.mongodb.client.model.Aggregates.project
3
import com.mongodb.client.model.Projections.*
4
import com.mongodb.kotlin.client.coroutine.MongoClient
5
import kotlinx.coroutines.runBlocking
6
import org.bson.Document
7
8
fun main() {
9
    // establish connection and set namespace
10
    val uri = "<connection-string>"
11
    val mongoClient = MongoClient.create(uri)
12
    val database = mongoClient.getDatabase("sample_airbnb")
13
    val collection = database.getCollection<Document>("listingsAndReviews")
14
15
    runBlocking {
16
        // define query
17
        val agg = Document(
18
            "\$searchMeta",
19
            Document("facet",
20
                Document("operator",
21
                    Document("geoWithin",
22
                        Document("path", "address.location")
23
                            .append("box",
24
                                Document("bottomLeft",
25
                                    Document("type", "Point")
26
                                        .append("coordinates", listOf(112.467, -55.050)))
27
                                .append("topRight",
28
                                    Document("type", "Point")
29
                                        .append("coordinates", listOf(168.000, -9.133))))))
30
                .append("facets",
31
                    Document("propertyTypeFacet",
32
                        Document("type", "string")
33
                            .append("path", "property_type"))))
34
        )
35
36
        // run query and print results
37
        val resultsFlow = collection.aggregate<Document>(listOf(agg))
38
        resultsFlow.collect { println(it) }
39
    }
40
    mongoClient.close()
41
}

1
// run-geo-box-metadata-query.js
2
3
// establish connection and set namespace
4
const { MongoClient } = require("mongodb");
5
const uri = "<connection-string>";
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
    // define query
14
    const agg = [
15
      {
16
        "$searchMeta": {
17
          "facet": {
18
            "operator": {
19
              "geoWithin": {
20
                "path": "address.location",
21
                "box": {
22
                  "bottomLeft": {
23
                    "type": "Point",
24
                    "coordinates": [112.467, -55.050]
25
                  },
26
                  "topRight": {
27
                    "type": "Point",
28
                    "coordinates": [168.000, -9.133]
29
                  }
30
                }
31
              }
32
            },
33
            "facets": {
34
              "propertyTypeFacet": {
35
                "type": "string",
36
                "path": "property_type"
37
              }
38
            }
39
          }
40
        }
41
      }
42
    ];
43
44
    // run query and print results
45
    const result = collection.aggregate(agg);
46
    await result.forEach((doc) => {
47
      console.log(JSON.stringify(doc, null, 2));
48
    });
49
  } finally {
50
    await client.close();
51
  }
52
}
53
run().catch(console.dir);

1
# run-geo-box-metadata-query.py
2
3
# establish connection and set namespace
4
import pymongo
5
6
client = pymongo.MongoClient("<connection-string>")
7
database = client["sample_airbnb"]
8
collection = database["listingsAndReviews"]
9
10
# define query
11
query = [
12
  {
13
    "$searchMeta": {
14
      "facet": {
15
        "operator": {
16
          "geoWithin": {
17
            "path": "address.location",
18
            "box": {
19
              "bottomLeft": {
20
                "type": "Point",
21
                "coordinates": [112.467, -55.050]
22
              },
23
              "topRight": {
24
                "type": "Point",
25
                "coordinates": [168.000, -9.133]
26
              }
27
            }
28
          }
29
        },
30
        "facets": {
31
          "propertyTypeFacet": {
32
            "type": "string",
33
            "path": "property_type"
34
          }
35
        }
36
      }
37
    }
38
  }
39
]
40
41
# run query and print results
42
results = collection.aggregate(query)
43
for document in results:
44
    print(document)