Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Geodaten
<a name="mongo-apis-geospatial-operators"></a>

Dieser Abschnitt enthält detaillierte Informationen zu Geodatenoperatoren, die von Amazon DocumentDB unterstützt werden.

**Topics**
+ [\$1geometry](geometry.md)
+ [\$1geoIntersects](geoIntersects.md)
+ [\$1geoWithin](geoWithin.md)
+ [\$1maxDistance](maxDistance.md)
+ [\$1minDistance](minDistance.md)
+ [\$1near](near.md)
+ [\$1nearSphere](nearSphere.md)

# \$1geometry
<a name="geometry"></a>

Der `$geometry` Operator in Amazon DocumentDB wird verwendet, um ein GeoJSON-Geometrieobjekt als Teil einer Geodatenabfrage anzugeben. Dieser Operator wird in Verbindung mit anderen Operatoren für Geodatenabfragen wie `$geoWithin` und `$geoIntersects` zur Durchführung räumlicher Abfragen Ihrer Daten verwendet.

In Amazon DocumentDB unterstützt der `$geometry` Operator die folgenden GeoJSON-Geometrietypen:
+ Point
+ LineString
+ Polygon
+ MultiPoint
+ MultiLineString
+ MultiPolygon
+ GeometryCollection

**Parameter**
+ `type`: Der Typ des GeoJSON-Geometrieobjekts, z. B.`Point`,`Polygon`, usw.
+ `coordinates`: Ein Array von Koordinaten, das die Geometrie darstellt. Die Struktur des Koordinatenarrays hängt vom Geometrietyp ab.

## Beispiel (MongoDB Shell)
<a name="geometry-examples"></a>

Das folgende Beispiel zeigt, wie der `$geometry` Operator verwendet wird, um eine `$geoIntersects` Abfrage in Amazon DocumentDB durchzuführen.

**Erstellen Sie Beispieldokumente**

```
db.locations.insertMany([
  { 
    "_id": 1,
    "name": "Location 1",
    "location": { 
      "type": "Point",
      "coordinates": [-73.983253, 40.753941]
    }
  },
  { 
    "_id": 2,
    "name": "Location 2", 
    "location": {
      "type": "Polygon",
      "coordinates": [[
        [-73.998427, 40.730309],
        [-73.954348, 40.730309],
        [-73.954348, 40.780816],
        [-73.998427, 40.780816],
        [-73.998427, 40.730309]
      ]]
    }
  }
]);
```

**Beispiel für eine Abfrage**

```
db.locations.find({
  "location": {
    "$geoIntersects": {
      "$geometry": {
        "type": "Polygon",
        "coordinates": [[
          [-73.998, 40.730],
          [-73.954, 40.730],
          [-73.954, 40.781],
          [-73.998, 40.781],
          [-73.998, 40.730]
        ]]
      }
    }
  }
})
```

**Ausgabe**

```
[
  {
    "_id": 2,
    "name": "Location 2",
    "location": {
      "type": "Polygon",
      "coordinates": [
        [
          [-73.998427, 40.730309],
          [-73.954348, 40.730309],
          [-73.954348, 40.780816],
          [-73.998427, 40.780816],
          [-73.998427, 40.730309]
        ]
      ]
    }
  }
]
```

## Codebeispiele
<a name="geometry-code"></a>

Um ein Codebeispiel für die Verwendung des `$geometry` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function example() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('locations');

  const query = {
    "location": {
      "$geoIntersects": {
        "$geometry": {
          "type": "Polygon",
          "coordinates": [[
            [-73.998, 40.730],
            [-73.954, 40.730],
            [-73.954, 40.781],
            [-73.998, 40.781],
            [-73.998, 40.730]
          ]]
        }
      }
    }
  };

  const result = await collection.find(query).toArray();
  console.log(result);

  await client.close();
}

example();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    collection = db['locations']

    query = {
        "location": {
            "$geoIntersects": {
                "$geometry": {
                    "type": "Polygon",
                    "coordinates": [[
                        [-73.998, 40.730],
                        [-73.954, 40.730],
                        [-73.954, 40.781],
                        [-73.998, 40.781],
                        [-73.998, 40.730]
                    ]]
                }
            }
        }
    }

    result = list(collection.find(query))
    print(result)

    client.close()

