JSON 欄位

Milvus 允許您使用JSON 資料類型，在單一欄位內儲存結構化資料並建立索引。這使具有巢狀屬性的靈活模式成為可能，同時仍然允許通過 JSON 索引進行有效的過濾。

什麼是 JSON 欄位？

JSON 欄位是 Milvus 中一個模式定義的欄位，用來儲存結構化的鍵值資料。值可以包括字串、數字、布林值、陣列或深嵌套物件。

以下是一個 JSON 欄位在文件中的範例：

{
  "metadata": {
    "category": "electronics",
    "brand": "BrandA",
    "in_stock": true,
    "price": 99.99,
    "string_price": "99.99",
    "tags": ["clearance", "summer_sale"],
    "supplier": {
      "name": "SupplierX",
      "country": "USA",
      "contact": {
        "email": "support@supplierx.com",
        "phone": "+1-800-555-0199"
      }
    }
  }
}

在這個範例中

• metadata 是模式中定義的 JSON 欄位。

• 您可以儲存平面值 (例如category,in_stock)、陣列 (tags) 以及巢狀物件 (supplier)。

在模式中定義 JSON 欄位

要使用 JSON 欄位，請在集合模式中明確定義，指定DataType 為JSON 。

下面的範例建立了一個集合，其模式包含這些欄位：

• 主索引鍵 (product_id)

• 一個vector 欄位 (每個集合必須使用)

• 一個metadata 欄位，其類型為JSON ，可儲存結構化資料，如平面值、陣列或巢狀物件

from pymilvus import MilvusClient, DataType

client = MilvusClient(uri="http://localhost:19530")

# Create schema with a JSON field
schema = client.create_schema(auto_id=False, enable_dynamic_field=True)

schema.add_field(field_name="product_id", datatype=DataType.INT64, is_primary=True)
schema.add_field(field_name="vector", datatype=DataType.FLOAT_VECTOR, dim=5)
schema.add_field(field_name="metadata", datatype=DataType.JSON, nullable=True)  # JSON field that allows null values

client.create_collection(
    collection_name="product_catalog",
    schema=schema
)

import io.milvus.v2.client.*;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import io.milvus.v2.service.collection.request.AddFieldReq;

ConnectConfig config = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build();
MilvusClientV2 client = new MilvusClientV2(config);

CreateCollectionReq.CollectionSchema schema = CreateCollectionReq.CollectionSchema.builder()
        .enableDynamicField(true)
        .build();
        
schema.addField(AddFieldReq.builder()
        .fieldName("product_id")
        .dataType(DataType.Int64)
        .isPrimaryKey(Boolean.TRUE)
        .build());
schema.addField(AddFieldReq.builder()
        .fieldName("vector")
        .dataType(DataType.FloatVector)
        .dimension(5)
        .build());
schema.addField(AddFieldReq.builder()
        .fieldName("metadata")
        .dataType(DataType.JSON)
        .isNullable(true)
        .build());
        
CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("product_catalog")
        .collectionSchema(schema)
        .build();
client.createCollection(requestCreate);

import { MilvusClient, DataType } from '@zilliz/milvus2-sdk-node';

const client = new MilvusClient({
  address: 'localhost:19530'
});

// Create collection
await client.createCollection({
collection_name: "product_catalog",
fields: [
  {
    name: "product_id",
    data_type: DataType.Int64,
    is_primary_key: true,
    autoID: false
  },
  {
    name: "vector",
    data_type: DataType.FloatVector,
    dim: 5
  },
  {
    name: "metadata",
    data_type: DataType.JSON,
    nullable: true  // JSON field that allows null values
  }
],
enable_dynamic_field: true
});

import (
    "context"

    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "localhost:19530",
})
if err != nil {
    return err
}

schema := entity.NewSchema().WithDynamicFieldEnabled(true)
schema.WithField(entity.NewField().
    WithName("product_id").pk
    WithDataType(entity.FieldTypeInt64).
    WithIsPrimaryKey(true),
).WithField(entity.NewField().
    WithName("vector").
    WithDataType(entity.FieldTypeFloatVector).
    WithDim(5),
).WithField(entity.NewField().
    WithName("metadata").
    WithDataType(entity.FieldTypeJSON).
    WithNullable(true),
)

err = client.CreateCollection(ctx, milvusclient.NewCreateCollectionOption("product_catalog", schema))
if err != nil {
    return err
}

