Tipy k výkonu dotazů pro sady SDK služby Azure Cosmos DB

Omezení volání plánu dotazů

Pokud chcete spustit dotaz, je potřeba sestavit plán dotazu. To obecně představuje síťový požadavek na bránu Azure Cosmos DB, která přidává latenci operace dotazu. Tento požadavek můžete odebrat dvěma způsoby a snížit latenci operace dotazu:

Optimalizace dotazů s jedním oddílem pomocí optimistického přímého spuštění

Azure Cosmos DB NoSQL má optimalizaci s názvem Optimistic Direct Execution (ODE), která může zlepšit efektivitu určitých dotazů NoSQL. Konkrétně dotazy, které nevyžadují distribuci, zahrnují ty, které je možné spouštět v jednom fyzickém oddílu nebo které obsahují odpovědi, které nevyžadují stránkování. Dotazy, které nevyžadují distribuci, můžou s jistotou přeskočit některé procesy, jako je generování plánu dotazů na straně klienta a přepsání dotazů, což snižuje latenci dotazů a náklady na RU. Pokud v požadavku nebo samotném dotazu zadáte klíč oddílu (nebo máte jenom jeden fyzický oddíl) a výsledky dotazu nevyžadují stránkování, může ODE vaše dotazy vylepšit.

Ode je nyní k dispozici v sadě .NET SDK verze 3.38.0 a novější. Při spuštění dotazu a zadání klíče oddílu v požadavku nebo samotném dotazu nebo v databázi je pouze jeden fyzický oddíl, může provádění dotazu využívat výhody ODE. Chcete-li povolit ODE, nastavte EnableOptimisticDirectExecution na hodnotu true v QueryRequestOptions.

Dotazy s jedním oddílem, které obsahují funkce GROUP BY, ORDER BY, DISTINCT a agregační funkce (například součet, střední hodnota, minimum a maximum), můžou výrazně těžit z použití ODE. V situacích, kdy dotaz cílí na více oddílů nebo stále vyžaduje stránkování, ale latence odpovědi na dotazy a náklady na RU můžou být vyšší než bez použití ODE. Proto při použití odepisu doporučujeme:

• Zadejte klíč oddílu v samotném volání nebo dotazu.
• Ujistěte se, že se velikost dat nezvětšila a způsobila rozdělení oddílu.
• Ujistěte se, že výsledky dotazu nevyžadují stránkování, abyste získali plnou výhodu ODE.

Tady je několik příkladů jednoduchých dotazů na jeden oddíl, které můžou využívat ODE:

- SELECT * FROM r
- SELECT * FROM r WHERE r.pk == "value"
- SELECT * FROM r WHERE r.id > 5
- SELECT r.id FROM r JOIN id IN r.id
- SELECT TOP 5 r.id FROM r ORDER BY r.id
- SELECT * FROM r WHERE r.id > 5 OFFSET 5 LIMIT 3 

V některých případech můžou dotazy na jeden oddíl vyžadovat distribuci, pokud se počet datových položek v průběhu času zvýší a databáze Azure Cosmos DB rozdělí oddíl. Mezi příklady dotazů, ve kterých by k tomu mohlo dojít, patří:

- SELECT Count(r.id) AS count_a FROM r
- SELECT DISTINCT r.id FROM r
- SELECT Max(r.a) as min_a FROM r
- SELECT Avg(r.a) as min_a FROM r
- SELECT Sum(r.a) as sum_a FROM r WHERE r.a > 0 

Některé složité dotazy můžou vždy vyžadovat distribuci, i když cílí na jeden oddíl. Mezi příklady takových dotazů patří:

- SELECT Sum(id) as sum_id FROM r JOIN id IN r.id
- SELECT DISTINCT r.id FROM r GROUP BY r.id
- SELECT DISTINCT r.id, Sum(r.id) as sum_a FROM r GROUP BY r.id
- SELECT Count(1) FROM (SELECT DISTINCT r.id FROM root r)
- SELECT Avg(1) AS avg FROM root r 

Je důležité si uvědomit, že ODE nemusí vždy načíst plán dotazu a v důsledku toho nemůže zakázat nebo vypnout nepodporované dotazy. Například po rozdělení oddílů už tyto dotazy nemají nárok na ODE a proto se nespustí, protože vyhodnocení plánu dotazů na straně klienta je zablokuje. Aby se zajistila kompatibilita nebo kontinuita služeb, je důležité zajistit, aby se u ODE používaly pouze dotazy, které jsou plně podporované ve scénářích bez odepisu (tj. provádějí a vytvářejí správný výsledek v obecném případě s více oddíly).