example()
```

------

# \$1geoIntersects
<a name="geoIntersects"></a>

Der `$geoIntersects` Operator in Amazon DocumentDB wird verwendet, um Dokumente zu finden, deren Geodaten sich mit einem bestimmten GeoJSON-Objekt überschneiden. Dieser Operator ist nützlich für Anwendungen, bei denen Dokumente anhand ihrer räumlichen Beziehung zu einer bestimmten geographischen Form, wie z. B. einem Polygon oder Multipolygon, identifiziert werden müssen.

**Parameter**
+ `$geometry`: Ein GeoJSON-Objekt, das die Form darstellt, bei der nach Überschneidungen gesucht werden soll. Die unterstützten GeoJSON-Objekttypen sind`Point`, `LineString``Polygon`, und`MultiPolygon`.

## Beispiel (MongoDB Shell)
<a name="geoIntersects-examples"></a>

Das folgende Beispiel zeigt, wie der `$geoIntersects` Operator verwendet wird, um den Namen des Bundesstaates für einen bestimmten Satz von Koordinaten in Amazon DocumentDB zu finden.

**Erstellen Sie Beispieldokumente**

```
db.states.insertMany([
  {
    "name": "New York",
    "loc": {
      "type": "Polygon",
      "coordinates": [[
        [-74.25909423828125, 40.47556838210948],
        [-73.70819091796875, 40.47556838210948],
        [-73.70819091796875, 41.31342607582222],
        [-74.25909423828125, 41.31342607582222],
        [-74.25909423828125, 40.47556838210948]
      ]]
    }
  },
  {
    "name": "California",
    "loc": {
      "type": "Polygon",
      "coordinates": [[
        [-124.4091796875, 32.56456771381587],
        [-114.5458984375, 32.56456771381587],
        [-114.5458984375, 42.00964153424558],
        [-124.4091796875, 42.00964153424558],
        [-124.4091796875, 32.56456771381587]
      ]]
    }
  }
]);
```

**Beispiel für eine Abfrage**

```
var location = [-73.965355, 40.782865];

db.states.find({
  "loc": {
    "$geoIntersects": {
      "$geometry": {
        "type": "Point",
        "coordinates": location
      }
    }
  }
}, {
  "name": 1
});
```

**Ausgabe**

```
{ "_id" : ObjectId("536b0a143004b15885c91a2c"), "name" : "New York" }
```

## Codebeispiele
<a name="geoIntersects-code"></a>

Um ein Codebeispiel für die Verwendung des `$geoIntersects` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function findStateByGeoIntersects(longitude, latitude) {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('states');

  const query = {
    loc: {
      $geoIntersects: {
        $geometry: {
          type: 'Point',
          coordinates: [longitude, latitude]
        }
      }
    }
  };

  const projection = {
    _id: 0,
    name: 1
  };

  const document = await collection.findOne(query, { projection });

  await client.close();
  
  if (document) {
    return document.name;
  } else {
    throw new Error('The geo location you entered was not found in the United States!');
  }
}
```

------
#### [ Python ]

```
from pymongo import MongoClient

def find_state_by_geointersects(longitude, latitude):
    try:
        client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
        db = client.test
        collection_states = db.states

        query_geointersects = {
            "loc": {
                "$geoIntersects": {
                    "$geometry": {
                        "type": "Point",
                        "coordinates": [longitude, latitude]
                    }
                }
            }
        }

        document = collection_states.find_one(query_geointersects,
                                              projection={
                                                  "_id": 0,
                                                  "name": 1
                                              })
        if document is not None:
            state_name = document['name']
            return state_name
        else:
            raise Exception("The geo location you entered was not found in the United States!")
    except Exception as e:
        print('Exception in geoIntersects: {}'.format(e))
        raise
    finally:
        if client is not None:
            client.close()
```

------

# \$1geoWithin
<a name="geoWithin"></a>

Der `$geoWithin` Operator in Amazon DocumentDB wird verwendet, um Dokumente zu finden, deren Standortdaten (dargestellt als GeoJSON-Objekte) vollständig in einer bestimmten Form enthalten sind, z. B. einem Polygon oder Multipolygon. Dies ist nützlich für die Abfrage von Objekten, die sich in einer bestimmten geografischen Region befinden.

**Parameter**
+ `$geometry`: Ein GeoJSON-Objekt, das die Form darstellt, nach der abgefragt werden soll.

