Campo JSON

Milvus le permite almacenar e indexar datos estructurados dentro de un único campo utilizando el tipo de datos JSON. Esto permite esquemas flexibles con atributos anidados a la vez que permite un filtrado eficiente a través de la indexación JSON.

¿Qué es un campo JSON?

Un campo JSON es un campo definido por esquema en Milvus que almacena datos estructurados clave-valor. Los valores pueden incluir cadenas, números, booleanos, matrices u objetos profundamente anidados.

He aquí un ejemplo del aspecto que puede tener un campo JSON en un documento:

{
  "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"
      }
    }
  }
}

En este ejemplo

• metadata es el campo JSON definido en el esquema.

• Puede almacenar valores planos (por ejemplo, category, in_stock), matrices (tags) y objetos anidados (supplier).

Definir un campo JSON en el esquema

Para utilizar un campo JSON, defínalo explícitamente en el esquema de la colección especificando DataType como JSON.

El ejemplo siguiente crea una colección cuyo esquema contiene estos campos:

• La clave primaria (product_id)

• Un campo vector (obligatorio para cada colección)

• Un campo metadata de tipo JSON, que puede almacenar datos estructurados como valores planos, matrices u objetos anidados.

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
}"

Insertar entidades con datos JSON

Una vez creada la colección, inserte entidades que contengan objetos JSON estructurados en el campo JSON de metadata.

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
}"

Indexar valores dentro del campo JSON

Para acelerar el filtrado escalar en campos JSON, Milvus soporta los siguientes tipos de índices:

• Índice de ruta JSON - indexa rutas JSON específicas con un tipo escalar declarado.

• Índice plano JSON - indexa un objeto JSON entero (o subárbol) con inferencia automática de tipo.

Elija entre índice de rutas e índice planoCompatible with Milvus 2.6.x

Capacidad	Índice de rutas JSON	Índice plano JSON
Qué indexa	Ruta(s) específica(s) que usted nombre	Todas las rutas planas bajo una ruta de objeto
Gestión de tipos	Usted declara json_cast_type (tipos escalares)	Debe ser JSON (auto type inference)
Arrays como LHS¹	Soportado	No se admite
Velocidad de consulta	Alta en rutas indexadas	Alta, ligeramente inferior de media
Uso del disco	Bajo	Mayor

¹ Matrices como LHS significa que el lado izquierdo de la expresión del filtro es una matriz JSON, por ejemplo:

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

En estos casos, metadata["tags"] es una matriz. La indexación plana JSON no acelera este tipo de filtros - utilice en su lugar un índice de ruta JSON con un tipo de molde de matriz.

Utilice el índice de ruta JSON cuando:

• Conoce de antemano las teclas de acceso rápido que debe consultar.

• Necesita filtrar cuando el lado izquierdo es un array.

• Desea minimizar el uso de disco.

Utilice el índice plano JSON cuando:

• Quieres indexar un subárbol entero (incluyendo la raíz).

• La estructura JSON cambia con frecuencia.

• Desea una cobertura de consulta más amplia sin declarar cada ruta.

Indexación de rutas JSON

Para crear un índice de rutas JSON, especifique:

• Ruta JSON (json_path): La ruta a la clave o campo anidado dentro de su objeto JSON que desea indexar.

  • Ejemplo:

    • Para una clave, metadata["category"]

    • Para un campo anidado, metadata["contact"]["email"]

    Define dónde debe buscar el motor de indexación dentro de la estructura JSON.

• Tipo de reparto JSON (json_cast_type): El tipo de datos que Milvus debe utilizar al interpretar e indexar el valor en la ruta especificada.

  • Este tipo debe coincidir con el tipo de datos real del campo que se está indexando. Si desea convertir el tipo de datos a otro durante la indexación, considere utilizar una función cast.

  • Para obtener una lista completa, consulte más abajo.

Tipos de conversión JSON admitidos

Los tipos de conversión no distinguen entre mayúsculas y minúsculas. Se admiten los siguientes tipos:

Tipo de conversión	Descripción	Ejemplo de valor JSON
bool	Valor booleano	true, false
double	Valor numérico (entero o flotante)	42, 99.99, -15.5
varchar	Valor de cadena	"electronics", "BrandA"
array_bool	Matriz de booleanos	[true, false, true]
array_double	Matriz de números	[1.2, 3.14, 42]
array_varchar	Matriz de cadenas	["tag1", "tag2", "tag3"]

Ejemplo: Creación de índices de rutas JSON

Utilizando la estructura JSON metadata de nuestra introducción, aquí tienes ejemplos de cómo crear índices en diferentes rutas 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"
  }
}'

Utiliza las funciones JSON cast para la conversión de tiposCompatible with Milvus 2.5.14+

Si tu clave de campo JSON contiene valores en un formato incorrecto (por ejemplo, números almacenados como cadenas), puedes utilizar funciones cast para convertir los valores durante la indexación.

Funciones de conversión admitidas

Las funciones de conversión no distinguen entre mayúsculas y minúsculas. Se admiten los siguientes tipos:

Función Cast	Convierte De → A	Caso de uso
"STRING_TO_DOUBLE"	Cadena → Numérico (doble)	Convierte "99.99" a 99.99

Ejemplo: Convertir números de cadena a doble

# 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"
  }
}'

Indexación plana JSONCompatible with Milvus 2.6.x

Para la indexación plana JSON, Milvus indexa todos los pares clave-valor dentro de una ruta de objetos JSON (incluidos los objetos anidados) aplanando la estructura JSON e infiriendo automáticamente el tipo de cada valor.

Cómo funcionan el aplanamiento y la inferencia de tipos

Cuando crea un índice plano JSON en una ruta de objeto, Milvus:

