Fråga efter objekt i Azure Cosmos DB för NoSQL med hjälp av .NET

GÄLLER FÖR: NoSQL

Objekt i Azure Cosmos DB representerar entiteter som lagras i en container. I API:et för NoSQL består ett objekt av JSON-formaterade data med en unik identifierare. När du utfärdar frågor med hjälp av API:et för NoSQL returneras resultatet som en JSON-matris med JSON-dokument.

Köra frågor mot objekt med HJÄLP av SQL

Azure Cosmos DB for NoSQL stöder användning av Structured Query Language (SQL) för att utföra frågor på objekt i containrar. En enkel SQL-fråga som SELECT * FROM products returnerar alla objekt och egenskaper från en container. Frågor kan vara ännu mer komplexa och innehålla specifika fältprojektioner, filter och andra vanliga SQL-satser:

SELECT 
    p.name, 
    p.description AS copy
FROM 
    products p 
WHERE 
    p.price > 500

Mer information om SQL-syntaxen för Azure Cosmos DB för NoSQL finns i Komma igång med SQL-frågor.

Fråga ett objekt

Anteckning

Exemplen i den här artikeln förutsätter att du redan har definierat en C#-typ som representerar dina data med namnet Product:

// C# record type for items in the container
public record Product(
    string id,
    string category,
    string name,
    int quantity,
    bool sale
);

Om du vill fråga efter objekt i en container anropar du någon av följande metoder:

• GetItemQueryIterator<>
• GetItemLinqQueryable<>

Fråga objekt med hjälp av en SQL-fråga asynkront

Det här exemplet skapar en SQL-fråga med en enkel sträng, hämtar en feed-iterator och använder sedan kapslade loopar för att iterera över resultat. Den yttre while-loopen itererar genom resultatsidor, medan den inre foreach-loopen itererar över resultaten på en sida.

// Query multiple items from container
using FeedIterator<Product> feed = container.GetItemQueryIterator<Product>(
    queryText: "SELECT * FROM products WHERE p.quantity > 10"
);

// Iterate query result pages
while (feed.HasMoreResults)
{
    FeedResponse<Product> response = await feed.ReadNextAsync();

    // Iterate query results
    foreach (Product item in response)
    {
        Console.WriteLine($"Found item:\t{item.name}");
    }
}

Metoden Container.GetItemQueryIterator<> returnerar en FeedIterator<> som används för att iterera genom flersidiga resultat. Egenskapen HasMoreResults anger om det finns fler resultatsidor kvar. Metoden ReadNextAsync hämtar nästa sida med resultat som en uppräkningsbar som sedan används i en loop för att iterera över resultat.

Du kan också använda QueryDefinition för att skapa en SQL-fråga med parametriserade indata:

// Build query definition
var parameterizedQuery = new QueryDefinition(
    query: "SELECT * FROM products p WHERE p.quantity > @quantity"
)
    .WithParameter("@quantity", 10);

// Query multiple items from container
using FeedIterator<Product> filteredFeed = container.GetItemQueryIterator<Product>(
    queryDefinition: parameterizedQuery
);

// Iterate query result pages
while (filteredFeed.HasMoreResults)
{
    FeedResponse<Product> response = await filteredFeed.ReadNextAsync();

    // Iterate query results
    foreach (Product item in response)
    {
        Console.WriteLine($"Found item:\t{item.name}");
    }
}

Tips

Parametriserade indatavärden kan förhindra många vanliga SQL-frågeinmatningsattacker.

Fråga objekt med LINQ asynkront

I det här exemplet används ett IQueryable<> -objekt för att konstruera en språkintegrerad fråga (LINQ). Resultatet itereras sedan över med hjälp av en feed-iterator.

// Get LINQ IQueryable object
IOrderedQueryable<Product> queryable = container.GetItemLinqQueryable<Product>();

// Construct LINQ query
var matches = queryable
    .Where(p => p.quantity > 10);

// Convert to feed iterator
using FeedIterator<Product> linqFeed = matches.ToFeedIterator();

// Iterate query result pages
while (linqFeed.HasMoreResults)
{
    FeedResponse<Product> response = await linqFeed.ReadNextAsync();

    // Iterate query results
    foreach (Product item in response)
    {
        Console.WriteLine($"Matched item:\t{item.name}");
    }
}

Metoden Container.GetItemLinqQueryable<> skapar en IQueryable för att skapa LINQ-frågan. ToFeedIterator<> Sedan används metoden för att konvertera LINQ-frågeuttrycket till en FeedIterator<>.

Tips

Du kan iterera över , men den IQueryable<>här åtgärden är synkron. ToFeedIterator<> Använd metoden för att samla in resultat asynkront.

Nästa steg

Nu när du har frågat flera objekt kan du prova någon av våra självstudier från slutpunkt till slutpunkt med API:et för NoSQL.

Skapa en app som frågar och lägger till data i Azure Cosmos DB för NoSQL