## Beispiel (MongoDB Shell)
<a name="geoWithin-examples"></a>

Das folgende Beispiel zeigt, wie der `$geoWithin` Operator verwendet werden kann, um alle Flughäfen im Bundesstaat New York zu finden.

**Erstellen Sie Beispieldokumente**

```
// Insert state document
db.states.insert({
    "name": "New York",
    "loc": {
        "type": "Polygon",
        "coordinates": [[
            [-79.76278, 45.0],
            [-73.94, 45.0],
            [-73.94, 40.5],
            [-79.76278, 40.5],
            [-79.76278, 45.0]
        ]]
    }
});

// Insert airport documents
db.airports.insert([
    {
        "name": "John F. Kennedy International Airport",
        "type": "airport",
        "code": "JFK",
        "loc": {
            "type": "Point",
            "coordinates": [-73.7781, 40.6413]
        }
    },
    {
        "name": "LaGuardia Airport",
        "type": "airport",
        "code": "LGA",
        "loc": {
            "type": "Point",
            "coordinates": [-73.8772, 40.7769]
        }
    },
    {
        "name": "Buffalo Niagara International Airport",
        "type": "airport",
        "code": "BUF",
        "loc": {
            "type": "Point",
            "coordinates": [-78.7322, 42.9403]
        }
    }
]);
```

**Beispiel für eine Abfrage**

```
var state = db.states.findOne({"name": "New York"});

db.airports.find({
    "loc": {
        "$geoWithin": {
            "$geometry": state.loc
        }
    }
}, {
    "name": 1,
    "type": 1,
    "code": 1,
    "_id": 0
});
```

**Ausgabe**

```
[
  {
    "name": "John F. Kennedy International Airport",
    "type": "airport",
    "code": "JFK"
  },
  {
    "name": "LaGuardia Airport",
    "type": "airport",
    "code": "LGA"
  }
]
```

## Codebeispiele
<a name="geoWithin-code"></a>

Um ein Codebeispiel für die Verwendung des `$geoWithin` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function findAirportsWithinState(stateName) {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');

  const stateDoc = await db.collection('states').findOne({ name: stateName }, { projection: { _id: 0, loc: 1 } });
  const airportDocs = await db.collection('airports').find({
    loc: {
      $geoWithin: {
        $geometry: stateDoc.loc
      }
    }
  }, { projection: { name: 1, type: 1, code: 1, _id: 0 } }).toArray();

  console.log(airportDocs);

  await client.close();
}

findAirportsWithinState('New York');
```

------
#### [ Python ]

```
from pymongo import MongoClient

def find_airports_within_state(state_name):
    try:
        client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
        db = client['test']
        state_doc = db.states.find_one({'name': state_name}, {'_id': 0, 'loc': 1})
        airport_docs = db.airports.find({
            'loc': {
                '$geoWithin': {
                    '$geometry': state_doc['loc']
                }
            }
        }, {'name': 1, 'type': 1, 'code': 1, '_id': 0})
        
        return list(airport_docs)
    except Exception as e:
        print(f'Error: {e}')
    finally:
        client.close()

