Správa zásad indexování v Azure Cosmos DB

Platí pro: ✅ NoSQL

V Azure Cosmos DB se data indexují podle zásad indexování, které jsou definované pro každý kontejner. Výchozí zásady indexování pro nově vytvořené kontejnery u všech řetězců a čísel vynucují indexy rozsahu. Tuto politiku můžete překonat vlastní politikou indexování.

Note

Metoda aktualizace zásad indexování popsaných v tomto článku se vztahuje pouze na Azure Cosmos DB pro NoSQL. Přečtěte si o indexování ve službě Azure Cosmos DB pro MongoDB a sekundárním indexování ve službě Azure Cosmos DB pro Apache Cassandra.

Příklady zásad indexování

Tady je několik příkladů zásad indexování zobrazených ve formátu JSON. Jsou vystavené na portálu Azure ve formátu JSON. Stejné parametry je možné nastavit pomocí Azure CLI nebo jakékoli sady SDK.

Zásady odhlášení pro selektivní vyloučení některých datových cest vlastností

{
    "indexingMode": "consistent",
    "includedPaths": [
        {
            "path": "/*"
        }
    ],
    "excludedPaths": [
        {
            "path": "/path/to/single/excluded/property/?"
        },
        {
            "path": "/path/to/root/of/multiple/excluded/properties/*"
        }
    ]
}

Note

Klíč oddílu (pokud není také /id) není indexovaný, a proto by měl být zahrnut do indexu.
Systémové vlastnosti id a _ts jsou vždy indexovány, pokud je režim indexování účtu cosmos consistent.
Systémové vlastnosti id a _ts nejsou zahrnuty do popisu indexovaných cest zásad kontejneru. Důvodem je návrh, protože tyto systémové vlastnosti jsou ve výchozím nastavení indexovány a toto chování nelze zakázat.

Zásady souhlasu pro selektivní zahrnutí některých vlastnostních cest

{
    "indexingMode": "consistent",
    "includedPaths": [
        {
            "path": "/path/to/included/property/?"
        },
        {
            "path": "/path/to/root/of/multiple/included/properties/*"
        }
    ],
    "excludedPaths": [
        {
            "path": "/*"
        }
    ]
}

Note

Obecně doporučujeme používat zásady indexování založené na principu opt-out. Azure Cosmos DB proaktivně indexuje všechny nové vlastnosti, které mohou být přidány do datového modelu.

Použijte prostorový index pouze na konkrétní vlastnostní cestě

{
    "indexingMode": "consistent",
    "automatic": true,
    "includedPaths": [
        {
            "path": "/*"
        }
    ],
    "excludedPaths": [
        {
            "path": "/_etag/?"
        }
    ],
    "spatialIndexes": [
        {
                    "path": "/path/to/geojson/property/?",
            "types": [
                "Point",
                "Polygon",
                "MultiPolygon",
                "LineString"
            ]
        }
    ]
}

Příklady zásad indexování vektorů

Kromě zahrnutí nebo vyloučení cest pro jednotlivé vlastnosti můžete také zadat vektorový index. Obecně platí, že indexy vektorů by měly být zadány vždy, když VectorDistance se systémová funkce používá k měření podobnosti mezi vektorem dotazu a vektorovou vlastností.

Note

Než budete pokračovat, musíte povolit indexování a vyhledávání vektorů NoSQL ve službě Azure Cosmos DB.

Important

Zásady indexování vektorů musí být na stejné trase jako je definováno v zásadách vektoru kontejneru. Další informace najdete v tématu Zásady vektoru kontejneru.

{
    "indexingMode": "consistent",
    "automatic": true,
    "includedPaths": [
        {
            "path": "/*"
        }
    ],
    "excludedPaths": [
        {
            "path": "/_etag/?"
        }
    ],
    "vectorIndexes": [
        {
            "path": "/vector",
            "type": "quantizedFlat"
        }
    ]
}

Important

