Mengelola kebijakan pengindeksan di Azure Cosmos DB

Di Azure Cosmos DB, data diindeks mengikuti kebijakan pengindeksan yang ditentukan untuk tiap-tiap kontainer. Kebijakan pengindeksan default untuk kontainer yang baru dibuat memberlakukan indeks rentang untuk string atau nomor apa pun. Anda dapat mengambil alih kebijakan ini dengan kebijakan pengindeksan kustom Anda sendiri.

Nota

Metode memperbarui kebijakan pengindeksan yang dijelaskan dalam artikel ini hanya berlaku untuk Azure Cosmos DB untuk NoSQL. Pelajari tentang pengindeksan di Azure Cosmos DB untuk MongoDB dan Pengindeksan Sekunder di Azure Cosmos DB untuk Apache Cassandra.

Contoh kebijakan pengindeksan

Berikut adalah beberapa contoh kebijakan pengindeksan yang ditampilkan dalam format JSON mereka. Mereka diekspos pada portal Azure dalam format JSON. Parameter yang sama dapat diatur dengan menggunakan Azure CLI atau SDK apa pun.

Kebijakan Opt-out untuk mengecualikan beberapa jalur properti secara selektif

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

Nota

• Kunci partisi (kecuali juga /id) tidak diindeks dan harus disertakan dalam indeks.
• Properti sistem id dan _ts selalu diindeks ketika mode pengindeksan akun cosmos consistent.
• Properti sistem id dan _ts tidak disertakan dalam deskripsi jalur yang diindeks dari kebijakan kontainer. Ini dirancang karena properti sistem ini diindeks secara default dan perilaku ini tidak dapat dinonaktifkan.

Kebijakan keikutsertaan untuk secara selektif menyertakan beberapa jalur properti

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

Nota

Kami umumnya menyarankan agar Anda menggunakan kebijakan pengindeksan dengan opsi keluar. Azure Cosmos DB secara proaktif mengindeks properti baru apa pun yang mungkin ditambahkan ke model data Anda.

Gunakan indeks spasial pada jalur properti tertentu saja

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

Contoh kebijakan pengindeksan vektor

Selain menyertakan atau mengecualikan jalur untuk properti individual, Anda juga dapat menentukan indeks vektor. Secara umum, indeks vektor harus ditentukan setiap kali VectorDistance fungsi sistem digunakan untuk mengukur kesamaan antara vektor kueri dan properti vektor.

Nota

Sebelum melanjutkan, Anda harus mengaktifkan pengindeksan dan pencarian vektor NoSQL Azure Cosmos DB.

Important

Kebijakan pengindeksan vektor harus berada pada jalur yang sama yang ditentukan dalam kebijakan vektor kontainer. Untuk mempelajari selengkapnya, lihat Kebijakan vektor kontainer.

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

Important

Karakter joker (*, []) dan jalur vektor yang tertampung di dalam array saat ini tidak didukung dalam kebijakan vektor atau indeks vektor.

Anda dapat menentukan jenis kebijakan indeks vektor berikut:

Tipe	Description	Dimensi maks
flat	Menyimpan vektor pada indeks yang sama dengan properti terindeks lainnya.	505
quantizedFlat	Mengukur (mengompresi) vektor sebelum menyimpan pada indeks. Ini dapat mengurangi latensi dan meningkatkan throughput dengan sedikit mengorbankan akurasi.	4096
diskANN	Membuat indeks berdasarkan DiskANN untuk perkiraan pencarian yang cepat dan efisien.	4096

Jenis indeks flat dan quantizedFlat menggunakan indeks Azure Cosmos DB untuk menyimpan dan membaca setiap vektor saat melakukan pencarian vektor. Pencarian vektor dengan flat indeks adalah pencarian brute-force dan menghasilkan akurasi 100%. Namun, ada batasan 505 dimensi untuk vektor pada indeks datar.

Indeks quantizedFlat menyimpan vektor terukur atau terkompresi pada indeks. Pencarian vektor dengan quantizedFlat indeks juga merupakan pencarian brute-force, namun akurasinya mungkin sedikit kurang dari 100% karena vektor diukur sebelum ditambahkan ke indeks. Namun, pencarian vektor dengan quantized flat harus memiliki latensi yang lebih rendah, throughput yang lebih tinggi, dan biaya RU yang lebih rendah daripada pencarian vektor pada flat indeks. Ini adalah opsi yang baik untuk skenario di mana Anda menggunakan filter kueri untuk mempersempit pencarian vektor ke sekumpulan vektor yang relatif kecil.