airports = find_airports_within_state('New York')
print(airports)
```

------

# \$1maxDistance
<a name="maxDistance"></a>

Der `$maxDistance` Operator in Amazon DocumentDB wird verwendet, um die maximale Entfernung (in Metern) von einem GeoJSON-Punkt anzugeben, innerhalb derer sich Dokumente befinden müssen, um in die Abfrageergebnisse aufgenommen zu werden. Dieser Operator wird in Verbindung mit dem `$nearSphere` Operator verwendet, um Geodatenabfragen durchzuführen.

**Parameter**
+ `$maxDistance`: Die maximale Entfernung (in Metern) vom Referenzpunkt, innerhalb derer sich Dokumente befinden müssen, um in die Abfrageergebnisse aufgenommen zu werden.

## Beispiel (MongoDB Shell)
<a name="maxDistance-examples"></a>

Das folgende Beispiel zeigt, wie der `$maxDistance` Operator in Amazon DocumentDB verwendet wird, um alle Hauptstädte der Bundesstaaten im Umkreis von 100 Kilometern von Boston zu finden.

**Erstellen Sie Beispieldokumente**

```
db.capitals.insert([
  { state: "Massachusetts", city: "Boston", location: { type: "Point", coordinates: [-71.0589, 42.3601] } },
  { state: "Rhode Island", city: "Providence", location: { type: "Point", coordinates: [-71.4128, 41.8239] } },
  { state: "New Hampshire", city: "Concord", location: { type: "Point", coordinates: [-71.5383, 43.2067] } },
  { state: "Vermont", city: "Montpelier", location: { type: "Point", coordinates: [-72.5751, 44.2604] } }
]);
```

**Beispiel für eine Abfrage**

```
db.capitals.find(
  {
    location: {
      $nearSphere: {
        $geometry: { type: "Point", coordinates: [-71.0589, 42.3601] },
        $maxDistance: 100000
      }
    }
  },
  { state: 1, city: 1, _id: 0 }
);
```

**Ausgabe**

```
[
  { "state": "Rhode Island", "city": "Providence" },
  { "state": "New Hampshire", "city": "Concord" }
]
```

## Codebeispiele
<a name="maxDistance-code"></a>

Um ein Codebeispiel für die Verwendung des `$maxDistance` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function findCapitalsNearBoston() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const capitals = db.collection('capitals');

  const result = await capitals.find({
    location: {
      $nearSphere: {
        $geometry: { type: "Point", coordinates: [-71.0589, 42.3601] },
        $maxDistance: 100000
      }
    }
  }, {
    projection: { state: 1, city: 1, _id: 0 }
  }).toArray();

  console.log(result);
  await client.close();
}

findCapitalsNearBoston();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def find_capitals_near_boston():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    capitals = db.capitals

    result = list(capitals.find(
        {
            "location": {
                "$nearSphere": {
                    "$geometry": { "type": "Point", "coordinates": [-71.0589, 42.3601] },
                    "$maxDistance": 100000
                }
            }
        },
        {"state": 1, "city": 1, "_id": 0}
    ))

    print(result)
    client.close()

find_capitals_near_boston()
```

------

# \$1minDistance
<a name="minDistance"></a>

`$minDistance`ist ein Suchoperator, der in Verbindung mit `$nearSphere` oder verwendet wird, `$geoNear` um Dokumente zu filtern, die sich mindestens im angegebenen Mindestabstand vom Mittelpunkt befinden. Dieser Operator wird in Amazon DocumentDB unterstützt und funktioniert ähnlich wie sein Gegenstück in MongoDB.

**Parameter**
+ `$minDistance`: Der Mindestabstand (in Metern) vom Mittelpunkt, um Dokumente in die Ergebnisse einzubeziehen.

## Beispiel (MongoDB Shell)
<a name="minDistance-examples"></a>

In diesem Beispiel finden wir alle Restaurants in einem Umkreis von 2 Kilometern um einen bestimmten Standort in Seattle, Washington.

**Erstellen Sie Beispieldokumente**

```
db.usarestaurants.insertMany([
  {
    "state": "Washington",
    "city": "Seattle",
    "name": "Noodle House",
    "rating": 4.8,
    "location": {
      "type": "Point",
      "coordinates": [-122.3517, 47.6159]
    }
  },
  {
    "state": "Washington",
    "city": "Seattle",
    "name": "Pike Place Grill",
    "rating": 4.5,
    "location": {
      "type": "Point",
      "coordinates": [-122.3412, 47.6102]
    }
  },
  {
    "state": "Washington",
    "city": "Bellevue",
    "name": "The Burger Joint",
    "rating": 4.2,
    "location": {
      "type": "Point",
      "coordinates": [-122.2007, 47.6105]
    }
  }
]);
```

**Beispiel für eine Abfrage**

```
db.usarestaurants.find({
  "location": {
    "$nearSphere": {
      "$geometry": {
        "type": "Point",
        "coordinates": [-122.3516, 47.6156]
      },
      "$minDistance": 1,
      "$maxDistance": 2000
    }
  }
}, {
  "name": 1
});
```

**Ausgabe**

```
{ "_id" : ObjectId("611f3da985009a81ad38e74b"), "name" : "Noodle House" }
{ "_id" : ObjectId("611f3da985009a81ad38e74c"), "name" : "Pike Place Grill" }
```

## Codebeispiele
<a name="minDistance-code"></a>