Zástupné znaky (*, []) a vektorové cesty vnořené uvnitř polí nejsou v současné době podporovány v zásadách vektorů nebo vektorovém indexu.

Můžete definovat následující typy zásad indexu vektorů:

Typ	Description	Maximální rozměry
`flat`	Ukládá vektory do stejného indexu jako ostatní indexované vlastnosti.	505
`quantizedFlat`	Kvantuje (komprimuje) vektory před uložením do indexu. To může zlepšit latenci a propustnost za cenu malé přesnosti.	4096
`diskANN`	Vytvoří index založený na diskANN pro rychlé a efektivní přibližné vyhledávání.	4096

Typy indexů flat a quantizedFlat používají index služby Azure Cosmos DB k ukládání a čtení jednotlivých vektorů při provádění vektorového vyhledávání. Vektorové vyhledávání s indexem je bruteforce vyhledávání a zajišťuje 100% přesnost. Existuje však omezení 505 dimenzí vektorů na plochém indexu.

Index quantizedFlat ukládá do indexu kvantované nebo komprimované vektory. Vektorové vyhledávání s indexem quantizedFlat jsou také hrubou silou hledání, ale jejich přesnost může být o něco menší než 100 %, protože vektory jsou před přidáním do indexu kvantovány. Vektorové vyhledávání pomocí quantized flat by mělo mít nižší latenci, vyšší propustnost a nižší náklady na jednotky požadavků (RU) než vektorové vyhledávání v indexu flat. Tato možnost je vhodná pro scénáře, ve kterých používáte filtry dotazů k zúžení vektorového vyhledávání na relativně malou sadu vektorů.

Index diskANN je samostatný index definovaný speciálně pro vektory využívající DiskANN, sadu vysoce výkonných algoritmů indexování vektorů vyvinutých společností Microsoft Research. Indexy DiskANN můžou nabízet některé dotazy s nejnižší latencí, dotazy s nejvyšším dotazem za sekundu (QPS) a dotazy s nejnižšími náklady na RU s vysokou přesností. Vzhledem k tomu, že diskANN je přibližný index nejbližších sousedů (ANN), může být přesnost nižší než quantizedFlat nebo flat.

diskANN a quantizedFlat indexy můžou využívat volitelné parametry sestavení indexu, které se dají použít k ladění kompromisu mezi přesností a latencí, který platí pro každý ANN vektorový index.

quantizationByteSize: Nastaví velikost (v bajtech) pro kvantování produktu: Min=1, Default=dynamic (systém rozhoduje), Max=512. Nastavení tohoto většího by mohlo vést k přesnějšímu vyhledávání vektorů na úkor vyšších nákladů RU a vyšší latence. To platí pro oba typy indexů quantizedFlat a DiskANN.
indexingSearchListSize: Nastaví, kolik vektorů se má prohledávat během sestavování indexu: Min=10, Default=100, Max=500. Nastavení této hodnoty na vyšší by mohlo vést k vyšší přesnosti vektorového vyhledávání na úkor delší doby sestavení indexu a vyšší latence nahrávání (příjmu) vektorů. To platí jenom pro DiskANN indexy.

Použití horizontálně dělených diskANN

Sharded DiskANN pomáhá optimalizovat rozsáhlé vektorové vyhledávání rozdělením indexu DiskANN na menší a lépe spravovatelné části. Zadáním VectorIndexShardKey v zásadách indexování kontejneru můžete vytvořit více indexů DiskANN – jeden pro každou jedinečnou hodnotu vybrané vlastnosti dokumentu.

Tento přístup může vést k rychlejšímu výkonu dotazů, lepšímu odvolání a nižším nákladům na RU, zejména při práci s daty s vysokou kardinalitou. Ať už vytváříte moduly doporučení, sémantické vyhledávání nebo inteligentní agenty, dílované DiskANN vám dává větší kontrolu nad strukturou a prováděním indexování vektorů.