# restful
export TOKEN="root:Milvus"
export CLUSTER_ENDPOINT="http://localhost:19530"

# 字段定义
export productIdField='{
  "fieldName": "product_id",
  "dataType": "Int64",
  "isPrimary": true,
  "autoID": false
}'

export vectorField='{
  "fieldName": "vector",
  "dataType": "FloatVector",
  "typeParams": {
    "dim": 5
  }
}'

export metadataField='{
  "fieldName": "metadata",
  "dataType": "JSON",
  "isNullable": true
}'

# 构造 schema
export schema="{
  \"autoID\": false,
  \"enableDynamicField\": true,
  \"fields\": [
    $productIdField,
    $vectorField,
    $metadataField
  ]
}"

# 创建集合
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--data "{
  \"collectionName\": \"product_catalog\",
  \"schema\": $schema
}"

插入具有 JSON 資料的實體

建立集合後，在metadata JSON 欄位中插入包含結構化 JSON 物件的實體。

entities = [
    {
        "product_id": 1,
        "vector": [0.1, 0.2, 0.3, 0.4, 0.5],
        "metadata": {
            "category": "electronics",
            "brand": "BrandA",
            "in_stock": True,
            "price": 99.99,
            "string_price": "99.99",
            "tags": ["clearance", "summer_sale"],
            "supplier": {
                "name": "SupplierX",
                "country": "USA",
                "contact": {
                    "email": "support@supplierx.com",
                    "phone": "+1-800-555-0199"
                }
            }
        }
    }
]

client.insert(collection_name="product_catalog", data=entities)

import com.google.gson.Gson;
import com.google.gson.JsonObject;

import io.milvus.v2.service.vector.request.InsertReq;

Gson gson = new Gson();
JsonObject row = new JsonObject();
row.addProperty("product_id", 1);
row.add("vector", gson.toJsonTree(Arrays.asList(0.1, 0.2, 0.3, 0.4, 0.5)));

JsonObject metadata = new JsonObject();
metadata.addProperty("category", "electronics");
metadata.addProperty("brand", "BrandA");
metadata.addProperty("in_stock", true);
metadata.addProperty("price", 99.99);
metadata.addProperty("string_price", "99.99");
metadata.add("tags", gson.toJsonTree(Arrays.asList("clearance", "summer_sale")));

JsonObject supplier = new JsonObject();
supplier.addProperty("name", "SupplierX");
supplier.addProperty("country", "USA");

JsonObject contact = new JsonObject();
contact.addProperty("email", "support@supplierx.com");
contact.addProperty("phone", "+1-800-555-0199");

supplier.add("contact", contact);
metadata.add("supplier", supplier);
row.add("metadata", metadata);

client.insert(InsertReq.builder()
        .collectionName("product_catalog")
        .data(Collections.singletonList(row))
        .build());

const entities = [
    {
        "product_id": 1,
        "vector": [0.1, 0.2, 0.3, 0.4, 0.5],
        "metadata": {
            "category": "electronics",
            "brand": "BrandA",
            "in_stock": True,
            "price": 99.99,
            "string_price": "99.99",
            "tags": ["clearance", "summer_sale"],
            "supplier": {
                "name": "SupplierX",
                "country": "USA",
                "contact": {
                    "email": "support@supplierx.com",
                    "phone": "+1-800-555-0199"
                }
            }
        }
    }
]

await client.insert({
    collection_name: "product_catalog", 
    data: entities
});

_, err = client.Insert(ctx, milvusclient.NewColumnBasedInsertOption("product_catalog").
    WithInt64Column("product_id", []int64{1}).
    WithFloatVectorColumn("vector", 5, [][]float32{
        {0.1, 0.2, 0.3, 0.4, 0.5},
    }).WithColumns(
    column.NewColumnJSONBytes("metadata", [][]byte{
        []byte(`{
            "category": "electronics",
            "brand": "BrandA",
            "in_stock": True,
            "price": 99.99,
            "string_price": "99.99",
            "tags": ["clearance", "summer_sale"],
            "supplier": {
                "name": "SupplierX",
                "country": "USA",
                "contact": {
                    "email": "support@supplierx.com",
                    "phone": "+1-800-555-0199"
                }
            }
        }`),
    }),
))
if err != nil {
    return err
}

# restful
export TOKEN="root:Milvus"
export CLUSTER_ENDPOINT="http://localhost:19530"