Um ein Codebeispiel für die Verwendung des `$minDistance` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function findRestaurantsNearby() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const collection = db.collection('usarestaurants');

  const result = await collection.find({
    "location": {
      "$nearSphere": {
        "$geometry": {
          "type": "Point",
          "coordinates": [-122.3516, 47.6156]
        },
        "$minDistance": 1,
        "$maxDistance": 2000
      }
    }
  }, {
    "projection": { "name": 1 }
  }).toArray();

  console.log(result);
  client.close();
}

findRestaurantsNearby();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def find_restaurants_nearby():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    collection = db.usarestaurants

    result = list(collection.find({
        "location": {
            "$nearSphere": {
                "$geometry": {
                    "type": "Point",
                    "coordinates": [-122.3516, 47.6156]
                },
                "$minDistance": 1,
                "$maxDistance": 2000
            }
        }
    }, {
        "projection": {"name": 1}
    }))

    print(result)
    client.close()

find_restaurants_nearby()
```

------

# \$1near
<a name="near"></a>

Der `$near` Operator in Amazon DocumentDB wird verwendet, um Dokumente zu finden, die sich geografisch in der Nähe eines bestimmten Punktes befinden. Er gibt Dokumente zurück, die nach Entfernung sortiert sind, wobei die Dokumente, die sich am nächsten befinden, zuerst angezeigt werden. Dieser Operator erfordert einen 2dSphere-Geodatenindex und ist nützlich für Näherungsabfragen von Standortdaten.

**Parameter**
+ `$geometry`: Ein GeoJSON Point-Objekt, das den Mittelpunkt für die Near-Abfrage definiert.
+ `$maxDistance`: (optional) Die maximale Entfernung in Metern vom angegebenen Punkt, die ein Dokument haben darf, um der Abfrage zu entsprechen.
+ `$minDistance`: (optional) Die Mindestentfernung in Metern vom angegebenen Punkt, die ein Dokument haben darf, um der Abfrage zu entsprechen.

**Anforderungen an den Index**
+ `2dsphere index`: Erforderlich für Geodatenabfragen zu GeoJSON-Punktdaten.

## Beispiel (MongoDB Shell)
<a name="near-examples"></a>

Das folgende Beispiel zeigt, wie Sie den `$near` Operator verwenden können, um die Restaurants zu finden, die einem bestimmten Ort in Seattle, Washington, am nächsten liegen.

**Erstellen Sie Beispieldokumente**

```
db.usarestaurants.insert([
  {
    "name": "Noodle House",
    "city": "Seattle",
    "state": "Washington",
    "rating": 4.8,
    "location": { "type": "Point", "coordinates": [-122.3517, 47.6159] }
  },
  {
    "name": "Pike Place Grill",
    "city": "Seattle",
    "state": "Washington",
    "rating": 4.2,
    "location": { "type": "Point", "coordinates": [-122.3403, 47.6062] }
  },
  {
    "name": "Lola",
    "city": "Seattle",
    "state": "Washington",
    "rating": 4.5,
    "location": { "type": "Point", "coordinates": [-122.3407, 47.6107] }
  }
]);
```

**Erstellen Sie einen 2dSphere-Index**

```
db.usarestaurants.createIndex({ "location": "2dsphere" });
```

**Abfragebeispiel mit GeoJSON Point**

```
db.usarestaurants.find({
  location: {
    $near: {
      $geometry: {
        type: "Point",
        coordinates: [-122.3516, 47.6156]
      },
      $maxDistance: 100,
      $minDistance: 10
    }
  }
});
```

**Ausgabe**

```
{
  "_id" : ObjectId("69031ec9ea1c2922a1ce5f4a"),
  "name" : "Noodle House",
  "city" : "Seattle",
  "state" : "Washington",
  "rating" : 4.8,
  "location" : {
    "type" : "Point",
    "coordinates" : [ -122.3517, 47.6159 ]
  }
}
```

## Codebeispiele
<a name="near-code"></a>

Um ein Codebeispiel für die Verwendung des `$near` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function findNearbyRestaurants() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const restaurants = db.collection('usarestaurants');

  // Create 2dsphere index
  await restaurants.createIndex({ "location": "2dsphere" });

  const result = await restaurants.find({
    location: {
      $near: {
        $geometry: {
          type: "Point",
          coordinates: [-122.3516, 47.6156]
        },
        $maxDistance: 100,
        $minDistance: 10
      }
    }
  }).toArray();

  console.log(result);

  client.close();
}

findNearbyRestaurants();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def find_nearby_restaurants():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client['test']
    restaurants = db['usarestaurants']

    # Create 2dsphere index
    restaurants.create_index([("location", "2dsphere")])

    result = list(restaurants.find({
        'location': {
            '$near': {
                '$geometry': {
                    'type': 'Point',
                    'coordinates': [-122.3516, 47.6156]
                },
                '$maxDistance': 100,
                '$minDistance': 10
            }
        }
    }))

    print(result)

    client.close()

find_nearby_restaurants()
```

