Komma igång med SQL-frågorGetting started with SQL queries

GÄLLER för: SQL API

I Azure Cosmos DB SQL API-konton finns det två sätt att läsa data:In Azure Cosmos DB SQL API accounts, there are two ways to read data:

Punkt läsningar – du kan göra en nyckel/värde-sökning på ett enskilt objekt-ID och en partitionsnyckel.Point reads - You can do a key/value lookup on a single item ID and partition key. Kombinationen av objekt-ID och partitionsnyckel är nyckeln och själva objektet är värdet.The item ID and partition key combination is the key and the item itself is the value. För ett dokument med 1 KB läser vi vanligt vis kostnad 1 begär ande enhet med en svars tid under 10 MS.For a 1 KB document, point reads typically cost 1 request unit with a latency under 10 ms. Punkt läsningar returnerar ett enskilt objekt.Point reads return a single item.

Här följer några exempel på hur du gör punkt läsningar med varje SDK:Here are some examples of how to do Point reads with each SDK:

SQL-frågor – du kan fråga efter data genom att skriva frågor med hjälp av STRUCTURED Query Language (SQL) som ett JSON-frågespråk.SQL queries - You can query data by writing queries using the Structured Query Language (SQL) as a JSON query language. Frågor kostar alltid att vara minst 2,3 enheter för programbegäran och i allmänhet har de en högre och mer varierande svars tid än punkt läsningar.Queries always cost at least 2.3 request units and, in general, will have a higher and more variable latency than point reads. Frågor kan returnera många objekt.Queries can return many items.

De flesta Läs tunga arbets belastningar på Azure Cosmos DB använda en kombination av både punkt läsningar och SQL-frågor.Most read-heavy workloads on Azure Cosmos DB use a combination of both point reads and SQL queries. Om du bara behöver läsa ett enskilt objekt är punkt läsningarna billigare och snabbare än frågor.If you just need to read a single item, point reads are cheaper and faster than queries. Punkt läsningar behöver inte använda frågemotor för att få åtkomst till data och kan läsa data direkt.Point reads don't need to use the query engine to access data and can read the data directly. Naturligtvis är det inte möjligt för alla arbets belastningar att enbart läsa data med hjälp av punkt läsningar, så stöd för SQL som frågespråk och schema-oberoende indexering ger ett mer flexibelt sätt att komma åt dina data.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.

Här följer några exempel på hur du gör SQL-frågor med varje SDK:Here are some examples of how to do SQL queries with each SDK:

Resten av det här dokumentet visar hur du kommer igång med att skriva SQL-frågor i Azure Cosmos DB.The remainder of this doc shows how to get started writing SQL queries in Azure Cosmos DB. SQL-frågor kan köras via antingen SDK eller Azure Portal.SQL queries can be run through either the SDK or Azure portal.

Ladda upp exempel dataUpload sample data

I ditt SQL API Cosmos DB-konto öppnar du datautforskaren för att skapa en behållare med namnet Families .In your SQL API Cosmos DB account, open the Data Explorer to create a container called Families. När behållaren har skapats använder du data struktur listan för att hitta och öppna den.After the container is created, use the data structures browser, to find and open it. I din Families behållare visas Items alternativet direkt under namnet på behållaren.In your Families container, you will see the Items option right below the name of the container. Öppna det här alternativet så visas en knapp i meny raden i mitten av skärmen för att skapa ett nytt objekt.Open this option and you'll see a button, in the menu bar in center of the screen, to create a 'New Item'. Du kommer att använda den här funktionen för att skapa JSON-objekten nedan.You will use this feature to create the JSON items below.

Skapa JSON-objektCreate JSON items

Följande 2 JSON-objekt är dokument om Andersen-och Wakefield-familjer.The following 2 JSON items are documents about the Andersen and Wakefield families. De omfattar föräldrar, barn och deras hus djur, adress och registrerings information.They include parents, children and their pets, address, and registration information.

Det första objektet har strängar, siffror, booleska värden, matriser och kapslade egenskaper: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
}

Det andra objektet använder givenName och familyName i stället för firstName och 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
}

Fråga JSON-objektenQuery the JSON items

Prova några frågor mot JSON-data för att förstå några av de viktigaste aspekterna i Azure Cosmos DB SQL-frågespråket.Try a few queries against the JSON data to understand some of the key aspects of Azure Cosmos DB's SQL query language.

Följande fråga returnerar de objekt där id fältet matchar AndersenFamily .The following query returns the items where the id field matches AndersenFamily. Eftersom det är en SELECT * fråga är resultatet av frågan det fullständiga JSON-objektet.Since it's a SELECT * query, the output of the query is the complete JSON item. Mer information om SELECT-syntax finns i Select Statement.For more information about SELECT syntax, see SELECT statement.

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

Frågeresultatet är: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
    }]

Följande fråga formaterar om JSON-utdata till en annan form.The following query reformats the JSON output into a different shape. Frågan Projects ett nytt JSON Family -objekt med två markerade fält, Name och City när adressens ort är samma som 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" matchar det här ärendet."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

Frågeresultatet är:The query results are:

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

Följande fråga returnerar alla namn på underordnade objekt i den familj vars id matchningar WakefieldFamily beställs efter ort.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

Resultatet är:The results are:

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

KommentarerRemarks

I föregående exempel visas flera aspekter av Cosmos DB frågespråket:The preceding examples show several aspects of the Cosmos DB query language:

  • Eftersom SQL API fungerar med JSON-värden, hanterar den Tree-formade entiteter i stället för rader och kolumner.Since SQL API works on JSON values, it deals with tree-shaped entities instead of rows and columns. Du kan referera till trädnoden i godtyckligt djup, som Node1.Node2.Node3…..Nodem liknar referensen för två delar av <table>.<column> i 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.

  • Eftersom frågespråket fungerar med schemabaserade data, måste typ systemet bindas dynamiskt.Because the query language works with schemaless data, the type system must be bound dynamically. Samma uttryck kan ge olika typer på olika objekt.The same expression could yield different types on different items. Resultatet av en fråga är ett giltigt JSON-värde, men det är inte säkert att det är ett fast schema.The result of a query is a valid JSON value, but isn't guaranteed to be of a fixed schema.

  • Azure Cosmos DB stöder endast strikta JSON-objekt.Azure Cosmos DB supports strict JSON items only. Typsystem och uttryck är begränsade till att endast hantera JSON-typer.The type system and expressions are restricted to deal only with JSON types. Mer information finns i JSON- specifikationen.For more information, see the JSON specification.

  • En Cosmos-behållare är en schema fri samling med JSON-objekt.A Cosmos container is a schema-free collection of JSON items. Relationerna i och över behållar objekt samlas in implicit genom inne slutning, inte av primär nyckel och sekundär nyckel relationer.The relations within and across container items are implicitly captured by containment, not by primary key and foreign key relations. Den här funktionen är viktig för kopplingar inom objekt som beskrivs i kopplingar i Azure Cosmos DB.This feature is important for the intra-item joins that are described in Joins in Azure Cosmos DB.

Nästa stegNext steps