Azure Cosmos DB'de dizin oluşturma ilkelerini yönetme

Azure Cosmos DB'de veriler, her kapsayıcı için tanımlanan dizin oluşturma ilkelerine göre dizinlenir. Yeni oluşturulan kapsayıcıların varsayılan dizin oluşturma ilkesi tüm dizeler veya sayılar için aralık dizinlerini zorunlu tutar. Bu ilkeyi kendi özel dizin oluşturma ilkenizle geçersiz kılabilirsiniz.

Note

Bu makalede açıklanan dizin oluşturma ilkelerini güncelleştirme yöntemi yalnızca NoSQL için Azure Cosmos DB için geçerlidir. MongoDB için Azure Cosmos DB'de dizin oluşturma ve Apache Cassandra için Azure Cosmos DB'de İkincil dizin oluşturma hakkında bilgi edinin.

Dizin oluşturma ilkesi örnekleri

Aşağıda , JSON biçiminde gösterilen dizin oluşturma ilkelerine bazı örnekler verilmiştir. Bunlar Azure portalında JSON biçiminde kullanıma sunulur. Aynı parametreler Azure CLI veya herhangi bir SDK kullanılarak ayarlanabilir.

Belirli özellik yollarını dışlamak için hariç tutma politikası

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

Note

• Bölüm anahtarı (aynı zamanda /idolmadığı sürece) dizine alınmaz ve dizine eklenmelidir.
• Sistem özellikleri id ve _ts, Cosmos hesabı dizinleme modu consistent olduğunda her zaman dizine eklenir.
• Sistem özellikleri id ve _ts, kapsayıcı ilkesinin dizine alınmış yollar tanımına dahil değildir. Bu sistem özellikleri varsayılan olarak dizine alındığından ve bu davranış devre dışı bırakılamadığından bu tasarım gereğidir.

Bazı özellik yollarını isteğe bağlı olarak eklemek için isteğe bağlı politika

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

Note

Genellikle bir vazgeçme dizinleme politikası kullanmanızı öneririz. Azure Cosmos DB, veri modelinize eklenebilecek tüm yeni özellikleri proaktif olarak dizinler.

Yalnızca belirli bir özellik yolunda uzamsal dizin kullanın

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

Vektör dizin oluşturma ilkesi örnekleri

Tek tek özellikler için yolları eklemeye veya dışlamanın yanı sıra, bir vektör dizini de belirtebilirsiniz. Genel olarak, bir sorgu vektör ve vektör özelliği arasındaki benzerliği ölçmek için sistem işlevi her kullanıldığında vektör dizinleri belirtilmelidir VectorDistance .

Note

Devam etmeden önce Azure Cosmos DB NoSQL vektör dizini oluşturmayı ve aramayı etkinleştirmeniz gerekir.

Important

Vektör dizin oluşturma ilkesi, kapsayıcının vektör ilkesinde tanımlanan aynı yolda olmalıdır. Daha fazla bilgi için bkz. Kapsayıcı vektör ilkeleri.

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

Important

Diziler içinde iç içe yerleştirilmiş wildcard karakterler (*, []) ve vektör yolları şu anda vektör ilkesinde veya vektör indeksinde desteklenmemektedir.

Aşağıdaki vektör dizini ilkesi türlerini tanımlayabilirsiniz:

Türü	Description	Maksimum boyutlar
flat	Vektörleri diğer dizine alınan özelliklerle aynı dizinde depolar.	505
quantizedFlat	Dizinde depolamadan önce vektörleri niceleştirir (sıkıştırır). Bu, az miktarda doğruluk karşılığında gecikme süresini ve aktarım hızını iyileştirebilir.	4096
diskANN	Hızlı ve verimli yaklaşık arama için DiskANN tabanlı bir dizin oluşturur.	4096

flat ve quantizedFlat dizin türleri, vektör araması yaparken her vektöri depolamak ve okumak için Azure Cosmos DB dizinini kullanır. Dizin içeren flat vektör aramaları kaba kuvvet aramalarıdır ve %100 doğruluk sağlar. Ancak düz bir dizindeki vektörler için 505 boyut sınırlaması vardır.

Dizin, quantizedFlat dizinde nicelenmiş veya sıkıştırılmış vektörleri depolar. Dizinli quantizedFlat vektör aramaları da deneme yanılma aramalarıdır, ancak vektörler dizine eklemeden önce ölçüleceğinden doğrulukları %100'ün biraz altında olabilir. Ancak, quantized flat ile yapılan vektör aramaları, flat dizinindeki vektör aramalarına göre daha düşük gecikme süresi, daha yüksek aktarım hızı ve daha düşük RU maliyetine sahip olmalıdır. Bu, vektör aramasını görece küçük bir vektör kümesine daraltmak için sorgu filtrelerini kullandığınız senaryolar için iyi bir seçenektir.