Indeks diskANN adalah indeks terpisah yang didefinisikan khusus untuk vektor yang menggunakan DiskANN, serangkaian algoritma pengindeksan vektor berkinerja tinggi yang dikembangkan oleh Microsoft Research. Indeks DiskANN dapat menawarkan biaya terendah untuk kueri RU, kueri per detik tertinggi (QPS), dan latensi terendah dengan akurasi tinggi. Namun, karena DiskANN adalah perkiraan indeks tetangga terdekat (ANN), akurasinya mungkin lebih rendah dari quantizedFlat atau flat.

Indeks diskANN dan quantizedFlat dapat mengambil parameter build indeks opsional yang dapat digunakan untuk mengoptimalkan perimbangan akurasi dan latensi yang diterapkan pada setiap indeks vektor ANN.

• quantizationByteSize: Mengatur ukuran (dalam byte) untuk kuantisasi produk: Min=1, Default=dynamic (sistem memutuskan), Max=512. Mengatur parameter ini lebih besar dapat meningkatkan akurasi pencarian vektor, namun mengorbankan biaya RU yang lebih tinggi dan latensi yang lebih tinggi. Ini berlaku untuk kedua jenis indeks quantizedFlat dan DiskANN.
• indexingSearchListSize: Mengatur berapa banyak vektor yang akan dijelajahi selama pembangunan indeks: Min=10, Default=100, Max=500. Menetapkan ukuran yang lebih besar dapat menghasilkan pencarian vektor dengan akurasi yang lebih tinggi, tetapi mengorbankan waktu pembuatan indeks yang lebih lama dan latensi penyerapan vektor yang lebih tinggi. Ini hanya berlaku untuk DiskANN indeks.

Menggunakan DiskANN pecahan

Sharded DiskANN membantu Anda mengoptimalkan pencarian vektor skala besar dengan membagi indeks DiskANN menjadi bagian yang lebih kecil dan lebih mudah dikelola. Dengan menentukan VectorIndexShardKey dalam kebijakan pengindeksan kontainer, Anda dapat membuat beberapa indeks DiskANN—satu untuk setiap nilai unik properti dokumen yang dipilih.

Pendekatan ini dapat menyebabkan performa kueri yang lebih cepat, pengenalan yang ditingkatkan, dan biaya RU yang lebih rendah, terutama saat bekerja dengan data kardinalitas tinggi. Baik Anda membangun mesin rekomendasi, pencarian semantik, atau agen cerdas, DiskANN pecahan memberi Anda kontrol lebih besar atas bagaimana pengindeksan vektor disusun dan dijalankan.

Di sini, kita dapat melihat contoh menentukan kunci shard berdasarkan properti tenantID. Ini bisa menjadi properti apa pun dari item data, bahkan kunci partisi. String tunggal perlu diapit dalam array. Untuk mempelajari lebih lanjut, lihat Sharded DiskANN: Pencarian vektor terfokus.

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

Contoh kebijakan pengindeksan tuple

Contoh kebijakan pengindeksan ini mendefinisikan indeks tuple pada events.name dan events.category.

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

Indeks sebelumnya digunakan untuk kueri berikut.

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

Contoh kebijakan pengindeksan komposit

Selain menyertakan atau mengecualikan jalur untuk properti individual, Anda juga dapat menentukan indeks komposit. Untuk melakukan kueri yang memiliki ORDER BY klausa untuk beberapa properti, diperlukan sebuah indeks komposit pada properti-properti tersebut. Jika kueri menyertakan filter bersama dengan pengurutan pada beberapa properti, Anda mungkin memerlukan lebih dari satu indeks komposit.

Indeks komposit juga memiliki manfaat kinerja untuk kueri yang memiliki beberapa filter atau gabungan filter dan klausa pengurutan (ORDER BY).

Nota

