Query's uitvoeren op items in Azure Cosmos DB for NoSQL met behulp van .NET

Artikel
08/15/2024

VAN TOEPASSING OP: NoSQL

Items in Azure Cosmos DB vertegenwoordigen entiteiten die zijn opgeslagen in een container. In de API voor NoSQL bestaat een item uit JSON-geformatteerde gegevens met een unieke id. Wanneer u query's uitvraagt met behulp van de API voor NoSQL, worden resultaten geretourneerd als een JSON-matrix met JSON-documenten.

Query's uitvoeren op items met SQL

Azure Cosmos DB for NoSQL ondersteunt het gebruik van Structured Query Language (SQL) om query's uit te voeren op items in containers. Een eenvoudige SQL-query retourneert SELECT * FROM products alle items en eigenschappen uit een container. Query's kunnen nog complexer zijn en specifieke veldprojecties, filters en andere algemene SQL-componenten bevatten:

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

Zie Aan de slag met SQL-query's voor meer informatie over de SQL-syntaxis voor Azure Cosmos DB for NoSQL.

Een query uitvoeren op een item

Notitie

In de voorbeelden in dit artikel wordt ervan uitgegaan dat u al een C#-type hebt gedefinieerd om uw gegevens met de naam Product weer te geven:

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

Als u een query wilt uitvoeren op items in een container, roept u een van de volgende methoden aan:

GetItemQueryIterator<>
GetItemLinqQueryable<>

Query's uitvoeren op items met behulp van een SQL-query asynchroon

In dit voorbeeld wordt een SQL-query gemaakt met behulp van een eenvoudige tekenreeks, een feed-iterator opgehaald en vervolgens geneste lussen gebruikt om resultaten te herhalen. De buitenste while-lus doorloopt resultaatpagina's, terwijl de binnenste foreach-lus de resultaten binnen een pagina doorloopt.

// Query multiple items from container
using FeedIterator<Product> feed = container.GetItemQueryIterator<Product>(
    queryText: "SELECT * FROM products p 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}");
    }
}

De methode Container.GetItemQueryIterator<> retourneert een FeedIterator<> methode die wordt gebruikt voor het doorlopen van resultaten met meerdere pagina's. De HasMoreResults eigenschap geeft aan of er meer resultaatpagina's overblijven. De ReadNextAsync methode haalt de volgende pagina met resultaten op als een opsomming die vervolgens in een lus wordt gebruikt om resultaten te herhalen.

U kunt ook QueryDefinition gebruiken om een SQL-query te bouwen met geparameteriseerde invoer:

// 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}");
    }
}

Tip

Geparameteriseerde invoerwaarden kunnen helpen bij het voorkomen van veel veelvoorkomende SQL-queryinjectieaanvallen.

Query's uitvoeren op items met LINQ asynchroon

In dit voorbeeld wordt een IQueryable<> object gebruikt om een LINQ (Language Integrated Query) samen te stellen. De resultaten worden vervolgens ge curseerd over het gebruik van een 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}");
    }
}

De methode Container.GetItemLinqQueryable<> bouwt een IQueryable om de LINQ-query te bouwen. Vervolgens wordt de ToFeedIterator<> methode gebruikt om de LINQ-queryexpressie te converteren naar een FeedIterator<>.

Tip

Hoewel u de bewerking kunt herhalen IQueryable<>, is deze bewerking synchroon. Gebruik de ToFeedIterator<> methode om asynchroon resultaten te verzamelen.

Volgende stappen

Nu u meerdere items hebt opgevraagd, kunt u een van onze end-to-end zelfstudies uitproberen met de API voor NoSQL.

Een app bouwen waarmee gegevens worden opgevraagd en toegevoegd aan Azure Cosmos DB for NoSQL

Share via