------

# \$1nearSphere
<a name="nearSphere"></a>

Der `$nearSphere` Operator in Amazon DocumentDB wird verwendet, um Dokumente zu finden, die sich innerhalb einer bestimmten Entfernung von einem Geodatenpunkt befinden. Dieser Operator ist besonders nützlich für geografische Abfragen, z. B. für die Suche nach allen Restaurants in einem bestimmten Umkreis eines bestimmten Standorts.

**Parameter**
+ `$geometry`: Ein GeoJSON-Objekt, das den Referenzpunkt darstellt. Muss ein `Point` Objekt mit `coordinates` Feldern `type` und sein.
+ `$minDistance`: (optional) Der Mindestabstand (in Metern) vom Referenzpunkt, den Dokumente haben müssen.
+ `$maxDistance`: (optional) Der maximale Abstand (in Metern) vom Referenzpunkt, den Dokumente haben müssen.

## Beispiel (MongoDB Shell)
<a name="nearSphere-examples"></a>

In diesem Beispiel finden wir alle Restaurants im Umkreis von 2 Kilometern (2000 Metern) von einem bestimmten Ort in Seattle, WA.

**Erstellen Sie Beispieldokumente**

```
db.usarestaurants.insert([
  {
    name: "Noodle House",
    location: { type: "Point", coordinates: [-122.3516, 47.6156] }
  },
  {
    name: "Pike Place Grill",
    location: { type: "Point", coordinates: [-122.3403, 47.6101] }
  },
  {
    name: "Seattle Coffee Co.",
    location: { type: "Point", coordinates: [-122.3339, 47.6062] }
  }
]);
```

**Beispiel für eine Abfrage**

```
db.usarestaurants.find({
  location: {
    $nearSphere: {
      $geometry: {
        type: "Point",
        coordinates: [-122.3516, 47.6156]
      },
      $minDistance: 1,
      $maxDistance: 2000
    }
  }
}, {
  name: 1
});
```

**Ausgabe**

```
{ "_id" : ObjectId("611f3da985009a81ad38e74b"), "name" : "Noodle House" }
{ "_id" : ObjectId("611f3da985009a81ad38e74c"), "name" : "Pike Place Grill" }
```

## Codebeispiele
<a name="nearSphere-code"></a>

Um ein Codebeispiel für die Verwendung des `$nearSphere` Befehls anzuzeigen, wählen Sie die Registerkarte für die Sprache, die Sie verwenden möchten:

------
#### [ Node.js ]

```
const { MongoClient } = require('mongodb');

async function findNearbyRestaurants() {
  const client = await MongoClient.connect('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');
  const db = client.db('test');
  const restaurants = db.collection('usarestaurants');

  const result = await restaurants.find({
    location: {
      $nearSphere: {
        $geometry: {
          type: "Point",
          coordinates: [-122.3516, 47.6156]
        },
        $minDistance: 1,
        $maxDistance: 2000
      }
    }
  }, {
    projection: { name: 1 }
  }).toArray();

  console.log(result);
  client.close();
}

findNearbyRestaurants();
```

------
#### [ Python ]

```
from pymongo import MongoClient

def find_nearby_restaurants():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')
    db = client.test
    restaurants = db.usarestaurants

    result = list(restaurants.find({
        'location': {
            '$nearSphere': {
                '$geometry': {
                    'type': 'Point',
                    'coordinates': [-122.3516, 47.6156]
                },
                '$minDistance': 1,
                '$maxDistance': 2000
            }
        }
    }, {
        'name': 1
    }))

    print(result)
    client.close()

find_nearby_restaurants()
```

------