Zde vidíme příklad definování klíče pro shardování na základě vlastnosti tenantID. Může se jednat o libovolnou vlastnost datové položky, a to i klíč oddílu. Jediný řetězec musí být uzavřený v poli. Další informace najdete v tématu Sharded DiskANN: Prioritní vektorové vyhledávání.

"vectorIndexes": [
    {
        "path": "/vector2",
        "type": "DiskANN",
        "vectorIndexShardKey": ["/tenantID"]
    }
]

Příklady zásad indexování řazené kolekce členů

Toto příkladové pravidlo indexování definuje index nad dvojicí events.name a events.category.

{  
    "automatic":true,
    "indexingMode":"Consistent",
    "includedPaths":[  
        {"path":"/*"}, 
        {"path":"/events/[]/{name,category}/?"} 
    ],
    "excludedPaths":[],
    "compositeIndexes":[]
}

Předchozí index se používá pro následující dotaz.

SELECT * 
FROM root r 
WHERE 
   EXISTS (SELECT VALUE 1 FROM ev IN r.events 
           WHERE ev.name = 'M&M' AND ev.category = 'Candy')

Příklady složených zásad indexování

Kromě zahrnutí nebo vyloučení cest pro jednotlivé vlastnosti můžete také zadat složený index. Chcete-li provést dotaz, který má ORDER BY klauzuli pro více vlastností, je pro tyto vlastnosti vyžadován složený index . Pokud dotaz obsahuje filtry spolu s řazením více vlastností, možná budete potřebovat více než jeden složený index.

Složené indexy mají také výhodu výkonu pro dotazy, které mají více filtrů, nebo filtr i klauzuli ORDER BY.

Note

