Erste Schritte mit SQL-Abfragen

  • Artikel
  • 4 Minuten Lesedauer

GILT FÜR: NoSQL

Für Azure Cosmos DB for NoSQL-Konten gibt es zwei Möglichkeiten, Daten zu lesen:

Punktlesevorgänge: Sie können nach einem Schlüssel/Wert anhand einer einzelnen Element-ID und einem Partitionsschlüssel suchen. Die Kombination aus Element-ID und Partitionsschlüssel ist der Schlüssel, und das Element selbst ist der Wert. Für ein Dokument mit einer Größe von 1 KB erfordern Punktlesevorgänge in der Regel eine Anforderungseinheit mit einer Wartezeit von unter 10 Millisekunden. Punktlesevorgänge geben kein Teilelement oder bestimmtes Feld zurück, sondern ein einzelnes ganzes Element.

Hier finden Sie Beispiele für Punktlesevorgänge für die verschiedenen SDKs:

SQL-Abfragen: Sie können Daten auch abfragen, indem Sie mit SQL als JSON-Abfragesprache Abfragen schreiben. Abfragen benötigen immer mindestens 2,3 Anforderungseinheiten. Im Allgemeinen weisen sie auch eine höhere und variablere Wartezeit im Vergleich zu Punktlesevorgängen auf. Abfragen können viele Elemente zurückgeben.

Die meisten leseintensiven Workloads in Azure Cosmos DB verwenden eine Kombination von Punktlesevorgängen und SQL-Abfragen. Wenn Sie nur ein einzelnes Element lesen müssen, sind Punktlesevorgänge günstiger und schneller als Abfragen. Punktlesevorgänge müssen die Abfrage-Engine nicht verwenden, um auf Daten zuzugreifen, und sie können die Daten direkt lesen. Natürlich ist es nicht für alle Workloads möglich, Daten ausschließlich mithilfe von Punktlesevorgängen zu lesen. Die Unterstützung von SQL als Abfragesprache und die vom Schema unabhängige Indexierung bieten also eine flexiblere Möglichkeit, auf Ihre Daten zuzugreifen.

Hier finden Sie Beispiele für SQL-Abfragen für die verschiedenen SDKs:

Im verbleibenden Teil dieser Dokumentation erfahren Sie, wie Sie SQL-Abfragen in Azure Cosmos DB schreiben. SQL-Abfragen können entweder über das SDK oder das Azure-Portal ausgeführt werden.

Hochladen von Beispieldaten

Öffnen Sie in Ihrem API for NoSQL Azure Cosmos DB-Konto den Daten-Explorer, um einen Container mit dem Namen Families zu erstellen. Verwenden Sie nach dem Erstellen des Containers den Datenstrukturbrowser, um ihn zu suchen und zu öffnen. In Ihrem Families-Container wird die Option Items direkt unterhalb des Namens des Containers angezeigt. Öffnen Sie diese Option. Daraufhin wird auf der Menüleiste in der Mitte des Bildschirms eine Schaltfläche angezeigt, mit der Sie ein neues Element erstellen können. Sie verwenden diese Funktion, um die folgenden JSON-Elemente zu erstellen.

Erstellen von JSON-Elementen

Die folgenden beiden JSON-Elemente sind Dokumente zu den Familien „Andersen“ und „Wakefield“. Sie enthalten Eltern, Kinder, Haustiere, Adresse und Registrierungsinformationen.

Das erste Element enthält Zeichenfolgen, Zahlen, boolesche Werte, Arrays und geschachtelte Eigenschaften:

{
  "id": "AndersenFamily",
  "lastName": "Andersen",
  "parents": [
     { "firstName": "Thomas" },
     { "firstName": "Mary Kay"}
  ],
  "children": [
     {
         "firstName": "Henriette Thaulow",
         "gender": "female",
         "grade": 5,
         "pets": [{ "givenName": "Fluffy" }]
     }
  ],
  "address": { "state": "WA", "county": "King", "city": "Seattle" },
  "creationDate": 1431620472,
  "isRegistered": true
}

Das zweite Element verwendet givenName und familyName anstelle von firstName und lastName:

{
  "id": "WakefieldFamily",
  "parents": [
      { "familyName": "Wakefield", "givenName": "Robin" },
      { "familyName": "Miller", "givenName": "Ben" }
  ],
  "children": [
      {
        "familyName": "Merriam",
        "givenName": "Jesse",
        "gender": "female",
        "grade": 1,
        "pets": [
            { "givenName": "Goofy" },
            { "givenName": "Shadow" }
        ]
      },
      {
        "familyName": "Miller",
         "givenName": "Lisa",
         "gender": "female",
         "grade": 8 }
  ],
  "address": { "state": "NY", "county": "Manhattan", "city": "NY" },
  "creationDate": 1431620462,
  "isRegistered": false
}

Abfragen der JSON-Elemente

Führen Sie einige Abfragen für die JSON-Daten aus, um einige der Schlüsselaspekte der SQL-Abfragesprache von Azure Cosmos DB besser zu verstehen.

Die folgende Abfrage gibt die Elemente zurück, in denen das id-Feld dem Text AndersenFamily entspricht. Da es sich um eine SELECT *-Abfrage handelt, ist die Ausgabe der Abfrage das komplette JSON-Element. Weitere Informationen zur SELECT-Syntax finden Sie unter SELECT-Anweisung.

    SELECT *
    FROM Families f
    WHERE f.id = "AndersenFamily"

Die Abfrage hat folgende Ergebnisse:

    [{
        "id": "AndersenFamily",
        "lastName": "Andersen",
        "parents": [
           { "firstName": "Thomas" },
           { "firstName": "Mary Kay"}
        ],
        "children": [
           {
               "firstName": "Henriette Thaulow", "gender": "female", "grade": 5,
               "pets": [{ "givenName": "Fluffy" }]
           }
        ],
        "address": { "state": "WA", "county": "King", "city": "Seattle" },
        "creationDate": 1431620472,
        "isRegistered": true
    }]

Mit der folgenden Abfrage wird die JSON-Ausgabe auf andere Weise neu formatiert. Die Abfrage projiziert ein neues JSON-Objekt Family mit zwei ausgewählten Feldern (Name und City), wenn die Stadt in der Adresse dem Staat entspricht. Dies ist bei „NY, NY“ der Fall.

    SELECT {"Name":f.id, "City":f.address.city} AS Family
    FROM Families f
    WHERE f.address.city = f.address.state

Die Abfrage hat folgende Ergebnisse:

    [{
        "Family": {
            "Name": "WakefieldFamily",
            "City": "NY"
        }
    }]

Die folgende Abfrage gibt alle Vornamen von Kindern der Familie zurück, deren id dem Text WakefieldFamily entspricht, und zwar geordnet nach der Stadt.

    SELECT c.givenName
    FROM Families f
    JOIN c IN f.children
    WHERE f.id = 'WakefieldFamily'
    ORDER BY f.address.city ASC

Die Ergebnisse sind:

    [
      { "givenName": "Jesse" },
      { "givenName": "Lisa"}
    ]

Bemerkungen

Die Beispiele oben zeigen verschiedene Aspekte der Azure Cosmos DB-Abfragesprache:

  • Da API for NoSQL mit JSON-Werten arbeitet, werden baumförmige Entitäten anstelle von Spalten und Zeilen verarbeitet. Sie können auf die Baumknoten in beliebiger Tiefe verweisen, z.B. Node1.Node2.Node3…..Nodem, ähnlich dem zweiteiligen Verweis <table>.<column> in ANSI SQL.

  • Da die Abfragesprache mit schemalosen Daten arbeitet, muss das Typsystem dynamisch gebunden werden. Der gleiche Ausdruck kann unterschiedliche Typen in unterschiedlichen Elementen ergeben. Das Ergebnis einer Abfrage ist ein gültiger JSON-Wert, aber nicht garantiert innerhalb eines festen Schemas.

  • Azure Cosmos DB unterstützt nur strikte JSON-Elemente. Typsystem und Ausdrücke sind auf JSON-Typen beschränkt. Weitere Informationen finden Sie in der JSON-Spezifikation.

  • Ein Azure Cosmos DB-Container ist eine schemalose Sammlung von JSON-Elementen. Die Beziehungen innerhalb und zwischen Containerelementen werden implizit nach Eigenständigkeit erfasst, nicht nach Beziehungen von primären Schlüsseln und Fremdschlüsseln. Dieses Feature ist für die elementinternen Verknüpfungen wichtig, die in Verknüpfungen in Azure Cosmos DBbeschrieben werden.

Nächste Schritte