export entities='[
  {
    "product_id": 1,
    "vector": [0.1, 0.2, 0.3, 0.4, 0.5],
    "metadata": {
      "category": "electronics",
      "brand": "BrandA",
      "in_stock": true,
      "price": 99.99,
      "string_price": "99.99",
      "tags": ["clearance", "summer_sale"],
      "supplier": {
        "name": "SupplierX",
        "country": "USA",
        "contact": {
          "email": "support@supplierx.com",
          "phone": "+1-800-555-0199"
        }
      }
    }
  }
]'

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/product_catalog/insert" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--data "{
  \"data\": $entities
}"

在 JSON 欄位內索引值

為了加速 JSON 欄位的標量篩選，Milvus 支援下列類型的索引：

• JSON 路徑索引- 以宣告的標量類型索引特定的 JSON 路徑。

• JSON 平面索引- 以自動類型推斷方式索引整個 JSON 物件（或子樹）。

選擇路徑索引或平面索引Compatible with Milvus 2.6.x

能力	JSON 路徑索引	JSON 平面索引
索引的內容	您指定的特定路徑	物件路徑下的所有扁平化路徑
類型處理	您宣告json_cast_type (標量類型)	必須是 JSON (自動類型推斷)
陣列為 LHS¹	支援	不支援
查詢速度	索引路徑上高	高，平均略低
磁碟使用量	較低	較高

¹陣列作為 LHS表示篩選表達式的左側是 JSON 陣列，例如：

metadata["tags"] == ["clearance", "summer_sale"]
json_contains(metadata["tags"], "clearance")

在這些情況下，metadata["tags"] 是陣列。JSON 平面索引無法加速此類篩選 - 請使用具有陣列轉換類型的 JSON 路徑索引。

在下列情況下使用 JSON 路徑索引

• 您事先知道要查詢的熱鍵。

• 需要篩選左側為陣列的項目。

• 希望將磁碟使用量降至最低。

在下列情況下使用 JSON flat 索引

• 您想要索引整個子樹 (包括根目錄)。

• 您的 JSON 結構經常改變。

• 您想要更廣泛的查詢範圍，而不需要宣告每條路徑。

JSON 路徑索引

若要建立 JSON 路徑索引，請指定：

• JSON path(json_path)：您要索引的 JSON 物件中的關鍵或巢狀欄位的路徑。

  • 範例：

    • 對於關鍵字、metadata["category"]

    • 對於巢狀欄位、metadata["contact"]["email"]

    這定義了索引引擎應該在 JSON 結構中尋找的位置。

• JSON 轉換類型(json_cast_type)：Milvus 在指定路徑解釋和索引值時應該使用的資料類型。

  • 此類型必須與被索引欄位的實際資料類型相符。如果您想在編制索引時將資料類型轉換成其他類型，請考慮使用轉換函數。

  • 如需完整清單，請參閱下文。

支援的 JSON 轉換類型

轉換類型不區分大小寫。支援下列類型：

轉換類型	說明	範例 JSON 值
bool	布林值	true,false
double	數值（整數或浮點數）	42,99.99 、-15.5
varchar	字串值	"electronics","BrandA"
array_bool	布林數陣列	[true, false, true]
array_double	數字陣列	[1.2, 3.14, 42]
array_varchar	字串陣列	["tag1", "tag2", "tag3"]

範例：建立 JSON 路徑索引

使用介紹中的metadata JSON 結構，以下是如何在不同 JSON 路徑上建立索引的範例：

# Index the category field as a string
index_params = client.prepare_index_params()

index_params.add_index(
    field_name="metadata",
    index_type="AUTOINDEX", # Must be set to AUTOINDEX or INVERTED for JSON path indexing
    index_name="category_index",  # Unique index name
    params={
        "json_path": "metadata[\"category\"]", # Path to the JSON key to be indexed
        "json_cast_type": "varchar" # Data cast type
    }
)

# Index the tags array as string array
index_params.add_index(
    field_name="metadata",
    index_type="AUTOINDEX", # Must be set to AUTOINDEX or INVERTED for JSON path indexing
    index_name="tags_array_index", # Unique index name
    params={
        "json_path": "metadata[\"tags\"]", # Path to the JSON key to be indexed
        "json_cast_type": "array_varchar" # Data cast type
    }
)