1. Aplanará - Recorrerá recursivamente el objeto comenzando por el json_path especificado y extraerá los pares clave-valor anidados como rutas totalmente cualificadas. Utilizando el ejemplo anterior de metadata:

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

   se convierte en:

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

2. Inferir tipos automáticamente - Para cada valor, Milvus determina su tipo en el siguiente orden:

   unsigned integer → signed integer → floating-point → string
   

   El primer tipo que se ajusta al valor se utiliza para la indexación.

   Esto significa que el tipo inferido será siempre uno de estos cuatro.

   La inferencia de tipo se realiza por documento, por lo que una misma ruta puede tener diferentes tipos inferidos en los distintos documentos.

   Tras la inferencia de tipos, los datos aplanados se representan internamente como términos con sus tipos inferidos, por ejemplo:

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

Ejemplo: Crear índice plano 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

Aplicar índices a la colección

Después de definir los parámetros del índice, puede aplicarlos a la colección utilizando 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
}"

Filtrar por valores de campo JSON

Después de insertar e indexar campos JSON, puedes filtrar sobre ellos utilizando expresiones de filtrado estándar con sintaxis de ruta JSON.

Por ejemplo

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")'

Para utilizar estas expresiones en una búsqueda o consulta, asegúrate de que

• Has creado un índice en cada campo vectorial.

• La colección está cargada en memoria.

Para obtener una lista completa de los operadores y expresiones compatibles, consulte Operadores JSON.

Juntarlo todo

Hasta ahora, has aprendido cómo definir, insertar y, opcionalmente, indexar valores estructurados dentro de un campo JSON.

Para completar el flujo de trabajo en una aplicación del mundo real, también necesitarás:

• Crear un índice en sus campos v ectoriales (obligatorio para cada campo vectorial de una colección).

  Consulte Establecer parámetros de índice

• Cargar la colección

  Consulte Cargar y liberar

• Buscar o consultar utilizando filtros de ruta JSON

  Consulte Búsqueda filtrada y operadores JSON

PREGUNTAS FRECUENTES

¿Cuáles son las diferencias entre un campo JSON y un campo dinámico?

• Elcampo JSON está definido por el esquema. Debe declarar explícitamente el campo en el esquema.

• El campo dinámico es un objeto JSON oculto ($meta) que almacena automáticamente cualquier campo no definido en el esquema.

Ambos admiten estructuras anidadas e indexación de rutas JSON, pero los campos dinámicos son más adecuados para estructuras de datos opcionales o en evolución.

Consulte Campo dinámico para más detalles.

¿Existen limitaciones en cuanto al tamaño de un campo JSON?

Sí. Cada campo JSON está limitado a 65.536 bytes.

¿Es posible establecer un valor por defecto en un campo JSON?

No, los campos JSON no admiten valores por defecto. Sin embargo, puede configurar nullable=True al definir el campo para permitir entradas vacías.

Consulte Nullable & Default para más detalles.

¿Existen convenciones de nomenclatura para las claves de los campos JSON?

Sí, para garantizar la compatibilidad con las consultas y la indexación:

• Utilice sólo letras, números y guiones bajos en las claves JSON.

• Evite utilizar caracteres especiales, espacios o puntos (., /, etc.).

• Las claves incompatibles pueden causar problemas de análisis en las expresiones de filtro.

¿Cómo maneja Milvus los valores de cadena en los campos JSON?

Milvus almacena los valores de cadena exactamente como aparecen en la entrada JSON, sin transformación semántica. Las cadenas entrecomilladas incorrectamente pueden dar lugar a errores durante el análisis.

Ejemplos de cadenas válidas:

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

Ejemplos de cadenas no válidas:

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

¿Qué lógica de filtrado utiliza Milvus para las rutas JSON indexadas?

• Indexación numérica:

  Si se crea un índice con json_cast_type="double", sólo las condiciones de filtro numéricas (por ejemplo, >, <, == 42) aprovecharán el índice. Las condiciones no numéricas pueden retroceder a un escaneo de fuerza bruta.

• Indexación de cadenas:

  Si un índice utiliza json_cast_type="varchar", sólo las condiciones de filtro de cadena se beneficiarán del índice; otros tipos pueden retroceder a una exploración de fuerza bruta.

• Indexación booleana:

  La indexación booleana se comporta de forma similar a la indexación de cadenas, con el uso del índice sólo cuando la condición coincide estrictamente con verdadero o falso.

¿Qué ocurre con la precisión numérica al indexar campos JSON?

Milvus almacena todos los valores numéricos indexados como dobles.

Si un valor numérico supera 2^53, puede perder precisión. Esta pérdida de precisión puede provocar que las consultas de filtrado no coincidan exactamente con valores fuera de rango.

¿Puedo crear varios índices en la misma ruta JSON con diferentes tipos de reparto?

No, cada ruta JSON sólo admite un índice. Debe elegir un único json_cast_type que coincida con sus datos. No es posible crear varios índices en la misma ruta con distintos tipos de molde.

¿Qué ocurre si los valores de una ruta JSON tienen tipos incoherentes?

Los tipos incoherentes entre entidades pueden provocar una indexación parcial. Por ejemplo, si metadata["price"] se almacena como número (99.99) y como cadena ("99.99"), y el índice se define con json_cast_type="double", sólo se indexarán los valores numéricos. Las entradas en forma de cadena se omitirán y no aparecerán en los resultados del filtro.

¿Puedo utilizar filtros con un tipo distinto del tipo de molde indexado?

Si su expresión de filtro utiliza un tipo diferente al del índice json_cast_type, el sistema no utilizará el índice y puede recurrir a una exploración de fuerza bruta más lenta, si los datos lo permiten. Para un mejor rendimiento, alinee siempre su expresión de filtro con el tipo de molde del índice.