Použití generování místního plánu dotazů

Sada SQL SDK obsahuje nativní ServiceInterop.dll k analýze a optimalizaci dotazů místně. ServiceInterop.dll se podporuje jenom na platformě Windows x64 . Následující typy aplikací ve výchozím nastavení používají 32bitové zpracování hostitele. Pokud chcete změnit zpracování hostitele na 64bitové zpracování, postupujte podle tohoto postupu na základě typu aplikace:

• U spustitelných aplikací můžete změnit zpracování hostitele nastavením cíle platformy na x64 v okně Vlastnosti projektu na kartě Sestavení .

• U projektů testů založených na VSTest můžete změnit zpracování hostitele tak, že v nabídce Visual Studio Test vyberete výchozí architekturu procesoru nastavení testu>>jako X64.

• U místně nasazených ASP.NET webových aplikací můžete změnit zpracování hostitele tak, že vyberete Možnost Použít 64bitovou verzi služby IIS Express pro weby a projekty v části Nástroje>Možnosti>projektů a webových projektů řešení.>

• U ASP.NET webových aplikací nasazených v Azure můžete změnit zpracování hostitele výběrem 64bitové platformy v nastavení aplikace na webu Azure Portal.

Použití dotazů s jedním oddílem

using (FeedIterator<MyItem> feedIterator = container.GetItemQueryIterator<MyItem>(
    "SELECT * FROM c WHERE c.city = 'Seattle' AND c.state = 'Washington'"
{
    // ...
}

using (FeedIterator<MyItem> feedIterator = container.GetItemQueryIterator<MyItem>(
    "SELECT * FROM c WHERE c.city = 'Seattle'",
    requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Washington")}))
{
    // ...
}

IDocumentQuery<dynamic> query = client.CreateDocumentQuery(
    UriFactory.CreateDocumentCollectionUri(DatabaseName, CollectionName), 
    "SELECT * FROM c WHERE c.city = 'Seattle'", 
    new FeedOptions 
    { 
        PartitionKey = new PartitionKey("Washington")
    }).AsDocumentQuery();

Vyhněte se zbytečnému opětovnému vytvoření iterátoru.

Pokud aktuální komponenta spotřebovává všechny výsledky dotazu, nemusíte iterátor znovu vytvářet s pokračováním pro každou stránku. Vždy dáváte přednost úplnému vyprázdnění dotazu, pokud stránkování neřídí jiná volající komponenta:

using (FeedIterator<MyItem> feedIterator = container.GetItemQueryIterator<MyItem>(
    "SELECT * FROM c WHERE c.city = 'Seattle'",
    requestOptions: new QueryRequestOptions() { PartitionKey = new PartitionKey("Washington")}))
{
    while (feedIterator.HasMoreResults) 
    {
        foreach(MyItem document in await feedIterator.ReadNextAsync())
        {
            // Iterate through documents
        }
    }
}

IDocumentQuery<dynamic> query = client.CreateDocumentQuery(
    UriFactory.CreateDocumentCollectionUri(DatabaseName, CollectionName), 
    "SELECT * FROM c WHERE c.city = 'Seattle'", 
    new FeedOptions 
    { 
        PartitionKey = new PartitionKey("Washington")
    }).AsDocumentQuery();
while (query.HasMoreResults) 
{
    foreach(Document document in await queryable.ExecuteNextAsync())
    {
        // Iterate through documents
    }
}

Ladění stupně paralelismu

using (FeedIterator<MyItem> feedIterator = container.GetItemQueryIterator<MyItem>(
    "SELECT * FROM c WHERE c.city = 'Seattle'",
    requestOptions: new QueryRequestOptions() { 
        PartitionKey = new PartitionKey("Washington"),
        MaxConcurrency = -1 }))
{
    // ...
}

IDocumentQuery<dynamic> query = client.CreateDocumentQuery(
    UriFactory.CreateDocumentCollectionUri(DatabaseName, CollectionName), 
    "SELECT * FROM c WHERE c.city = 'Seattle'", 
    new FeedOptions 
    { 
        MaxDegreeOfParallelism = -1, 
        EnableCrossPartitionQuery = true 
    }).AsDocumentQuery();

Předpokládejme, že

• D = Výchozí maximální počet paralelních úloh (= celkový počet procesorů v klientském počítači)
• P = Maximální počet paralelních úloh zadaný uživatelem
• N = počet oddílů, které je potřeba navštívit při odpovídání na dotaz

Následují důsledky chování paralelních dotazů pro různé hodnoty P.

• (P == 0) => Sériový režim
• (P == 1) => Maximálně jeden úkol
• (P > 1) => minimální (P, N) paralelní úkoly
• (P < 1) => minimální (N, D) paralelní úkoly

Vyladění velikosti stránky

Když vydáte dotaz SQL, výsledky se vrátí segmentovaným způsobem, pokud je sada výsledků příliš velká.

using (FeedIterator<MyItem> feedIterator = container.GetItemQueryIterator<MyItem>(
    "SELECT * FROM c WHERE c.city = 'Seattle'",
    requestOptions: new QueryRequestOptions() { 
        PartitionKey = new PartitionKey("Washington"),
        MaxItemCount = 1000}))
{
    // ...
}

IQueryable<dynamic> authorResults = client.CreateDocumentQuery(
    UriFactory.CreateDocumentCollectionUri(DatabaseName, CollectionName), 
    "SELECT p.Author FROM Pages p WHERE p.Title = 'About Seattle'", 
    new FeedOptions { MaxItemCount = 1000 });

Při spuštění dotazu se výsledná data odesílají v paketu TCP. Pokud zadáte příliš nízkou hodnotu pro MaxItemCount, počet cest potřebných k odeslání dat v paketu TCP je vysoký, což má vliv na výkon. Pokud si tedy nejste jistí, jakou hodnotu pro vlastnost nastavit MaxItemCount , je nejlepší ji nastavit na -1 a nechat sadu SDK zvolit výchozí hodnotu.

Vyladění velikosti vyrovnávací paměti

using (FeedIterator<MyItem> feedIterator = container.GetItemQueryIterator<MyItem>(
    "SELECT * FROM c WHERE c.city = 'Seattle'",
    requestOptions: new QueryRequestOptions() { 
        PartitionKey = new PartitionKey("Washington"),
        MaxBufferedItemCount = -1}))
{
    // ...
}

IQueryable<dynamic> authorResults = client.CreateDocumentQuery(
    UriFactory.CreateDocumentCollectionUri(DatabaseName, CollectionName), 
    "SELECT p.Author FROM Pages p WHERE p.Title = 'About Seattle'", 
    new FeedOptions { MaxBufferedItemCount = -1 });

Předběžné načítání funguje stejně bez ohledu na stupeň paralelismu a pro data ze všech oddílů existuje jedna vyrovnávací paměť.

Další kroky

Další informace o výkonu pomocí sady .NET SDK:

• Osvědčené postupy pro sadu .NET SDK služby Azure Cosmos DB
• Tipy pro zvýšení výkonu pro sadu .NET SDK služby Azure Cosmos DB V3
• Tipy pro zvýšení výkonu pro sadu .NET SDK služby Azure Cosmos DB V2

Omezení volání plánu dotazů

Pokud chcete spustit dotaz, je potřeba sestavit plán dotazu. To obecně představuje síťový požadavek na bránu Azure Cosmos DB, která přidává latenci operace dotazu.

Použití ukládání do mezipaměti plánu dotazů

Plán dotazu s oborem dotazu na jeden oddíl je uložen v mezipaměti klienta. Tím se eliminuje nutnost volat bráně, aby se po prvním volání načetl plán dotazu. Klíčem plánu dotazů v mezipaměti je řetězec dotazu SQL. Musíte se ujistit, že je dotaz parametrizovaný. Pokud ne, vyhledávání v mezipaměti plánu dotazů bude často neúspěšné, protože řetězec dotazu pravděpodobně nebude identický napříč voláními. Ukládání plánů dotazů do mezipaměti je ve výchozím nastavení povolené pro sadu Java SDK verze 4.20.0 a vyšší a pro sadu Spring Data Azure Cosmos DB SDK verze 3.13.0 a vyšší.

Použití parametrizovaných dotazů na jeden oddíl

U parametrizovaných dotazů, které jsou vymezeny na klíč oddílu s parametrem setPartitionKey CosmosQueryRequestOptions a neobsahují žádné agregace (včetně Distinct, DCount, Group By), je možné se vyhnout plánu dotazu:

CosmosQueryRequestOptions options = new CosmosQueryRequestOptions();
options.setPartitionKey(new PartitionKey("Washington"));

ArrayList<SqlParameter> paramList = new ArrayList<SqlParameter>();
paramList.add(new SqlParameter("@city", "Seattle"));
SqlQuerySpec querySpec = new SqlQuerySpec(
        "SELECT * FROM c WHERE c.city = @city",
        paramList);

//  Sync API
CosmosPagedIterable<MyItem> filteredItems = 
    container.queryItems(querySpec, options, MyItem.class);

//  Async API
CosmosPagedFlux<MyItem> filteredItems = 
    asyncContainer.queryItems(querySpec, options, MyItem.class);

Ladění stupně paralelismu

Paralelní dotazy fungují dotazováním více oddílů paralelně. Data z jednotlivého děleného kontejneru se ale načítají sériově s ohledem na dotaz. Proto pomocí setMaxDegreeOfParallelism nastavte CosmosQueryRequestOptions hodnotu na počet oddílů, které máte. Pokud neznáte počet oddílů, můžete použít setMaxDegreeOfParallelism k nastavení vysokého čísla a systém jako maximální stupeň paralelismu zvolí minimum (počet oddílů, zadaný vstup uživatelem). Nastavení hodnoty -1 umožní sadě SDK rozhodnout o optimální souběžnosti.

Je důležité si uvědomit, že paralelní dotazy přinášejí nejlepší výhody, pokud se data rovnoměrně distribuují napříč všemi oddíly s ohledem na dotaz. Pokud je dělený kontejner rozdělený tak, aby se všechna nebo většina dat vrácených dotazem soustředila do několika oddílů (v nejhorším případě jeden oddíl), výkon dotazu by byl snížený.

CosmosQueryRequestOptions options = new CosmosQueryRequestOptions();
options.setPartitionKey(new PartitionKey("Washington"));
options.setMaxDegreeOfParallelism(-1);

// Define the query

//  Sync API
CosmosPagedIterable<MyItem> filteredItems = 
    container.queryItems(querySpec, options, MyItem.class);

//  Async API
CosmosPagedFlux<MyItem> filteredItems = 
    asyncContainer.queryItems(querySpec, options, MyItem.class);

Předpokládejme, že

• D = Výchozí maximální počet paralelních úloh (= celkový počet procesorů v klientském počítači)
• P = Maximální počet paralelních úloh zadaný uživatelem
• N = počet oddílů, které je potřeba navštívit při odpovídání na dotaz

Následují důsledky chování paralelních dotazů pro různé hodnoty P.

• (P == 0) => Sériový režim
• (P == 1) => Maximálně jeden úkol
• (P > 1) => minimální (P, N) paralelní úkoly
• (P == -1) => Min (N, D) paralelní úkoly

Vyladění velikosti stránky

Když vydáte dotaz SQL, výsledky se vrátí segmentovaným způsobem, pokud je sada výsledků příliš velká. Ve výchozím nastavení se výsledky vrátí v blocích 100 položek nebo 4 MB, podle toho, které omezení se dosáhne prvního. Zvětšením velikosti stránky se sníží počet požadovaných odezv a zvýší se výkon dotazů, které vracejí více než 100 položek. Pokud si nejste jistí, jakou hodnotu nastavit, je 1000 obvykle dobrou volbou. Při nárůstu velikosti stránky se zvýší spotřeba paměti, takže pokud je zatížení citlivé na paměť, zvažte nižší hodnotu.

K definování velikosti stránky můžete použít pageSize parametr pro iterableByPage() synchronizační rozhraní API a byPage() asynchronní rozhraní API:

//  Sync API
Iterable<FeedResponse<MyItem>> filteredItemsAsPages =
    container.queryItems(querySpec, options, MyItem.class).iterableByPage(continuationToken,pageSize);

for (FeedResponse<MyItem> page : filteredItemsAsPages) {
    for (MyItem item : page.getResults()) {
        //...
    }
}

//  Async API
Flux<FeedResponse<MyItem>> filteredItemsAsPages =
    asyncContainer.queryItems(querySpec, options, MyItem.class).byPage(continuationToken,pageSize);

filteredItemsAsPages.map(page -> {
    for (MyItem item : page.getResults()) {
        //...
    }
}).subscribe();

Vyladění velikosti vyrovnávací paměti

Paralelní dotaz je navržený tak, aby předem načítá výsledky, zatímco klient zpracovává aktuální dávku výsledků. Předběžné načítání pomáhá při celkovém zlepšení latence dotazu. setMaxBufferedItemCount v CosmosQueryRequestOptions limitech počtu předem načtených výsledků. Pokud chcete maximalizovat předběžné načítání, nastavte maxBufferedItemCount na vyšší číslo, než pageSize je (POZNÁMKA: To může také vést k vysokému využití paměti). Chcete-li minimalizovat předběžné načtení, nastavte hodnotu rovna maxBufferedItemCount hodnotě pageSize. Pokud tuto hodnotu nastavíte na hodnotu 0, systém automaticky určí počet položek, které se mají ukládat do vyrovnávací paměti.

CosmosQueryRequestOptions options = new CosmosQueryRequestOptions();
options.setPartitionKey(new PartitionKey("Washington"));
options.setMaxBufferedItemCount(-1);

// Define the query

//  Sync API
CosmosPagedIterable<MyItem> filteredItems = 
    container.queryItems(querySpec, options, MyItem.class);

//  Async API
CosmosPagedFlux<MyItem> filteredItems = 
    asyncContainer.queryItems(querySpec, options, MyItem.class);

Předběžné načítání funguje stejně bez ohledu na stupeň paralelismu a pro data ze všech oddílů existuje jedna vyrovnávací paměť.

Další kroky

Další informace o výkonu pomocí sady Java SDK:

• Osvědčené postupy pro sadu Azure Cosmos DB Java SDK verze 4
• Tipy pro zvýšení výkonu pro sadu Azure Cosmos DB Java SDK verze 4

Omezení volání plánu dotazů

Pokud chcete spustit dotaz, je potřeba sestavit plán dotazu. To obecně představuje síťový požadavek na bránu Azure Cosmos DB, která přidává latenci operace dotazu. Existuje způsob, jak tento požadavek odebrat a snížit latenci operace dotazu s jedním oddílem. U dotazů s jedním oddílem zadejte hodnotu klíče oddílu pro položku a předejte ji jako argument partition_key :

items = container.query_items(
        query="SELECT * FROM r where r.city = 'Seattle'",
        partition_key="Washington"
    )

Vyladění velikosti stránky

Když vydáte dotaz SQL, výsledky se vrátí segmentovaným způsobem, pokud je sada výsledků příliš velká. Max_item_count umožňuje nastavit maximální počet položek, které se mají vrátit v operaci výčtu.

items = container.query_items(
        query="SELECT * FROM r where r.city = 'Seattle'",
        partition_key="Washington",
        max_item_count=1000
    )

Další kroky

Další informace o používání sady Python SDK pro rozhraní API pro NoSQL:

• Sada Python SDK služby Azure Cosmos DB pro rozhraní API pro NoSQL
• Rychlý start: Klientská knihovna Azure Cosmos DB for NoSQL pro Python

Omezení volání plánu dotazů

Pokud chcete spustit dotaz, je potřeba sestavit plán dotazu. To obecně představuje síťový požadavek na bránu Azure Cosmos DB, která přidává latenci operace dotazu. Existuje způsob, jak tento požadavek odebrat a snížit latenci operace dotazu s jedním oddílem. U dotazů s jedním oddílem, které dotaz rozdělují na jeden oddíl, je možné provést dvěma způsoby.

Použití parametrizovaného výrazu dotazu a zadání klíče oddílu v příkazu dotazu. Dotaz se programově skládá z SELECT * FROM todo t WHERE t.partitionKey = 'Bikes, Touring Bikes':

// find all items with same categoryId (partitionKey)
const querySpec = {
    query: "select * from products p where p.categoryId=@categoryId",
    parameters: [
        {
            name: "@categoryId",
            value: "Bikes, Touring Bikes"
        }
    ]
};

// Get items 
const { resources } = await container.items.query(querySpec).fetchAll();

for (const item of resources) {
    console.log(`${item.id}: ${item.name}, ${item.sku}`);
}

Nebo zadejte partitionKey FeedOptions a předejte ho jako argument:

const querySpec = {
    query: "select * from products p"
};

const { resources } = await container.items.query(querySpec, { partitionKey: "Bikes, Touring Bikes" }).fetchAll();

for (const item of resources) {
    console.log(`${item.id}: ${item.name}, ${item.sku}`);
}

Vyladění velikosti stránky

Když vydáte dotaz SQL, výsledky se vrátí segmentovaným způsobem, pokud je sada výsledků příliš velká. MaxItemCount umožňuje nastavit maximální počet položek, které se mají vrátit v operaci výčtu.

const querySpec = {
    query: "select * from products p where p.categoryId=@categoryId",
    parameters: [
        {
            name: "@categoryId",
            value: items[2].categoryId
        }
    ]
};

const { resources } = await container.items.query(querySpec, { maxItemCount: 1000 }).fetchAll();

for (const item of resources) {
    console.log(`${item.id}: ${item.name}, ${item.sku}`);
}

Další kroky

Další informace o používání sady Node.js SDK pro rozhraní API pro NoSQL:

• Azure Cosmos DB Node.js SDK pro rozhraní API pro NoSQL
• Rychlý start – klientská knihovna Azure Cosmos DB for NoSQL pro Node.js