import io.milvus.v2.common.IndexParam;

Map<String,Object> extraParams1 = new HashMap<>();
extraParams1.put("json_path", "metadata[\"category\"]");
extraParams1.put("json_cast_type", "varchar");
indexParams.add(IndexParam.builder()
        .fieldName("metadata")
        .indexName("category_index")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .extraParams(extraParams1)
        .build());

Map<String,Object> extraParams2 = new HashMap<>();
extraParams2.put("json_path", "metadata[\"tags\"]");
extraParams2.put("json_cast_type", "array_varchar");
indexParams.add(IndexParam.builder()
        .fieldName("metadata")
        .indexName("tags_array_index")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .extraParams(extraParams2)
        .build());

const indexParams = [
  {
    collection_name: "product_catalog",
    field_name: "metadata",
    index_name: "category_index",
    index_type: "AUTOINDEX", // Can also use "INVERTED" for JSON path indexing
    extra_params: {
      json_path: 'metadata["category"]',
      json_cast_type: "varchar",
    },
  },
  {
    collection_name: "product_catalog",
    field_name: "metadata",
    index_name: "tags_array_index",
    index_type: "AUTOINDEX", // Can also use "INVERTED" for JSON path indexing
    extra_params: {
      json_path: 'metadata["tags"]',
      json_cast_type: "array_varchar",
    },
  },
];

import (
    "github.com/milvus-io/milvus/client/v2/index"
)

jsonIndex1 := index.NewJSONPathIndex(index.AUTOINDEX, "varchar", `metadata["category"]`)
    .WithIndexName("category_index")
jsonIndex2 := index.NewJSONPathIndex(index.AUTOINDEX, "array_varchar", `metadata["tags"]`)
    .WithIndexName("tags_array_index")

indexOpt1 := milvusclient.NewCreateIndexOption("product_catalog", "metadata", jsonIndex1)
indexOpt2 := milvusclient.NewCreateIndexOption("product_catalog", "metadata", jsonIndex2)

# restful
export categoryIndex='{
  "fieldName": "metadata",
  "indexName": "category_index",
  "params": {
    "index_type": "AUTOINDEX",
    "json_path": "metadata[\\\"category\\\"]",
    "json_cast_type": "varchar"
  }
}'

export tagsArrayIndex='{
  "fieldName": "metadata",
  "indexName": "tags_array_index",
  "params": {
    "index_type": "AUTOINDEX",
    "json_path": "metadata[\\\"tags\\\"]",
    "json_cast_type": "array_varchar"
  }
}'

使用 JSON 轉換函式進行類型轉換Compatible with Milvus 2.5.14+

如果您的 JSON 欄位 key 包含格式不正確的值 (例如，以字串形式儲存的數字)，您可以在建立索引時使用轉換函數 (cast functions) 來轉換值。

支援的轉換函數

轉換函數不區分大小寫。支援下列類型：

轉換函數	轉換自 → 轉換為	使用範例
"STRING_TO_DOUBLE"	字串 → 數字 (雙倍)	轉換"99.99" 至99.99

範例：將字串數字轉換為 double

# Convert string numbers to double for indexing
index_params.add_index(
    field_name="metadata",
    index_type="AUTOINDEX", # Must be set to AUTOINDEX or INVERTED for JSON path indexing
    index_name="string_to_double_index", # Unique index name
    params={
        "json_path": "metadata[\"string_price\"]", # Path to the JSON key to be indexed
        "json_cast_type": "double", # Data cast type
        "json_cast_function": "STRING_TO_DOUBLE" # Cast function; case insensitive
    }
)

Map<String,Object> extraParams3 = new HashMap<>();
extraParams3.put("json_path", "metadata[\"string_price\"]");
extraParams3.put("json_cast_type", "double");
extraParams3.put("json_cast_function", "STRING_TO_DOUBLE");
indexParams.add(IndexParam.builder()
        .fieldName("metadata")
        .indexName("string_to_double_index")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .extraParams(extraParams3)
        .build());

indexParams.push({
  collection_name: "product_catalog",
  field_name: "metadata",
  index_name: "string_to_double_index",
  index_type: "AUTOINDEX", // Can also use "INVERTED"
  extra_params: {
    json_path: 'metadata["string_price"]',
    json_cast_type: "double",
    json_cast_function: "STRING_TO_DOUBLE", // Case insensitive
  },
});

