Anulable y por defecto
Milvus le permite establecer el atributo nullable y valores por defecto para campos escalares, excepto el campo primario. Para los campos marcados como nullable=True, puede omitir el campo al insertar datos, o establecer directamente un valor nulo, y el sistema lo tratará como nulo sin provocar un error. Cuando un campo tiene un valor por defecto, el sistema aplicará automáticamente este valor si no se especifican datos para el campo durante la inserción.
Los atributos de valor por defecto y anulable agilizan la migración de datos de otros sistemas de bases de datos a Milvus al permitir el manejo de conjuntos de datos con valores nulos y preservar la configuración de valores por defecto. Al crear una colección, también puede habilitar los valores nulos o establecer valores por defecto para los campos en los que los valores pueden ser inciertos.
Límites
Sólo los campos escalares, excluido el campo primario, admiten valores por defecto y el atributo nullable.
Los campos JSON y Array no admiten valores por defecto.
Los valores por defecto o el atributo nullable sólo pueden configurarse durante la creación de la colección y no pueden modificarse posteriormente.
Los campos escalares con el atributo nullable activado no se pueden utilizar como
group_by_fielden la búsqueda de agrupación. Para obtener más información sobre la búsqueda de agrupación, consulte Búsqueda de agrupación.Los campos marcados como anulables no pueden utilizarse como claves de partición. Para más información sobre claves de partición, consulte Utilizar clave de partición.
Al crear un índice en un campo escalar con el atributo anulable activado, los valores nulos se excluirán del índice.
Atributo nullable
El atributo nullable permite almacenar valores nulos en una colección, lo que proporciona flexibilidad a la hora de manejar datos desconocidos.
Establecer el atributo nullable
Al crear una colección, utilice nullable=True para definir los campos anulables (por defecto, False). El siguiente ejemplo crea una colección llamada user_profiles_null y define el campo age como anulable.
from pymilvus import MilvusClient, DataType
client = MilvusClient(uri='http://localhost:19530')
# Define collection schema
schema = client.create_schema(
auto_id=False,
enable_dynamic_schema=True,
)
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)
schema.add_field(field_name="vector", datatype=DataType.FLOAT_VECTOR, dim=5)
schema.add_field(field_name="age", datatype=DataType.INT64, nullable=True) # Nullable field
# Set index params
index_params = client.prepare_index_params()
index_params.add_index(field_name="vector", index_type="IVF_FLAT", metric_type="L2", params={ "nlist": 128 })
# Create collection
client.create_collection(collection_name="user_profiles_null", schema=schema, index_params=index_params)
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.common.IndexParam;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import java.util.*;
MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
.uri("http://localhost:19530")
.build());
CreateCollectionReq.CollectionSchema schema = client.createSchema();
schema.setEnableDynamicField(true);
schema.addField(AddFieldReq.builder()
.fieldName("id")
.dataType(DataType.Int64)
.isPrimaryKey(true)
.build());
schema.addField(AddFieldReq.builder()
.fieldName("vector")
.dataType(DataType.FloatVector)
.dimension(5)
.build());
schema.addField(AddFieldReq.builder()
.fieldName("age")
.dataType(DataType.Int64)
.isNullable(true)
.build());
List<IndexParam> indexes = new ArrayList<>();
Map<String,Object> extraParams = new HashMap<>();
extraParams.put("nlist", 128);
indexes.add(IndexParam.builder()
.fieldName("vector")
.indexType(IndexParam.IndexType.IVF_FLAT)
.metricType(IndexParam.MetricType.L2)
.extraParams(extraParams)
.build());
CreateCollectionReq requestCreate = CreateCollectionReq.builder()
.collectionName("user_profiles_null")
.collectionSchema(schema)
.indexParams(indexes)
.build();
client.createCollection(requestCreate);
import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";
const client = new MilvusClient({
address: "http://localhost:19530",
token: "root:Milvus",
});
await client.createCollection({
collection_name: "user_profiles_null",
schema: [
{
name: "id",
is_primary_key: true,
data_type: DataType.int64,
},
{ name: "vector", data_type: DataType.Int64, dim: 5 },
{ name: "age", data_type: DataType.FloatVector, nullable: true },
],
index_params: [
{
index_name: "vector_inde",
field_name: "vector",
metric_type: MetricType.L2,
index_type: IndexType.AUTOINDEX,
},
],
});
export pkField='{
"fieldName": "id",
"dataType": "Int64",
"isPrimary": true
}'
export vectorField='{
"fieldName": "vector",
"dataType": "FloatVector",
"elementTypeParams": {
"dim": 5
}
}'
export nullField='{
"fieldName": "age",
"dataType": "Int64",
"nullable": true
}'
export schema="{
\"autoID\": false,
\"fields\": [
$pkField,
$vectorField,
$nullField
]
}"
export indexParams='[
{
"fieldName": "vector",
"metricType": "L2",
"indexType": "IVF_FLAT",
"params":{"nlist": 128}
}
]'
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d "{
\"collectionName\": \"user_profiles_null\",
\"schema\": $schema,
\"indexParams\": $indexParams
}"
Insertar entidades
Cuando insertes datos en un campo anulable, inserta null u omite directamente este campo.
data = [
{"id": 1, "vector": [0.1, 0.2, 0.3, 0.4, 0.5], "age": 30},
{"id": 2, "vector": [0.2, 0.3, 0.4, 0.5, 0.6], "age": None},
{"id": 3, "vector": [0.3, 0.4, 0.5, 0.6, 0.7]}
]
client.insert(collection_name="user_profiles_null", data=data)
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import io.milvus.v2.service.vector.request.InsertReq;
import io.milvus.v2.service.vector.response.InsertResp;
List<JsonObject> rows = new ArrayList<>();
Gson gson = new Gson();
rows.add(gson.fromJson("{\"id\": 1, \"vector\": [0.1, 0.2, 0.3, 0.4, 0.5], \"age\": 30}", JsonObject.class));
rows.add(gson.fromJson("{\"id\": 2, \"vector\": [0.2, 0.3, 0.4, 0.5, 0.6], \"age\": null}", JsonObject.class));
rows.add(gson.fromJson("{\"id\": 3, \"vector\": [0.3, 0.4, 0.5, 0.6, 0.7]}", JsonObject.class));
InsertResp insertR = client.insert(InsertReq.builder()
.collectionName("user_profiles_null")
.data(rows)
.build());
const data = [
{ id: 1, vector: [0.1, 0.2, 0.3, 0.4, 0.5], age: 30 },
{ id: 2, vector: [0.2, 0.3, 0.4, 0.5, 0.6], age: null },
{ id: 3, vector: [0.3, 0.4, 0.5, 0.6, 0.7] },
];
client.insert({
collection_name: "user_profiles_null",
data: data,
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/insert" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
"data": [
{"id": 1, "vector": [0.1, 0.2, 0.3, 0.4, 0.5], "age": 30},
{"id": 2, "vector": [0.2, 0.3, 0.4, 0.5, 0.6], "age": null},
{"id": 3, "vector": [0.3, 0.4, 0.5, 0.6, 0.7]}
],
"collectionName": "user_profiles_null"
}'
Búsqueda y consulta con valores nulos
Al utilizar el método search, si un campo contiene valores null, el resultado de la búsqueda devolverá el campo como nulo.
res = client.search(
collection_name="user_profiles_null",
data=[[0.1, 0.2, 0.4, 0.3, 0.128]],
limit=2,
search_params={"params": {"nprobe": 16}},
output_fields=["id", "age"]
)
print(res)
# Output
# data: ["[{'id': 1, 'distance': 0.15838398039340973, 'entity': {'age': 30, 'id': 1}}, {'id': 2, 'distance': 0.28278401494026184, 'entity': {'age': None, 'id': 2}}]"]
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.response.SearchResp;
Map<String,Object> params = new HashMap<>();
params.put("nprobe", 16);
SearchResp resp = client.search(SearchReq.builder()
.collectionName("user_profiles_null")
.annsField("vector")
.data(Collections.singletonList(new FloatVec(new float[]{0.1f, 0.2f, 0.3f, 0.4f, 0.5f})))
.topK(2)
.searchParams(params)
.outputFields(Arrays.asList("id", "age"))
.build());
System.out.println(resp.getSearchResults());
// Output
//
// [[SearchResp.SearchResult(entity={id=1, age=30}, score=0.0, id=1), SearchResp.SearchResult(entity={id=2, age=null}, score=0.050000004, id=2)]]
client.search({
collection_name: 'user_profiles_null',
data: [0.3, -0.6, 0.1, 0.3, 0.5],
limit: 2,
output_fields: ['age', 'id'],
filter: '25 <= age <= 35',
params: {
nprobe: 16
}
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
"collectionName": "user_profiles_null",
"data": [
[0.1, -0.2, 0.3, 0.4, 0.5]
],
"annsField": "vector",
"limit": 5,
"outputFields": ["id", "age"]
}'
#{"code":0,"cost":0,"data":[{"age":30,"distance":0.16000001,"id":1},{"age":null,"distance":0.28999996,"id":2},{"age":null,"distance":0.52000004,"id":3}]}
Cuando se utiliza el método query para el filtrado escalar, los resultados de filtrado para valores nulos son todos falsos, indicando que no serán seleccionados.
# Reviewing previously inserted data:
# {"id": 1, "vector": [0.1, 0.2, ..., 0.128], "age": 30}
# {"id": 2, "vector": [0.2, 0.3, ..., 0.129], "age": None}
# {"id": 3, "vector": [0.3, 0.4, ..., 0.130], "age": None} # Omitted age column is treated as None
results = client.query(
collection_name="user_profiles_null",
filter="age >= 0",
output_fields=["id", "age"]
)
# Example output:
# [
# {"id": 1, "age": 30}
# ]
# Note: Entities with `age` as `null` (id 2 and 3) will not appear in the result.
import io.milvus.v2.service.vector.request.QueryReq;
import io.milvus.v2.service.vector.response.QueryResp;
QueryResp resp = client.query(QueryReq.builder()
.collectionName("user_profiles_null")
.filter("age >= 0")
.outputFields(Arrays.asList("id", "age"))
.build());
System.out.println(resp.getQueryResults());
// Output
//
// [QueryResp.QueryResult(entity={id=1, age=30})]
const results = await client.query(
collection_name: "user_profiles_null",
filter: "age >= 0",
output_fields: ["id", "age"]
);
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
"collectionName": "user_profiles_null",
"filter": "age >= 0",
"outputFields": ["id", "age"]
}'
# {"code":0,"cost":0,"data":[{"age":30,"id":1}]}
Para consultar entidades con valores null, utilice una expresión vacía "".
null_results = client.query(
collection_name="user_profiles_null",
filter="",
output_fields=["id", "age"]
)
# Example output:
# [{"id": 2, "age": None}, {"id": 3, "age": None}]
QueryResp resp = client.query(QueryReq.builder()
.collectionName("user_profiles_null")
.filter("")
.outputFields(Arrays.asList("id", "age"))
.limit(10)
.build());
System.out.println(resp.getQueryResults());
const results = await client.query(
collection_name: "user_profiles_null",
filter: "",
output_fields: ["id", "age"]
);
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
"collectionName": "user_profiles_null",
"expr": "",
"outputFields": ["id", "age"]
}'
# {"code":0,"cost":0,"data":[{"age":30,"id":1},{"age":null,"id":2},{"age":null,"id":3}]}
Valores por defecto
Los valores por defecto son valores preestablecidos asignados a campos escalares. Si no proporciona un valor para un campo con un valor predeterminado durante la inserción, el sistema utiliza automáticamente el valor predeterminado.
Establecer valores por defecto
Al crear una colección, utilice el parámetro default_value para definir el valor por defecto de un campo. El siguiente ejemplo muestra cómo establecer el valor por defecto de age en 18 y de status en "active".
schema = client.create_schema(
auto_id=False,
enable_dynamic_schema=True,
)
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)
schema.add_field(field_name="vector", datatype=DataType.FLOAT_VECTOR, dim=5)
schema.add_field(field_name="age", datatype=DataType.INT64, default_value=18)
schema.add_field(field_name="status", datatype=DataType.VARCHAR, default_value="active", max_length=10)
index_params = client.prepare_index_params()
index_params.add_index(field_name="vector", index_type="IVF_FLAT", metric_type="L2", params={ "nlist": 128 })
client.create_collection(collection_name="user_profiles_default", schema=schema, index_params=index_params)
import io.milvus.v2.common.DataType;
import io.milvus.v2.common.IndexParam;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import java.util.*;
CreateCollectionReq.CollectionSchema schema = client.createSchema();
schema.setEnableDynamicField(true);
schema.addField(AddFieldReq.builder()
.fieldName("id")
.dataType(DataType.Int64)
.isPrimaryKey(true)
.build());
schema.addField(AddFieldReq.builder()
.fieldName("vector")
.dataType(DataType.FloatVector)
.dimension(5)
.build());
schema.addField(AddFieldReq.builder()
.fieldName("age")
.dataType(DataType.Int64)
.defaultValue(18L)
.build());
schema.addField(AddFieldReq.builder()
.fieldName("status")
.dataType(DataType.VarChar)
.maxLength(10)
.defaultValue("active")
.build());
List<IndexParam> indexes = new ArrayList<>();
Map<String,Object> extraParams = new HashMap<>();
extraParams.put("nlist", 128);
indexes.add(IndexParam.builder()
.fieldName("vector")
.indexType(IndexParam.IndexType.IVF_FLAT)
.metricType(IndexParam.MetricType.L2)
.extraParams(extraParams)
.build());
CreateCollectionReq requestCreate = CreateCollectionReq.builder()
.collectionName("user_profiles_default")
.collectionSchema(schema)
.indexParams(indexes)
.build();
client.createCollection(requestCreate);
import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";
const client = new MilvusClient({
address: "http://localhost:19530",
token: "root:Milvus",
});
await client.createCollection({
collection_name: "user_profiles_default",
schema: [
{
name: "id",
is_primary_key: true,
data_type: DataType.int64,
},
{ name: "vector", data_type: DataType.FloatVector, dim: 5 },
{ name: "age", data_type: DataType.Int64, default_value: 18 },
{ name: 'status', data_type: DataType.VarChar, max_length: 30, default_value: 'active'},
],
index_params: [
{
index_name: "vector_inde",
field_name: "vector",
metric_type: MetricType.L2,
index_type: IndexType.IVF_FLAT,
},
],
});
export pkField='{
"fieldName": "id",
"dataType": "Int64",
"isPrimary": true
}'
export vectorField='{
"fieldName": "vector",
"dataType": "FloatVector",
"elementTypeParams": {
"dim": 5
}
}'
export defaultValueField1='{
"fieldName": "age",
"dataType": "Int64",
"defaultValue": 18
}'
export defaultValueField2='{
"fieldName": "status",
"dataType": "VarChar",
"defaultValue": "active",
"elementTypeParams": {
"max_length": 10
}
}'
export schema="{
\"autoID\": false,
\"fields\": [
$pkField,
$vectorField,
$defaultValueField1,
$defaultValueField2
]
}"
export indexParams='[
{
"fieldName": "vector",
"metricType": "L2",
"indexType": "IVF_FLAT",
"params":{"nlist": 128}
}
]'
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d "{
\"collectionName\": \"user_profiles_default\",
\"schema\": $schema,
\"indexParams\": $indexParams
}"
Insertar entidades
Al insertar datos, si omite campos con un valor por defecto o establece su valor en null, el sistema utiliza el valor por defecto.
data = [
{"id": 1, "vector": [0.1, 0.2, ..., 0.128], "age": 30, "status": "premium"},
{"id": 2, "vector": [0.2, 0.3, ..., 0.129]},
{"id": 3, "vector": [0.3, 0.4, ..., 0.130], "age": 25, "status": None},
{"id": 4, "vector": [0.4, 0.5, ..., 0.131], "age": None, "status": "inactive"}
]
client.insert(collection_name="user_profiles_default", data=data)
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import io.milvus.v2.service.vector.request.InsertReq;
import io.milvus.v2.service.vector.response.InsertResp;
List<JsonObject> rows = new ArrayList<>();
Gson gson = new Gson();
rows.add(gson.fromJson("{\"id\": 1, \"vector\": [0.1, 0.2, 0.3, 0.4, 0.5], \"age\": 30, \"status\": \"premium\"}", JsonObject.class));
rows.add(gson.fromJson("{\"id\": 2, \"vector\": [0.2, 0.3, 0.4, 0.5, 0.6]}", JsonObject.class));
rows.add(gson.fromJson("{\"id\": 3, \"vector\": [0.3, 0.4, 0.5, 0.6, 0.7], \"age\": 25, \"status\": null}", JsonObject.class));
rows.add(gson.fromJson("{\"id\": 4, \"vector\": [0.4, 0.5, 0.6, 0.7, 0.8], \"age\": null, \"status\": \"inactive\"}", JsonObject.class));
InsertResp insertR = client.insert(InsertReq.builder()
.collectionName("user_profiles_default")
.data(rows)
.build());
const data = [
{"id": 1, "vector": [0.1, 0.2, 0.3, 0.4, 0.5], "age": 30, "status": "premium"},
{"id": 2, "vector": [0.2, 0.3, 0.4, 0.5, 0.6]},
{"id": 3, "vector": [0.3, 0.4, 0.5, 0.6, 0.7], "age": 25, "status": null},
{"id": 4, "vector": [0.4, 0.5, 0.6, 0.7, 0.8], "age": null, "status": "inactive"}
];
client.insert({
collection_name: "user_profiles_default",
data: data,
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/insert" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
"data": [
{"id": 1, "vector": [0.1, 0.2, 0.3, 0.4, 0.5], "age": 30, "status": "premium"},
{"id": 2, "vector": [0.2, 0.3, 0.4, 0.5, 0.6]},
{"id": 3, "vector": [0.3, 0.4, 0.5, 0.6, 0.7], "age": 25, "status": null},
{"id": 4, "vector": [0.4, 0.5, 0.6, 0.7, 0.8], "age": null, "status": "inactive"}
],
"collectionName": "user_profiles_default"
}'
Para más información sobre cómo surten efecto los valores nulos y por defecto, consulta Reglas aplicables.
Búsqueda y consulta con valores por defecto
Las entidades que contienen valores por defecto se tratan igual que cualquier otra entidad durante las búsquedas vectoriales y el filtrado escalar. Puede incluir valores por defecto como parte de sus operaciones search y query.
Por ejemplo, en una operación search, las entidades con age establecido en el valor por defecto de 18 se incluirán en los resultados.
res = client.search(
collection_name="user_profiles_default",
data=[[0.1, 0.2, 0.4, 0.3, 0.128]],
search_params={"params": {"nprobe": 16}},
filter="age == 18", # 18 is the default value of the `age` field
limit=10,
output_fields=["id", "age", "status"]
)
print(res)
# Output
# data: ["[{'id': 2, 'distance': 0.28278401494026184, 'entity': {'id': 2, 'age': 18, 'status': 'active'}}, {'id': 4, 'distance': 0.8315839767456055, 'entity': {'id': 4, 'age': 18, 'status': 'inactive'}}]"]
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.response.SearchResp;
Map<String,Object> params = new HashMap<>();
params.put("nprobe", 16);
SearchResp resp = client.search(SearchReq.builder()
.collectionName("user_profiles_default")
.annsField("vector")
.data(Collections.singletonList(new FloatVec(new float[]{0.1f, 0.2f, 0.3f, 0.4f, 0.5f})))
.searchParams(params)
.filter("age == 18")
.topK(10)
.outputFields(Arrays.asList("id", "age", "status"))
.build());
System.out.println(resp.getSearchResults());
// Output
//
// [[SearchResp.SearchResult(entity={id=2, age=18, status=active}, score=0.050000004, id=2), SearchResp.SearchResult(entity={id=4, age=18, status=inactive}, score=0.45000002, id=4)]]
client.search({
collection_name: 'user_profiles_default',
data: [0.3, -0.6, 0.1, 0.3, 0.5],
limit: 2,
output_fields: ['age', 'id', 'status'],
filter: 'age == 18',
params: {
nprobe: 16
}
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
"collectionName": "user_profiles_default",
"data": [
[0.1, 0.2, 0.3, 0.4, 0.5]
],
"annsField": "vector",
"limit": 5,
"filter": "age == 18",
"outputFields": ["id", "age", "status"]
}'
# {"code":0,"cost":0,"data":[{"age":18,"distance":0.050000004,"id":2,"status":"active"},{"age":18,"distance":0.45000002,"id":4,"status":"inactive"}]}
En una operación query, puede hacer coincidir o filtrar por valores predeterminados directamente.
# Query all entities where `age` equals the default value (18)
default_age_results = client.query(
collection_name="user_profiles_default",
filter="age == 18",
output_fields=["id", "age", "status"]
)
# Query all entities where `status` equals the default value ("active")
default_status_results = client.query(
collection_name="user_profiles_default",
filter='status == "active"',
output_fields=["id", "age", "status"]
)
import io.milvus.v2.service.vector.request.QueryReq;
import io.milvus.v2.service.vector.response.QueryResp;
QueryResp ageResp = client.query(QueryReq.builder()
.collectionName("user_profiles_default")
.filter("age == 18")
.outputFields(Arrays.asList("id", "age", "status"))
.build());
System.out.println(ageResp.getQueryResults());
// Output
//
// [QueryResp.QueryResult(entity={id=2, age=18, status=active}), QueryResp.QueryResult(entity={id=4, age=18, status=inactive})]
QueryResp statusResp = client.query(QueryReq.builder()
.collectionName("user_profiles_default")
.filter("status == \"active\"")
.outputFields(Arrays.asList("id", "age", "status"))
.build());
System.out.println(statusResp.getQueryResults());
// Output
//
// [QueryResp.QueryResult(entity={id=2, age=18, status=active}), QueryResp.QueryResult(entity={id=3, age=25, status=active})]
// Query all entities where `age` equals the default value (18)
const default_age_results = await client.query(
collection_name: "user_profiles_default",
filter: "age == 18",
output_fields: ["id", "age", "status"]
);
// Query all entities where `status` equals the default value ("active")
const default_status_results = await client.query(
collection_name: "user_profiles_default",
filter: 'status == "active"',
output_fields: ["id", "age", "status"]
)
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
"collectionName": "user_profiles_default",
"filter": "age == 18",
"outputFields": ["id", "age", "status"]
}'
# {"code":0,"cost":0,"data":[{"age":18,"id":2,"status":"active"},{"age":18,"id":4,"status":"inactive"}]}
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
"collectionName": "user_profiles_default",
"filter": "status == \"active\"",
"outputFields": ["id", "age", "status"]
}'
# {"code":0,"cost":0,"data":[{"age":18,"id":2,"status":"active"},{"age":25,"id":3,"status":"active"}]}
Reglas aplicables
La siguiente tabla resume el comportamiento de las columnas anulables y los valores por defecto bajo diferentes combinaciones de configuración. Estas reglas determinan cómo Milvus maneja los datos cuando se intentan insertar valores nulos o si no se proporcionan valores de campo.
| Anulable | Valor por defecto | Tipo de valor por defecto | Entrada del usuario | Resultado | Ejemplo |
|---|---|---|---|---|---|
| ✅ | ✅ | No nulo | Ninguno/nulo | Utiliza el valor por defecto |
|
| ✅ | ❌ | - | Ninguno/nulo | Almacenado como null |
|
| ❌ | ✅ | No nulo | Ninguno/nulo | Utiliza el valor por defecto |
|
| ❌ | ❌ | - | Ninguno/nulo | Lanza un error |
|
| ❌ | ✅ | Nulo | Ninguno/nulo | Lanza un error |
|
