Aan de slag met SQL-query'sGetting started with SQL queries

VAN TOEPASSING OP: SQL-API

In Azure Cosmos DB SQL-API-accounts zijn er twee manieren om gegevens te lezen:In Azure Cosmos DB SQL API accounts, there are two ways to read data:

Punt Lees bewerkingen : u kunt een sleutel/waarde zoeken op één item-id en partitie sleutel.Point reads - You can do a key/value lookup on a single item ID and partition key. De combi natie van item-id en partitie sleutel is de sleutel en het item zelf is de waarde.The item ID and partition key combination is the key and the item itself is the value. Voor een 1 KB-document wordt bij het lezen van punten doorgaans de aanvraag eenheid kosten 1 berekend met een latentie van 10 MS.For a 1 KB document, point reads typically cost 1 request unit with a latency under 10 ms. Punt lezen retourneert één item.Point reads return a single item.

Hier volgen enkele voor beelden van hoe u met elke SDK punt Lees bewerkingen kunt uitvoeren:Here are some examples of how to do Point reads with each SDK:

SQL-query's : u kunt gegevens opvragen door query's te schrijven met behulp van de STRUCTURED query language (SQL) als een JSON-query taal.SQL queries - You can query data by writing queries using the Structured Query Language (SQL) as a JSON query language. Query's kosten altijd ten minste 2,3 aanvraag eenheden en, in het algemeen, heeft een hogere en meer variabele latentie dan lees punten.Queries always cost at least 2.3 request units and, in general, will have a higher and more variable latency than point reads. Query's kunnen veel items retour neren.Queries can return many items.

De meeste Lees-en zware werk belastingen op Azure Cosmos DB gebruiken een combi natie van zowel lees-als SQL-query's.Most read-heavy workloads on Azure Cosmos DB use a combination of both point reads and SQL queries. Als u slechts één item hoeft te lezen, zijn punt lezen goed koper en sneller dan query's.If you just need to read a single item, point reads are cheaper and faster than queries. Punt Lees bewerkingen hoeven de query-engine niet te gebruiken voor toegang tot gegevens en kunnen de gegevens rechtstreeks lezen.Point reads don't need to use the query engine to access data and can read the data directly. Het is natuurlijk niet mogelijk om alle werk belastingen exclusief gegevens te lezen met behulp van punt Lees bewerkingen, zodat SQL als query taal en indexering van het neutraal een flexibele manier is om toegang te krijgen tot uw gegevens.Of course, it's not possible for all workloads to exclusively read data using point reads, so support of SQL as a query language and schema-agnostic indexing provide a more flexible way to access your data.

Hier volgen enkele voor beelden van hoe u SQL-query's kunt uitvoeren voor elke SDK:Here are some examples of how to do SQL queries with each SDK:

In de rest van dit document ziet u hoe u SQL-query's in Azure Cosmos DB kunt schrijven.The remainder of this doc shows how to get started writing SQL queries in Azure Cosmos DB. SQL-query's kunnen worden uitgevoerd via de SDK of de Azure Portal.SQL queries can be run through either the SDK or Azure portal.

Voorbeeld gegevens uploadenUpload sample data

Open in uw SQL API-account Cosmos DB het Data Explorer om een container te maken Families .In your SQL API Cosmos DB account, open the Data Explorer to create a container called Families. Nadat de container is gemaakt, gebruikt u de gegevens structuren browser om deze te zoeken en te openen.After the container is created, use the data structures browser, to find and open it. In uw Families container ziet u de Items optie rechts onder de naam van de container.In your Families container, you will see the Items option right below the name of the container. Als u deze optie opent, ziet u een knop in de menu balk in het midden van het scherm om een nieuw item te maken.Open this option and you'll see a button, in the menu bar in center of the screen, to create a 'New Item'. U gebruikt deze functie om de volgende JSON-items te maken.You will use this feature to create the JSON items below.

JSON-items makenCreate JSON items

De volgende twee JSON-items zijn documenten over de Wakefield-families.The following 2 JSON items are documents about the Andersen and Wakefield families. Ze omvatten ouders, kinderen en hun huis dieren, adres en registratie gegevens.They include parents, children and their pets, address, and registration information.