jsonIndex3 := index.NewJSONPathIndex(index.AUTOINDEX, "double", `metadata["string_price"]`)
                    .WithIndexName("string_to_double_index")

indexOpt3 := milvusclient.NewCreateIndexOption("product_catalog", "metadata", jsonIndex3)

# restful
export stringToDoubleIndex='{
  "fieldName": "metadata",
  "indexName": "string_to_double_index",
  "params": {
    "index_type": "AUTOINDEX",
    "json_path": "metadata[\\\"string_price\\\"]",
    "json_cast_type": "double",
    "json_cast_function": "STRING_TO_DOUBLE"
  }
}'

JSON 平面索引Compatible with Milvus 2.6.x

對於 JSON扁平化索引，Milvus 會透過扁平化JSON 結構和自動推斷每個值的類型，來索引 JSON 物件路徑（包括巢狀物件）內的所有鍵值對（key-value pairs）。

扁平化和類型推斷如何工作

當您在物件路徑上建立一個 JSON 平面索引時，Milvus 會

1. 扁平化- 從指定的json_path 開始，以遞迴方式遍歷物件，並將巢狀的 key-value 對抽取為完全限定路徑。使用先前metadata 的範例：

   "metadata": {
     "category": "electronics",
     "price": 99.99,
     "supplier": { "country": "USA" }
   }
   

   成為：

   metadata["category"] = "electronics"
   metadata["price"] = 99.99
   metadata["supplier"]["country"] = "USA"
   

2. 自動推斷類型- 對於每個值，Milvus 會依下列順序決定其類型：

   unsigned integer → signed integer → floating-point → string
   

   第一個符合值的類型會被用於索引。

   這表示推斷的類型永遠是這四種之一。

   每個文件都會執行類型推斷，因此相同的路徑在不同的文件中會有不同的推斷類型。

   在類型推斷之後，扁平化資料在內部表示為具有其推斷類型的術語，例如：

   ("category", Text, "electronics")
   ("price", Double, 99.99)
   ("supplier.country", Text, "USA")
   

範例：建立 JSON 扁平化索引

# 1. Create a flat index on the root object of the JSON column (covers the entire JSON subtree)
index_params.add_index(
    field_name="metadata",
    index_type="AUTOINDEX",          # Or "INVERTED", same as Path Index
    index_name="metadata_flat",      # Unique index name
    params={
        "json_path": 'metadata',     # Object path: the root object of the column
        "json_cast_type": "JSON"     # Key difference: must be "JSON" for Flat Index; case-insensitive
    }
)

# 2. Optionally, create a flat index on a sub-object (e.g., supplier subtree)
index_params.add_index(
    field_name="metadata",
    index_type="AUTOINDEX",
    index_name="metadata_supplier_flat",
    params={
        "json_path": 'metadata["supplier"]',  # Object path: sub-object path
        "json_cast_type": "JSON"
    }
)

// java

// nodejs

// go

# restful

將索引套用至集合

定義索引參數後，您可以使用create_index() 將其套用至集合：

client.create_index(
    collection_name="product_catalog",
    index_params=index_params
)

import io.milvus.v2.service.index.request.CreateIndexReq;

client.createIndex(CreateIndexReq.builder()
        .collectionName("product_catalog")
        .indexParams(indexParams)
        .build());

await client.createIndex(indexParams)

indexTask1, err := client.CreateIndex(ctx, indexOpt1)
if err != nil {
    return err
}
indexTask2, err := client.CreateIndex(ctx, indexOpt2)
if err != nil {
    return err
}
indexTask3, err := client.CreateIndex(ctx, indexOpt3)
if err != nil {
    return err
}

# restful
export indexParams="[
  $categoryIndex,
  $tagsArrayIndex,
  $stringToDoubleIndex
]"
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/indexes/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--data "{
  \"collectionName\": \"product_catalog\",
  \"indexParams\": $indexParams
}"

依 JSON 欄位值篩選

插入 JSON 欄位並編入索引之後，您可以使用 JSON 路徑語法的標準篩選表達式來篩選它們。

例如

filter = 'metadata["category"] == "electronics"'
filter = 'metadata["price"] > 50'
filter = 'json_contains(metadata["tags"], "featured")'

String filter = 'metadata["category"] == "electronics"';
String filter = 'metadata["price"] > 50';
String filter = 'json_contains(metadata["tags"], "featured")';