Složené cesty mají implicitní /?, protože je indexována pouze skalární hodnota na té cestě. Zástupný znak /* není podporován ve složených cestách. Neměli byste zadávat /? ani /* ve složené cestě. Složené cesty také rozlišují malá a velká písmena.

Složený index definovaný pro (název vzestupně, věk sestupně)

{  
    "automatic":true,
    "indexingMode":"Consistent",
    "includedPaths":[  
        {  
            "path":"/*"
        }
    ],
    "excludedPaths":[],
    "compositeIndexes":[  
        [  
            {  
                "path":"/name",
                "order":"ascending"
            },
            {  
                "path":"/age",
                "order":"descending"
            }
        ]
    ]
}

Složený index pro název a věk se vyžaduje pro následující dotazy:

Dotaz č. 1:

SELECT *
FROM c
ORDER BY c.name ASC, c.age DESC

Dotaz č. 2:

SELECT *
FROM c
ORDER BY c.name DESC, c.age ASC

Tento složený index přináší následující dotazy a optimalizuje filtry:

Dotaz č. 3:

SELECT *
FROM c
WHERE c.name = "Tim"
ORDER BY c.name DESC, c.age ASC

Dotaz č. 4:

SELECT *
FROM c
WHERE c.name = "Tim" AND c.age > 18

Složený index definovaný pro (jméno ASC, věk ASC) a (jméno ASC, věk DESC)

V rámci stejné zásady indexování můžete definovat více složených indexů.

{  
    "automatic":true,
    "indexingMode":"Consistent",
    "includedPaths":[  
        {  
            "path":"/*"
        }
    ],
    "excludedPaths":[],
    "compositeIndexes":[  
        [  
            {  
                "path":"/name",
                "order":"ascending"
            },
            {  
                "path":"/age",
                "order":"ascending"
            }
        ],
        [  
            {  
                "path":"/name",
                "order":"ascending"
            },
            {  
                "path":"/age",
                "order":"descending"
            }
        ]
    ]
}

Složený index definovaný pro (název ASC, věk ASC)

Je volitelné zadat objednávku. Pokud není zadáno, pořadí je vzestupné.

{  
    "automatic":true,
    "indexingMode":"Consistent",
    "includedPaths":[  
        {  
            "path":"/*"
        }
    ],
    "excludedPaths":[],
    "compositeIndexes":[  
        [  
            {  
               "path":"/name"
            },
            {  
               "path":"/age"
            }
        ]
    ]
}

Vyloučit všechny cesty vlastností, ale zachovat indexování aktivní

Tuto zásadu můžete použít, pokud je funkce time-to-live (TTL) aktivní, ale žádné další indexy nejsou nutné k použití Azure Cosmos DB jako pouze key-value úložiště.

{
    "indexingMode": "consistent",
    "includedPaths": [],
    "excludedPaths": [{
        "path": "/*"
    }]
}

Bez indexování

Tato zásada vypne indexování. Pokud indexingMode je nastavená hodnota none, nemůžete v kontejneru nastavit hodnotu TTL.

{
    "indexingMode": "none"
}

Aktualizace zásad indexování

V Azure Cosmos DB je možné zásady indexování aktualizovat pomocí některé z následujících metod:

Z portálu Azure
Použití Azure CLI
Použití PowerShellu
Použití jedné SDK sady

Aktualizace zásad indexování aktivuje transformaci indexu. Průběh této transformace lze také sledovat pomocí sad SDK.

Note

Při aktualizaci zásad indexování se zápisy do Azure Cosmos DB nepřerušují. Přečtěte si další informace o transformacích indexování.

Important

Odebrání indexu se projeví okamžitě, zatímco přidání nového indexu nějakou dobu trvá, protože vyžaduje transformaci indexování. Když nahradíte jeden index jiným indexem (například nahradíte jeden index vlastností složeným indexem), nezapomeňte nejprve přidat nový index a potom počkat na dokončení transformace indexu před odebráním předchozího indexu ze zásad indexování. Jinak to negativně ovlivňuje vaši schopnost dotazovat se na předchozí index a může narušit všechny aktivní úlohy, které odkazují na předchozí index.

Použití portálu Azure

Azure Cosmos DB kontejnery ukládají své zásady indexování jako dokument JSON, který portál Azure umožňuje přímo upravovat.

Přihlaste se do Azure Portalu.
Vytvořte nový účet služby Azure Cosmos DB nebo vyberte existující účet.
Otevřete podokno Data Explorer a vyberte kontejner, na který chcete pracovat.
Vyberte Nastavení a pak zvolte Zásady indexování.
Upravte dokument JSON zásad indexování, jak je znázorněno v těchto příkladech.
Až budete hotovi, zvolte tlačítko Uložit.

Použití Azure CLI

Pokud chcete vytvořit kontejner s vlastní zásadou indexování, přečtěte si téma Vytvoření kontejneru s vlastními zásadami indexu pomocí rozhraní příkazového řádku.

Použijte PowerShell

Pokud chcete vytvořit kontejner s vlastní zásadou indexování, přečtěte si téma Vytvoření kontejneru s vlastními zásadami indexu pomocí PowerShellu.

Objekt ContainerProperties ze sady .NET SDK v3 zveřejňuje vlastnost IndexingPolicy, která umožňuje změnit IndexingMode a přidat nebo odebrat IncludedPaths a ExcludedPaths. Další informace najdete v tématu Rychlý start: Použití služby Azure Cosmos DB for NoSQL se sadou Azure SDK pro .NET.

// Retrieve the container's details
ContainerResponse containerResponse = await client.GetContainer("database", "container").ReadContainerAsync();
// Set the indexing mode to consistent
containerResponse.Resource.IndexingPolicy.IndexingMode = IndexingMode.Consistent;
// Add an included path
containerResponse.Resource.IndexingPolicy.IncludedPaths.Add(new IncludedPath { Path = "/*" });
// Add an excluded path
containerResponse.Resource.IndexingPolicy.ExcludedPaths.Add(new ExcludedPath { Path = "/name/*" });
// Add a spatial index
SpatialPath spatialPath = new SpatialPath
{
    Path = "/locations/*"
};
spatialPath.SpatialTypes.Add(SpatialType.Point);
containerResponse.Resource.IndexingPolicy.SpatialIndexes.Add(spatialPath);
// Add a composite index
containerResponse.Resource.IndexingPolicy.CompositeIndexes.Add(new Collection<CompositePath> { new CompositePath() { Path = "/name", Order = CompositePathSortOrder.Ascending }, new CompositePath() { Path = "/age", Order = CompositePathSortOrder.Descending } });
// Update container with changes
await client.GetContainer("database", "container").ReplaceContainerAsync(containerResponse.Resource);

Chcete-li sledovat průběh transformace indexu, předejte RequestOptions objekt, který nastaví PopulateQuotaInfo vlastnost na true. Načtěte hodnotu z hlavičky x-ms-documentdb-collection-index-transformation-progress odpovědi.

// retrieve the container's details
ContainerResponse containerResponse = await client.GetContainer("database", "container").ReadContainerAsync(new ContainerRequestOptions { PopulateQuotaInfo = true });
// retrieve the index transformation progress from the result
long indexTransformationProgress = long.Parse(containerResponse.Headers["x-ms-documentdb-collection-index-transformation-progress"]);

Rozhraní API sady SDK V3 fluent umožňuje napsat tuto definici stručným a efektivním způsobem při definování vlastních zásad indexování při vytváření nového kontejneru:

await client.GetDatabase("database").DefineContainer(name: "container", partitionKeyPath: "/myPartitionKey")
    .WithIndexingPolicy()
        .WithIncludedPaths()
            .Path("/*")
        .Attach()
        .WithExcludedPaths()
            .Path("/name/*")
        .Attach()
        .WithSpatialIndex()
            .Path("/locations/*", SpatialType.Point)
        .Attach()
        .WithCompositeIndex()
            .Path("/name", CompositePathSortOrder.Ascending)
            .Path("/age", CompositePathSortOrder.Descending)
        .Attach()
    .Attach()
    .CreateIfNotExistsAsync();

Objekt DocumentCollection ze sady .NET SDK v2 zveřejňuje vlastnost IndexingPolicy, která umožňuje změnit vlastnost IndexingMode a přidat nebo odebrat IncludedPaths a ExcludedPaths.

// Retrieve the container's details
ResourceResponse<DocumentCollection> containerResponse = await client.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri("database", "container"));
// Set the indexing mode to consistent
containerResponse.Resource.IndexingPolicy.IndexingMode = IndexingMode.Consistent;
// Add an included path
containerResponse.Resource.IndexingPolicy.IncludedPaths.Add(new IncludedPath { Path = "/*" });
// Add an excluded path
containerResponse.Resource.IndexingPolicy.ExcludedPaths.Add(new ExcludedPath { Path = "/name/*" });
// Add a spatial index
containerResponse.Resource.IndexingPolicy.SpatialIndexes.Add(new SpatialSpec() { Path = "/locations/*", SpatialTypes = new Collection<SpatialType>() { SpatialType.Point } } );
// Add a composite index
containerResponse.Resource.IndexingPolicy.CompositeIndexes.Add(new Collection<CompositePath> {new CompositePath() { Path = "/name", Order = CompositePathSortOrder.Ascending }, new CompositePath() { Path = "/age", Order = CompositePathSortOrder.Descending }});
// Update container with changes
await client.ReplaceDocumentCollectionAsync(containerResponse.Resource);

Chcete-li sledovat průběh transformace indexu, předejte RequestOptions objekt, který nastaví PopulateQuotaInfo vlastnost na true.

// retrieve the container's details
ResourceResponse<DocumentCollection> container = await client.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri("database", "container"), new RequestOptions { PopulateQuotaInfo = true });
// retrieve the index transformation progress from the result
long indexTransformationProgress = container.IndexTransformationProgress;

Použití sady Java SDK

Objekt DocumentCollection ze sady Java SDK zveřejňuje metody getIndexingPolicy() a setIndexingPolicy(). Objekt IndexingPolicy , se kterým manipuluje, umožňuje změnit režim indexování a přidat nebo odebrat zahrnuté a vyloučené cesty. Další informace najdete v tématu Quickstart: Použití Azure Cosmos DB pro NoSQL s Azure SDK pro Java.

// Retrieve the container's details
Observable<ResourceResponse<DocumentCollection>> containerResponse = client.readCollection(String.format("/dbs/%s/colls/%s", "database", "container"), null);
containerResponse.subscribe(result -> {
DocumentCollection container = result.getResource();
IndexingPolicy indexingPolicy = container.getIndexingPolicy();

// Set the indexing mode to consistent
indexingPolicy.setIndexingMode(IndexingMode.Consistent);

// Add an included path

Collection<IncludedPath> includedPaths = new ArrayList<>();
IncludedPath includedPath = new IncludedPath();
includedPath.setPath("/*");
includedPaths.add(includedPath);
indexingPolicy.setIncludedPaths(includedPaths);

// Add an excluded path

Collection<ExcludedPath> excludedPaths = new ArrayList<>();
ExcludedPath excludedPath = new ExcludedPath();
excludedPath.setPath("/name/*");
excludedPaths.add(excludedPath);
indexingPolicy.setExcludedPaths(excludedPaths);

// Add a spatial index

Collection<SpatialSpec> spatialIndexes = new ArrayList<SpatialSpec>();
Collection<SpatialType> collectionOfSpatialTypes = new ArrayList<SpatialType>();

SpatialSpec spec = new SpatialSpec();
spec.setPath("/locations/*");
collectionOfSpatialTypes.add(SpatialType.Point);
spec.setSpatialTypes(collectionOfSpatialTypes);
spatialIndexes.add(spec);

indexingPolicy.setSpatialIndexes(spatialIndexes);

// Add a composite index

Collection<ArrayList<CompositePath>> compositeIndexes = new ArrayList<>();
ArrayList<CompositePath> compositePaths = new ArrayList<>();

CompositePath nameCompositePath = new CompositePath();
nameCompositePath.setPath("/name");
nameCompositePath.setOrder(CompositePathSortOrder.Ascending);

CompositePath ageCompositePath = new CompositePath();
ageCompositePath.setPath("/age");
ageCompositePath.setOrder(CompositePathSortOrder.Descending);

compositePaths.add(ageCompositePath);
compositePaths.add(nameCompositePath);

compositeIndexes.add(compositePaths);
indexingPolicy.setCompositeIndexes(compositeIndexes);

// Update the container with changes

 client.replaceCollection(container, null);
});

Pokud chcete sledovat průběh transformace indexu v kontejneru, předejte RequestOptions objekt, který požaduje naplnění informací o kvótách. Načtěte hodnotu z hlavičky x-ms-documentdb-collection-index-transformation-progress odpovědi.

// set the RequestOptions object
RequestOptions requestOptions = new RequestOptions();
requestOptions.setPopulateQuotaInfo(true);
// retrieve the container's details
Observable<ResourceResponse<DocumentCollection>> containerResponse = client.readCollection(String.format("/dbs/%s/colls/%s", "database", "container"), requestOptions);
containerResponse.subscribe(result -> {
    // retrieve the index transformation progress from the response headers
    String indexTransformationProgress = result.getResponseHeaders().get("x-ms-documentdb-collection-index-transformation-progress");
});

Použití sady Node.js SDK

Rozhraní ContainerDefinition ze sady Node.js SDK zpřístupňuje indexingPolicy vlastnost, která umožňuje měnit indexingMode a také přidávat nebo odebírat includedPaths a excludedPaths. Další informace najdete v tématu Rychlý start: Použití služby Azure Cosmos DB for NoSQL se sadou Azure SDK pro Node.js.

Načtěte podrobnosti kontejneru:

const containerResponse = await client.database('database').container('container').read();

Nastavte režim indexování na konzistentní:

containerResponse.body.indexingPolicy.indexingMode = "consistent";

Přidání zahrnuté cesty včetně prostorového indexu:

containerResponse.body.indexingPolicy.includedPaths.push({
    includedPaths: [
      {
        path: "/age/*",
        indexes: [
          {
            kind: cosmos.DocumentBase.IndexKind.Range,
            dataType: cosmos.DocumentBase.DataType.String
          },
          {
            kind: cosmos.DocumentBase.IndexKind.Range,
            dataType: cosmos.DocumentBase.DataType.Number
          }
        ]
      },
      {
        path: "/locations/*",
        indexes: [
          {
            kind: cosmos.DocumentBase.IndexKind.Spatial,
            dataType: cosmos.DocumentBase.DataType.Point
          }
        ]
      }
    ]
  });

Přidat vyloučenou cestu:

containerResponse.body.indexingPolicy.excludedPaths.push({ path: '/name/*' });

Aktualizujte kontejner změnami:

const replaceResponse = await client.database('database').container('container').replace(containerResponse.body);

Chcete-li sledovat průběh transformace indexu v kontejneru, předejte RequestOptions objekt, který nastaví populateQuotaInfo vlastnost na true. Načtěte hodnotu z hlavičky x-ms-documentdb-collection-index-transformation-progress odpovědi.

// retrieve the container's details
const containerResponse = await client.database('database').container('container').read({
    populateQuotaInfo: true
});
// retrieve the index transformation progress from the response headers
const indexTransformationProgress = replaceResponse.headers['x-ms-documentdb-collection-index-transformation-progress'];

Přidejte složený index:

 console.log("create container with composite indexes");
  const containerDefWithCompositeIndexes = {
    id: "containerWithCompositeIndexingPolicy",
    indexingPolicy: {
      automatic: true,
      indexingMode: IndexingMode.consistent,
      includedPaths: [
        {
          path: "/*",
        },
      ],
      excludedPaths: [
        {
          path: '/"systemMetadata"/*',
        },
      ],
      compositeIndexes: [
        [
          { path: "/field", order: "ascending" },
          { path: "/key", order: "ascending" },
        ],
      ],
    },
  };
  const containerWithCompositeIndexes = (
    await database.containers.create(containerDefWithCompositeIndexes)
  ).container;

Použití sady Go SDK

Struktura IndexingPolicy definuje zásady indexování pro kontejner. Můžete ho použít při vytváření nového kontejneru nebo změně konfigurace existujícího kontejneru.

db, _ := client.NewDatabase("demodb")

pkDefinition := azcosmos.PartitionKeyDefinition{
	Paths: []string{"/state"},
		Kind:  azcosmos.PartitionKeyKindHash,
}

indexingPolicy := &azcosmos.IndexingPolicy{
	IndexingMode: azcosmos.IndexingModeConsistent,

    // add an included path
	IncludedPaths: []azcosmos.IncludedPath{
		{Path: "/*"},
	},

    // add an excluded path
	ExcludedPaths: []azcosmos.ExcludedPath{
		{Path: "/address/*"},
	},

    // add composite indices
	CompositeIndexes: [][]azcosmos.CompositeIndex{
		{
			{
				Path:  "/name",
				Order: azcosmos.CompositeIndexAscending,
			},
			{
				Path:  "/age",
				Order: azcosmos.CompositeIndexDescending,
			},
		},
	}

	db.CreateContainer(context.Background(), azcosmos.ContainerProperties{
		ID:                     "demo_container",
		PartitionKeyDefinition: pkDefinition,
		IndexingPolicy:         indexingPolicy,
	}, nil)

Použití sady Python SDK

Python SDK verze 3
Python SDK verze 4

Při použití sady Python SDK verze 3 se konfigurace kontejneru spravuje jako slovník. Z tohoto slovníku můžete získat přístup k zásadám indexování a všem jeho atributům. Další informace najdete v tématu Quickstart: Použití Azure Cosmos DB pro NoSQL s Azure SDK pro Python.

Načtěte podrobnosti kontejneru:

containerPath = 'dbs/database/colls/collection'
container = client.ReadContainer(containerPath)

Nastavte režim indexování na konzistentní:

container['indexingPolicy']['indexingMode'] = 'consistent'

Definujte zásadu indexování s zahrnutou cestou a prostorovým indexem:

container["indexingPolicy"] = {

    "indexingMode":"consistent",
    "spatialIndexes":[
                {"path":"/location/*","types":["Point"]}
             ],
    "includedPaths":[{"path":"/age/*","indexes":[]}],
    "excludedPaths":[{"path":"/*"}]
}

Definujte zásadu indexování s vyloučenou cestou:

container["indexingPolicy"] = {
    "indexingMode":"consistent",
    "includedPaths":[{"path":"/*","indexes":[]}],
    "excludedPaths":[{"path":"/name/*"}]
}

Přidejte složený index:

container['indexingPolicy']['compositeIndexes'] = [
                [
                    {
                        "path": "/name",
                        "order": "ascending"
                    },
                    {
                        "path": "/age",
                        "order": "descending"
                    }
                ]
                ]

Aktualizujte kontejner změnami:

response = client.ReplaceContainer(containerPath, container)

Při použití sady Python SDK verze 4 se konfigurace kontejneru spravuje jako slovník. Z tohoto slovníku můžete získat přístup k zásadám indexování a všem jeho atributům.

Načtěte podrobnosti kontejneru:

database_client = cosmos_client.get_database_client('database')
container_client = database_client.get_container_client('container')
container = container_client.read()

Nastavte režim indexování na konzistentní:

indexingPolicy = {
    'indexingMode': 'consistent'
}

Definujte zásadu indexování s zahrnutou cestou a prostorovým indexem:

indexingPolicy = {
    "indexingMode":"consistent",
    "spatialIndexes":[
        {"path":"/location/*","types":["Point"]}
    ],
    "includedPaths":[{"path":"/age/*","indexes":[]}],
    "excludedPaths":[{"path":"/*"}]
}

Definujte zásadu indexování s vyloučenou cestou:

indexingPolicy = {
    "indexingMode":"consistent",
    "includedPaths":[{"path":"/*","indexes":[]}],
    "excludedPaths":[{"path":"/name/*"}]
}

Přidejte složený index:

indexingPolicy['compositeIndexes'] = [
    [
        {
            "path": "/name",
            "order": "ascending"
        },
        {
            "path": "/age",
            "order": "descending"
        }
    ]
]

Aktualizujte kontejner změnami:

response = database_client.replace_container(container_client, container['partitionKey'], indexingPolicy)

Načtěte průběh transformace indexu z hlaviček odpovědi:

container_client.read(populate_quota_info = True,
                      response_hook = lambda h,p: print(h['x-ms-documentdb-collection-index-transformation-progress']))

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-04-27

Správa zásad indexování v Azure Cosmos DB

Příklady zásad indexování

Zásady odhlášení pro selektivní vyloučení některých datových cest vlastností

Zásady souhlasu pro selektivní zahrnutí některých vlastnostních cest

Použijte prostorový index pouze na konkrétní vlastnostní cestě

Příklady zásad indexování vektorů

Použití horizontálně dělených diskANN

Příklady zásad indexování řazené kolekce členů

Příklady složených zásad indexování

Složený index definovaný pro (název vzestupně, věk sestupně)

Složený index definovaný pro (jméno ASC, věk ASC) a (jméno ASC, věk DESC)

Složený index definovaný pro (název ASC, věk ASC)

Vyloučit všechny cesty vlastností, ale zachovat indexování aktivní

Bez indexování

Aktualizace zásad indexování

Použití portálu Azure

Použití Azure CLI

Použijte PowerShell

Použití sady .NET SDK

Použití sady Java SDK

Použití sady Node.js SDK

Použití sady Go SDK

Použití sady Python SDK

Související obsah

Váš názor

Další materiály