Dizin diskANN , Microsoft Research tarafından geliştirilen yüksek performanslı vektör dizinleme algoritmaları paketi olan DiskANN kullanan vektörler için özel olarak tanımlanan ayrı bir dizindir. DiskANN dizinleri en düşük gecikme süresi, en yüksek saniye başına sorgu (QPS) ve yüksek doğrulukta en düşük RU maliyeti sorgularından bazılarını sunabilir. Ancak, DiskANN, tahmini en yakın komşular (ANN) dizini olduğundan, doğruluğu quantizedFlat veya flat değerlerinden daha düşük olabilir.

diskANN ve quantizedFlat dizinleri, her ANN vektör dizini için geçerli olan doğruluk ile gecikme süresi arasındaki dengeyi ayarlamak için kullanılabilecek isteğe bağlı dizin derleme parametrelerini alabilir.

• quantizationByteSize: Ürün nicelemesi için boyutu (bayt cinsinden) ayarlar: Min=1, Default=dynamic (sistem karar verir), Max=512. Bu büyük ayarın ayarlanması, daha yüksek RU maliyeti ve daha yüksek gecikme süresi karşılığında daha yüksek doğruluk vektör aramalarına neden olabilir. Bu, hem hem de quantizedFlatDiskANN dizin türleri için geçerlidir.
• indexingSearchListSize: Dizin derlemesi oluşturma sırasında aranacak vektör sayısını ayarlar: Min=10, Default=100, Max=500. Bu büyük ayarın ayarlanması, daha uzun dizin oluşturma süreleri ve daha yüksek vektör alma gecikme süreleri pahasına daha yüksek doğruluk vektör aramaları yapılmasına neden olabilir. Bu yalnızca dizinler için DiskANN geçerlidir.

Parçalanmış DiskANN kullanma

Parçalı DiskANN, bir DiskANN dizinini daha küçük, daha yönetilebilir parçalara bölerek büyük ölçekli vektör aramasını iyileştirmenize yardımcı olur. Kapsayıcınızın dizin oluşturma ilkesinde bir VectorIndexShardKey belirterek, seçilen belge özelliğinin her benzersiz değeri için bir tane olmak üzere birden çok DiskANN dizini oluşturabilirsiniz.

Bu yaklaşım, özellikle yüksek kardinalite verileriyle çalışırken daha hızlı sorgu performansına, geliştirilmiş geri çağırmaya ve daha düşük RU maliyetlerine yol açabilir. Öneri altyapıları, anlamsal arama veya akıllı aracılar oluştururken parçalanmış DiskANN, vektör dizin oluşturmanın nasıl yapılandırıldığı ve yürütüldiği üzerinde daha fazla denetim sağlar.

Burada, bir tenantID özelliğine göre parça anahtarını tanımlama örneğini görebiliriz. Bu, bölüm anahtarı bile veri öğesinin herhangi bir özelliği olabilir. Tek dizenin bir dizi içine alınması gerekir. Daha fazla bilgi edinmek için bkz. Parçalanmış DiskANN: Odaklanmış vektör araması.

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

Küme dizinleme politikası örnekleri

Bu örnek dizin oluşturma ilkesi events.name ve events.category üzerinde bir tuple dizini tanımlar.

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

Yukarıdaki dizin aşağıdaki sorgu için kullanılır.

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

Bileşik dizin oluşturma ilkesi örnekleri

Bireysel özellikler için yolları eklemeye veya çıkarmanın yanı sıra, bir bileşik dizin de belirtebilirsiniz. Birden çok özellikle ilgili bir ORDER BY yan tümcesi olan bir sorgu gerçekleştirmek için, o özelliklerde bileşik bir dizin gereklidir. Sorguda birden çok özellikte sıralamanın yanı sıra filtreler varsa, birden fazla bileşik dizine ihtiyacınız olabilir.

Bileşik dizinler, birden çok filtreye veya hem filtreye hem de ORDER BY yan tümcesine sahip sorgular için performans avantajına da sahiptir.

Note