let filter = 'metadata["category"] == "electronics"'
let filter = 'metadata["price"] > 50'
let filter = 'json_contains(metadata["tags"], "featured")'

filter := 'metadata["category"] == "electronics"'
filter := 'metadata["price"] > 50'
filter := 'json_contains(metadata["tags"], "featured")'

# restful
export filterCategory='metadata["category"] == "electronics"'
export filterPrice='metadata["price"] > 50'
export filterTags='json_contains(metadata["tags"], "featured")'

若要在搜尋或查詢中使用這些表達式，請確定

• 您已在每個向量欄位上建立索引。

• 集合已載入記憶體。

如需支援的運算符和表達式的完整清單，請參閱JSON 運算符。

將所有內容整合在一起

到目前為止，您已經學會了如何在 JSON 欄位中定義、插入結構化的值，以及選用索引。

若要在實際應用程式中完成工作流程，您還需要

• 在您的向量欄位上建立索引（集合中的每個向量欄位都必須建立索引）

  請參閱設定索引參數

• 載入集合

  請參閱載入與釋出

• 使用 JSON 路徑篩選器進行搜尋或查詢

  請參閱篩選搜尋和 JSON 運算符號

常見問題

JSON 欄位和動態欄位有什麼不同？

• JSON 欄位是模式定義的。您必須在模式中明確宣告欄位。

• 動態欄位是隱藏的 JSON 物件 ($meta)，可自動儲存模式中未定義的任何欄位。

兩者都支援巢狀結構和 JSON 路徑索引，但動態欄位更適合可選或演進的資料結構。

詳情請參閱動態欄位。

JSON 欄位的大小有任何限制嗎？

有。每個 JSON 欄位的大小限制為 65,536 位元組。

JSON 欄位是否支援設定預設值？

不，JSON 欄位不支援預設值。但是，您可以在定義欄位時設定nullable=True ，以允許空項目。

詳情請參閱Nullable & Default。

JSON 欄位鍵有任何命名慣例嗎？

有，以確保與查詢和索引的相容性：

• 在 JSON 鍵中只使用字母、數字和底線。

• 避免使用特殊字符、空格或點 (.,/, 等等)。

• 不相容的鍵可能會在篩選表達式中造成解析問題。

Milvus 如何處理 JSON 欄位中的字串值？

Milvus 完全按照 JSON 輸入中出現的字串值來儲存，沒有語義轉換。引號不當的字串可能會在解析過程中導致錯誤。

有效字串的範例：

"a\"b", "a'b", "a\\b"

無效字串的範例：

'a"b', 'a\'b'

Milvus 對索引的 JSON 路徑使用什麼過濾邏輯？

• 數字索引：

  如果使用json_cast_type="double" 建立索引，則只有數字篩選條件 (例如>,<,== 42) 會利用索引。非數字條件可能會退回到暴力掃描。

• 字串索引：

  如果索引使用json_cast_type="varchar" ，則只有字串篩選條件可從索引中獲益；其他類型可能會退回到暴力掃描。

• 布林索引：

  布林索引的行為與字串索引類似，只有當條件嚴格符合真或假時，才會使用索引。

索引 JSON 欄位時，數值精確度如何？

Milvus 將所有索引的數值儲存為雙倍。

如果數值超過2^53，可能會失去精確度。這種精確度的損失可能會導致過濾器查詢無法精確匹配超出範圍的值。

我可以在同一個 JSON 路徑上，以不同的鑄模類型建立多個索引嗎？

不可以，每個 JSON 路徑只支援一個索引。您必須選擇符合您資料的單一json_cast_type 。不支援在同一路徑上以不同的鑄模類型建立多個索引。

如果 JSON 路徑上的值具有不一致的類型，該怎麼辦？

不同實體的類型不一致可能會導致部分索引。例如，如果metadata["price"] 以數字 (99.99) 和字串 ("99.99") 的形式儲存，而索引是以json_cast_type="double" 定義的，則只有數字值會被索引。字串形式的項目將會被跳過，並且不會出現在篩選結果中。

我可以使用不同於索引鑄模類型的篩選器嗎？

如果您的篩選表達式使用的類型與索引的json_cast_type 不同，系統將不會使用索引，並可能退回到較慢的暴力掃描 - 如果資料允許的話。為了獲得最佳效能，請務必使您的篩選表達式與索引的鑄模類型一致。