Jalur komposit memiliki implisit /? karena hanya nilai skalar pada jalur tersebut yang diindeks. Wildcard /* tidak didukung di jalur komposit. Anda tidak boleh menentukan /? atau /* di dalam jalur komposit. Jalur komposit juga peka huruf besar/kecil.

Indeks komposit ditetapkan untuk (nama naik, usia turun)

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

Indeks komposit pada nama dan usia diperlukan untuk kueri berikut:

Kueri #1:

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

Kueri #2:

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

Indeks komposit ini menguntungkan kueri berikut dan mengoptimalkan filter:

Kueri #3:

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

Kueri #4:

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

Indeks komposit didefinisikan sebagai (nama ASC, usia ASC) dan (nama ASC, usia DESC)

Anda dapat menentukan beberapa indeks komposit dalam kebijakan pengindeksan yang sama.

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

Indeks komposit yang ditentukan untuk (nama ASC, usia ASC)

Ini opsional untuk menentukan pesanan. Jika tidak ditentukan, urutan yang digunakan adalah urutan naik.

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

Kecualikan semua jalur properti tetapi tetap aktifkan pengindeksan

Anda dapat menggunakan kebijakan ini di mana fitur time-to-live (TTL) aktif tetapi tidak ada indeks lain yang diperlukan untuk menggunakan Azure Cosmos DB sebagai penyimpanan nilai kunci murni.

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

Tidak ada pengindeksan

Kebijakan ini menonaktifkan pengindeksan. Jika indexingMode diatur ke none, Anda tidak dapat mengatur TTL pada kontainer.

{
    "indexingMode": "none"
}

Memperbarui kebijakan pengindeksan

Di Azure Cosmos DB, kebijakan pengindeksan dapat diperbarui menggunakan salah satu metode berikut:

• Dari portal Azure
• Menggunakan Cli Azure
• Menggunakan PowerShell
• Menggunakan salah satu SDK

Pembaruan kebijakan pengindeksan memicu transformasi indeks. Kemajuan transformasi ini juga dapat dilacak dengan menggunakan SDK.

Nota

Ketika Anda memperbarui kebijakan pengindeksan, penulisan ke Azure Cosmos DB tetap tidak terganggu. Pelajari selengkapnya tentang transformasi pengindeksan.

Important

Menghapus indeks segera berlaku, sedangkan menambahkan indeks baru membutuhkan waktu karena memerlukan transformasi pengindeksan. Saat Anda mengganti satu indeks dengan indeks lain (misalnya, mengganti indeks properti tunggal dengan indeks komposit), pastikan untuk menambahkan indeks baru terlebih dahulu lalu menunggu transformasi indeks selesai sebelum Anda menghapus indeks sebelumnya dari kebijakan pengindeksan. Jika tidak, ini berdampak negatif pada kemampuan Anda untuk mengkueri indeks sebelumnya dan mungkin merusak beban kerja aktif apa pun yang mereferensikan indeks sebelumnya.

Gunakan portal Azure

Kontainer Azure Cosmos DB menyimpan kebijakan pengindeksan mereka sebagai dokumen JSON yang portal Azure memungkinkan Anda mengedit secara langsung.

1. Masuk ke portal Azure.

2. Buat akun Azure Cosmos DB baru atau pilih akun yang sudah ada.

3. Buka panel Data Explorer dan pilih kontainer yang ingin Anda kerjakan.

4. Pilih Pengaturan, lalu pilih Kebijakan Pengindeksan.

5. Ubah dokumen JSON kebijakan pengindeksan, seperti yang ditunjukkan dalam contoh-contoh ini.

6. Pilih Simpan saat Anda selesai.

Gunakan Azure CLI

Untuk membuat kontainer dengan kebijakan pengindeksan kustom, lihat Membuat kontainer dengan kebijakan indeks kustom menggunakan CLI.

Menggunakan PowerShell

Untuk membuat kontainer dengan kebijakan pengindeksan kustom, lihat Membuat kontainer dengan kebijakan indeks kustom menggunakan PowerShell.

Menggunakan SDK .NET

.NET SDK V3

Objek ContainerProperties dari .NET SDK v3 mengekspos properti IndexingPolicy yang memungkinkan Anda mengubah IndexingMode dan menambahkan atau menghapus IncludedPaths dan ExcludedPaths. Untuk informasi selengkapnya, lihat Quickstart: Gunakan Azure Cosmos DB untuk NoSQL dengan Azure SDK untuk .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);

Untuk melacak kemajuan transformasi indeks, lewati objek RequestOptions yang mengatur properti PopulateQuotaInfo ke true. Ambil nilai dari header respons x-ms-documentdb-collection-index-transformation-progress.

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

API fasih SDK V3 memungkinkan Anda menulis definisi ini dengan cara yang ringkas dan efisien saat menentukan kebijakan pengindeksan kustom saat membuat kontainer baru:

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

Objek DocumentCollection dari .NET SDK v2 mengekspos properti IndexingPolicy yang memungkinkan Anda mengubah IndexingMode dan menambahkan atau menghapus IncludedPaths dan 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);

Untuk melacak kemajuan transformasi indeks, lewati objek RequestOptions yang mengatur properti PopulateQuotaInfo ke 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;

Menggunakan SDK Java

Objek DocumentCollection dari Java SDK mengekspos metode getIndexingPolicy() dan setIndexingPolicy(). Objek IndexingPolicy yang dimanipulasi memungkinkan Anda mengubah mode pengindeksan dan menambahkan atau menghapus jalur yang disertakan dan dikecualikan. Untuk informasi selengkapnya, lihat Quickstart: Gunakan Azure Cosmos DB untuk NoSQL dengan Azure SDK untuk 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);
});

Untuk melacak kemajuan transformasi indeks pada kontainer, berikan RequestOptions objek yang meminta info kuota diisi. Ambil nilai dari header respons x-ms-documentdb-collection-index-transformation-progress.

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

Menggunakan Node.js SDK

Antarmuka ContainerDefinition dari Node.js SDK mengekspos indexingPolicy properti yang memungkinkan Anda mengubah indexingMode dan menambahkan atau menghapus includedPaths dan excludedPaths. Untuk informasi selengkapnya, lihat Quickstart: Gunakan Azure Cosmos DB untuk NoSQL dengan Azure SDK untuk Node.js.

Dapatkan detail kontainer:

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

Atur mode pengindeksan ke konsisten:

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

Tambahkan jalur yang disertakan termasuk indeks spasial:

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

Tambahkan jalur yang dikecualikan:

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

Perbarui kontainer dengan perubahan:

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

Untuk melacak kemajuan transformasi indeks pada kontainer, operkan objek RequestOptions yang mengatur properti populateQuotaInfo menjadi true. Ambil nilai dari header respons x-ms-documentdb-collection-index-transformation-progress.

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

Tambahkan indeks komposit:

 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;

Menggunakan Go SDK

Struktur IndexingPolicy menentukan kebijakan pengindeksan untuk kontainer. Ini dapat digunakan saat Anda membuat kontainer baru atau mengonfigurasi ulang kontainer yang sudah ada.

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)

Menggunakan SDK Python

Python SDK V3

Saat Anda menggunakan Python SDK V3, konfigurasi kontainer dikelola sebagai kamus. Dari kamus ini, Anda dapat mengakses kebijakan pengindeksan dan semua atributnya. Untuk informasi selengkapnya, lihat Quickstart: Gunakan Azure Cosmos DB untuk NoSQL dengan Azure SDK untuk Python.

Dapatkan detail kontainer:

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

Atur mode pengindeksan ke konsisten:

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

Tentukan kebijakan pengindeksan dengan jalur yang disertakan dan indeks spasial:

container["indexingPolicy"] = {

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

Tentukan kebijakan pengindeksan dengan jalur yang dikecualikan:

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

Tambahkan indeks komposit:

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

Perbarui kontainer dengan perubahan:

response = client.ReplaceContainer(containerPath, container)

Python SDK V4

Saat Anda menggunakan Python SDK V4, konfigurasi kontainer dikelola sebagai kamus. Dari kamus ini, Anda dapat mengakses kebijakan pengindeksan dan semua atributnya.

Dapatkan detail kontainer:

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

Atur mode pengindeksan ke konsisten:

indexingPolicy = {
    'indexingMode': 'consistent'
}

Tentukan kebijakan pengindeksan dengan jalur yang disertakan dan indeks spasial:

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

Tentukan kebijakan pengindeksan dengan jalur yang dikecualikan:

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

Tambahkan indeks komposit:

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

Perbarui kontainer dengan perubahan:

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

Dapatkan informasi kemajuan transformasi indeks dari header tanggapan.

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

Konten terkait

• Gambaran umum pengindeksan dalam Azure Cosmos DB
• Kebijakan pengindeksan di Azure Cosmos DB