Yalnızca bu yoldaki skaler değer dizine eklendiğinden bileşik yolların örtük /? bir değeri vardır. Bileşik yollarda joker karakter /* desteklenmez. Bileşik bir yolda /? veya /* belirtmemeniz gerekir. Bileşik yollar da büyük/küçük harfe duyarlıdır.

(ad artan, yaş azalan) için tanımlanan bileşik dizin

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

Ad ve yaş üzerindeki bileşik dizin aşağıdaki sorgular için gereklidir:

Sorgu #1:

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

Sorgu #2:

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

Bu bileşik dizin aşağıdaki sorgulardan yararlanır ve filtreleri iyileştirir:

Sorgu #3:

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

Sorgu #4:

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

(name ASC, yaş ASC) ve (name ASC, yaş DESC) için tanımlanan bileşik indeks

Aynı dizin oluşturma ilkesi içinde birden çok bileşik dizin tanımlayabilirsiniz.

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

için tanımlanan bileşik dizin (ad ASC, yaş ASC)

Siparişi belirtmek isteğe bağlıdır. Belirtilmezse, sıra artandır.

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

Tüm özellik yollarını dışla ama dizin oluşturmayı etkin tut

Yaşam süresi (TTL) özelliğinin etkin olduğu ve Azure Cosmos DB'yi saf bir anahtar-değer deposu olarak kullanmak için başka bir dizine gerek olmadığı durumlarda bu ilkeyi kullanabilirsiniz.

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

Dizin oluşturma yok

Bu ilke dizin oluşturmayı kapatır. olarak ayarlanırsa indexingModenone, kapsayıcıda TTL ayarlayamazsınız.

{
    "indexingMode": "none"
}

Dizin oluşturma ilkesi güncelleştiriliyor

Azure Cosmos DB'de dizin oluşturma ilkesi aşağıdaki yöntemlerden herhangi biri kullanılarak güncelleştirilebilir:

• Azure portalından
• Azure CLI'yı kullanma
• PowerShell'i kullanma
• SDK'lardan birini kullanma

Dizin oluşturma ilkesi güncelleştirmesi dizin dönüştürmeyi tetikler. Bu dönüşümün ilerleme durumu SDK'lar kullanılarak da izlenebilir.

Note

Dizin oluşturma ilkesini güncelleştirdiğinizde Azure Cosmos DB'ye yazma işlemleri kesintisiz olarak gerçekleştirilir. Dizin dönüştürmeleri hakkında daha fazla bilgi edinin.

Important

Dizin kaldırma işlemi hemen geçerli olurken, dizin oluşturma dönüşümü gerektirdiğinden yeni dizin eklemek biraz zaman alır. Bir dizini başka bir dizinle değiştirdiğinizde (örneğin, tek bir özellik dizinini bileşik dizinle değiştirdiğinizde), önce yeni dizini eklediğinizden emin olun ve dizin oluşturma ilkesinden önceki dizini kaldırmadan önce dizin dönüştürme işleminin tamamlanmasını bekleyin. Aksi takdirde, bu durum önceki dizini sorgulama becerinizi olumsuz etkiler ve önceki dizine başvuran tüm etkin iş yüklerini bozabilir.

Azure portalını kullanma

Azure Cosmos DB kapsayıcıları dizin oluşturma ilkelerini Azure portalının doğrudan düzenlemenizi sağlayan bir JSON belgesi olarak depolar.

1. Azure portalınaoturum açın.

2. Yeni bir Azure Cosmos DB hesabı oluşturun veya mevcut bir hesabı seçin.

3. Veri Gezgini bölmesini açın ve üzerinde çalışmak istediğiniz kapsayıcıyı seçin.

4. Ayarlar'ı ve ardından Dizin oluşturma İlkesi'ni seçin.

5. Dizin oluşturma ilkesi JSON belgesini, bu örneklerde gösterildiği gibi değiştirin.

6. Bitirdiğinizde Kaydet'i seçin.

Azure CLI'yi kullanma

Özel dizin oluşturma ilkesine sahip bir kapsayıcı oluşturmak için bkz. CLI kullanarak özel dizin ilkesiyle kapsayıcı oluşturma.

PowerShell kullanma

Özel dizin oluşturma ilkesine sahip bir kapsayıcı oluşturmak için bkz. PowerShell kullanarak özel dizin ilkesiyle kapsayıcı oluşturma.

.NET SDK'sını kullanma

.NET SDK V3

ContainerProperties .NET SDK v3'ten gelen nesne, IndexingPolicy öğesini değiştirmenize, IndexingMode ve IncludedPaths ekleyip kaldırmanıza olanak tanıyan bir ExcludedPaths özelliği sunar. Daha fazla bilgi için bkz. Hızlı Başlangıç: Azure SDK ile .NET için NoSQL ile Azure Cosmos DB kullanma.

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

Dizin dönüştürme ilerleme durumunu izlemek için, RequestOptions nesnesinin PopulateQuotaInfo özelliğini true olarak ayarlayan bir nesne geçirin. Yanıt üst bilgisi x-ms-documentdb-collection-index-transformation-progress değerini alın.

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

SDK V3 akıcı API'si, yeni bir kapsayıcı oluştururken özel dizin oluşturma ilkesi tanımlarken bu tanımı kısa ve verimli bir şekilde yazmanızı sağlar:

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();

.NET SDK V2

DocumentCollection nesnesi, IndexingPolicy değiştirmenize ve IndexingMode ve IncludedPaths eklemenize veya kaldırmanıza olanak tanıyan bir ExcludedPaths özelliğini kullanıma sunar.

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

Dizin dönüştürme ilerleme durumunu izlemek için, RequestOptions nesnesinin PopulateQuotaInfo özelliğini true olarak ayarlayan bir nesne geçirin.

// 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;

Java SDK'sını kullanma

DocumentCollection nesnesi, Java SDK'dan getIndexingPolicy() ve setIndexingPolicy() yöntemlerini kullanıma sunar. değiştirdikleri IndexingPolicy nesne, dizin oluşturma modunu değiştirmenize ve dahil edilen ve dışlanan yolları eklemenize veya kaldırmanıza olanak tanır. Daha fazla bilgi için bkz . Hızlı Başlangıç: Java için Azure SDK ile NoSQL için Azure Cosmos DB'yi kullanma.

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

Bir kapsayıcıda dizin dönüştürme ilerleme durumunu izlemek için kota bilgilerinin doldurulma isteğinde bulunan bir RequestOptions nesneyi geçirin. Yanıt üst bilgisi x-ms-documentdb-collection-index-transformation-progress değerini alın.

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

Node.js SDK'sını kullanma

ContainerDefinition Node.js SDK'sı arabirimi, özelliğini değiştirmenize ve indexingPolicyindexingMode ekleyip kaldırmanıza olanak tanıyan bir includedPaths özelliği sağlar. Daha fazla bilgi için bkz. Quickstart: Node.js için Azure SDK ile NoSQL için Azure Cosmos DB kullanma.

Kapsayıcının ayrıntılarını alın:

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

Dizin oluşturma modunu tutarlı olacak şekilde ayarlayın:

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

Uzamsal dizin içeren yolu dahil et.

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
          }
        ]
      }
    ]
  });

Eklenecek dışlanan yolu belirtin

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

Kapsayıcıyı değişikliklerle güncelleştirin:

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

Bir kapsayıcıda dizin dönüştürme ilerlemesini izlemek için RequestOptions nesnesi geçirin ve bu nesnenin populateQuotaInfo özelliğini true olarak ayarlayın. Yanıt üst bilgisi x-ms-documentdb-collection-index-transformation-progress değerini alın.

// 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'];

Bileşik dizin ekleme:

 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;

Go SDK'sını kullanma

IndexingPolicy yapısı bir kapsayıcı için dizin oluşturma ilkesini tanımlar. Yeni bir kapsayıcı oluşturduğunuzda veya var olan bir kapsayıcıyı yeniden yapılandırdığınızda kullanılabilir.

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)

Python SDK'sını kullanma

Python SDK V3

Python SDK V3 kullandığınızda, kapsayıcı yapılandırması sözlük olarak yönetilir. Bu sözlükten dizin oluşturma ilkesine ve tüm özniteliklerine erişebilirsiniz. Daha fazla bilgi için bkz . Hızlı Başlangıç: Python için Azure SDK ile NoSQL için Azure Cosmos DB kullanma.

Kapsayıcının ayrıntılarını alın:

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

Dizin oluşturma modunu tutarlı olacak şekilde ayarlayın:

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

Eklenen bir yol ve uzamsal dizin içeren bir dizin oluşturma ilkesi tanımlayın:

container["indexingPolicy"] = {

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

Dışarıda bırakılan bir yola sahip dizin oluşturma ilkesi tanımlayın:

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

Bileşik dizin ekleme:

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

Kapsayıcıyı değişikliklerle güncelleştirin:

response = client.ReplaceContainer(containerPath, container)

Python SDK V4

Python SDK V4 kullandığınızda, kapsayıcı yapılandırması sözlük olarak yönetilir. Bu sözlükten dizin oluşturma ilkesine ve tüm özniteliklerine erişebilirsiniz.

Kapsayıcının ayrıntılarını alın:

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

Dizin oluşturma modunu tutarlı olacak şekilde ayarlayın:

indexingPolicy = {
    'indexingMode': 'consistent'
}

Eklenen bir yol ve uzamsal dizin içeren bir dizin oluşturma ilkesi tanımlayın:

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

Dışarıda bırakılan bir yola sahip dizin oluşturma ilkesi tanımlayın:

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

Bileşik dizin ekleme:

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

Kapsayıcıyı değişikliklerle güncelleştirin:

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

Yanıt üst bilgilerinden dizin dönüştürme ilerleme durumunu alın:

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

İlgili içerik

• Azure Cosmos DB'de indexlemenin genel görünümü
• Azure Cosmos DB'de Indexleme politikaları