Het eerste item heeft teken reeksen, getallen, Booleaanse waarden, matrices en geneste eigenschappen:The first item has strings, numbers, Booleans, arrays, and nested properties:

{
  "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
}

Het tweede item maakt givenName Gebruik familyName van en in plaats van firstName en lastName :The second item uses givenName and familyName instead of firstName and 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
}

De JSON-items opvragenQuery the JSON items

Probeer enkele query's uit op de JSON-gegevens om inzicht te krijgen in de belangrijkste aspecten van de SQL-query taal van Azure Cosmos DB.Try a few queries against the JSON data to understand some of the key aspects of Azure Cosmos DB's SQL query language.

De volgende query retourneert de items waarbij het id veld overeenkomt AndersenFamily .The following query returns the items where the id field matches AndersenFamily. Omdat het een SELECT * query is, is de uitvoer van de query het volledige JSON-item.Since it's a SELECT * query, the output of the query is the complete JSON item. Zie instructie SELECTvoor meer informatie over de syntaxis SELECT.For more information about SELECT syntax, see SELECT statement.

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

De query resultaten zijn:The query results are:

    [{
        "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
    }]

Met de volgende query wordt de JSON-uitvoer in een andere vorm opgemaakt.The following query reformats the JSON output into a different shape. De query projecteert een nieuw JSON Family -object met twee geselecteerde velden Name en City , wanneer de adres plaats hetzelfde is als de status.The query projects a new JSON Family object with two selected fields, Name and City, when the address city is the same as the state. "NY, NY" komt overeen met dit geval."NY, NY" matches this case.

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

De query resultaten zijn:The query results are:

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

Met de volgende query worden alle opgegeven namen van onderliggende items geretourneerd in de familie waarvan de id treffers WakefieldFamily zijn geordend op basis van de plaats.The following query returns all the given names of children in the family whose id matches WakefieldFamily, ordered by city.

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

U ziet deze uitvoer:The results are:

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

OpmerkingenRemarks

In de voor gaande voor beelden worden verschillende aspecten van de Cosmos DB query taal weer gegeven:The preceding examples show several aspects of the Cosmos DB query language:

  • Aangezien de SQL-API werkt op JSON-waarden, worden er in plaats van rijen en kolommen getreede entiteiten behandeld.Since SQL API works on JSON values, it deals with tree-shaped entities instead of rows and columns. U kunt naar de structuur knooppunten op elke wille keurige diepte verwijzen, net als Node1.Node2.Node3…..Nodem bij de tweedelige verwijzing van <table>.<column> in ANSI SQL.You can refer to the tree nodes at any arbitrary depth, like Node1.Node2.Node3…..Nodem, similar to the two-part reference of <table>.<column> in ANSI SQL.

  • Omdat de query taal werkt met schemaloze gegevens, moet het type systeem dynamisch worden gebonden.Because the query language works with schemaless data, the type system must be bound dynamically. Een expressie kan verschillende typen voor verschillende elementen opleveren.The same expression could yield different types on different items. Het resultaat van een query is een geldige JSON-waarde, maar is niet gegarandeerd een vast schema.The result of a query is a valid JSON value, but isn't guaranteed to be of a fixed schema.

  • Azure Cosmos DB biedt alleen ondersteuning voor JSON-items.Azure Cosmos DB supports strict JSON items only. Dit betekent dat het typesysteem en expressies alleen geschikt zijn voor JSON-typen.The type system and expressions are restricted to deal only with JSON types. Zie voor meer informatie de JSON-specificatie.For more information, see the JSON specification.

  • Een Cosmos-container is een schema-gratis verzameling van JSON-items.A Cosmos container is a schema-free collection of JSON items. De relaties binnen en in container items worden impliciet vastgelegd door containment, niet op basis van primaire sleutel en refererende-sleutel relaties.The relations within and across container items are implicitly captured by containment, not by primary key and foreign key relations. Deze functie is belang rijk voor de intra-item-samen voegingen die worden beschreven in samen voegingen in azure Cosmos DB.This feature is important for the intra-item joins that are described in Joins in Azure Cosmos DB.

Volgende stappenNext steps