VarChar フィールド
Zilliz Cloud クラスターでは、テキスト形式のスカラーデータを VARCHAR および TEXT フィールドで保存できます。本ページでは、名前、タグ、カテゴリ、外部 ID などの短く上限が定められた文字列メタデータ向けに設計された VARCHAR について説明します。
エンティティとともに保存および返却する必要がある、より長いソーステキスト、ドキュメントの一節、記事本文、チケット、ログなどには、代わりに TEXT フィールドを使用します。詳細は、TEXT フィールド を参照してください。
VARCHAR フィールドを定義する際には、2 つのパラメーターが必須です。
-
datatypeをDataType.VARCHARに設定します。 -
max_lengthを指定します。これは、VARCHARフィールドが保存できる最大バイト数を定義します。max_lengthの有効範囲は 1~65,535 です。
Zilliz Cloud は、VARCHAR フィールドの null 値とデフォルト値をサポートしています。これらの機能を有効にするには、nullable を True に、default_value を文字列値に設定します。詳細は、Null 許容とデフォルト を参照してください。
VARCHAR フィールドを追加する
Zilliz Cloud クラスターで短く上限が定められた文字列メタデータを保存するには、コレクションスキーマで VARCHAR フィールドを定義します。以下は、2 つの VARCHAR フィールドを持つコレクションスキーマを定義する例です。
-
varchar_field1: 最大 100 バイトを保存し、null 値を許容し、デフォルト値は"Unknown"です。 -
varchar_field2: 最大 200 バイトを保存し、null 値を許容しますが、デフォルト値はありません。
スキーマを定義する際に enable_dynamic_field=True を設定すると、Zilliz Cloud では事前に定義されていないスカラーフィールドを挿入できます。ただし、これによりクエリと管理が複雑になり、パフォーマンスに影響する可能性があります。詳細は、動的フィールド を参照してください。
- Python
- Java
- Go
- Rust
- C++
- NodeJS
- cURL
# Import necessary libraries
from pymilvus import MilvusClient, DataType
# Define server address
SERVER_ADDR = "YOUR_CLUSTER_ENDPOINT"
# Create a MilvusClient instance
client = MilvusClient(uri=SERVER_ADDR)
# Define the collection schema
schema = client.create_schema(
auto_id=False,
enable_dynamic_field=True,
)
# Add `varchar_field1` that supports null values with default value "Unknown"
schema.add_field(field_name="varchar_field1", datatype=DataType.VARCHAR, max_length=100, nullable=True, default_value="Unknown")
# Add `varchar_field2` that supports null values without default value
schema.add_field(field_name="varchar_field2", datatype=DataType.VARCHAR, max_length=200, nullable=True)
schema.add_field(field_name="pk", datatype=DataType.INT64, is_primary=True)
schema.add_field(field_name="embedding", datatype=DataType.FLOAT_VECTOR, dim=3)
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
.uri("YOUR_CLUSTER_ENDPOINT")
.build());
CreateCollectionReq.CollectionSchema schema = client.createSchema();
schema.setEnableDynamicField(true);
schema.addField(AddFieldReq.builder()
.fieldName("varchar_field1")
.dataType(DataType.VarChar)
.maxLength(100)
.isNullable(true)
.defaultValue("Unknown")
.build());
schema.addField(AddFieldReq.builder()
.fieldName("varchar_field2")
.dataType(DataType.VarChar)
.maxLength(200)
.isNullable(true)
.build());
schema.addField(AddFieldReq.builder()
.fieldName("pk")
.dataType(DataType.Int64)
.isPrimaryKey(true)
.build());
schema.addField(AddFieldReq.builder()
.fieldName("embedding")
.dataType(DataType.FloatVector)
.dimension(3)
.build());
import (
"context"
"fmt"
"github.com/milvus-io/milvus/client/v3/column"
"github.com/milvus-io/milvus/client/v3/entity"
"github.com/milvus-io/milvus/client/v3/index"
"github.com/milvus-io/milvus/client/v3/milvusclient"
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
milvusAddr := "YOUR_CLUSTER_ENDPOINT"
client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
Address: milvusAddr,
})
if err != nil {
fmt.Println(err.Error())
// handle error
}
defer client.Close(ctx)
schema := entity.NewSchema()
schema.WithField(entity.NewField().
WithName("pk").
WithDataType(entity.FieldTypeInt64).
WithIsPrimaryKey(true),
).WithField(entity.NewField().
WithName("embedding").
WithDataType(entity.FieldTypeFloatVector).
WithDim(3),
).WithField(entity.NewField().
WithName("varchar_field1").
WithDataType(entity.FieldTypeVarChar).
WithMaxLength(100).
WithNullable(true).
WithDefaultValueString("Unknown"),
).WithField(entity.NewField().
WithName("varchar_field2").
WithDataType(entity.FieldTypeVarChar).
WithMaxLength(200).
WithNullable(true),
)
use milvus::v2::prelude::*;
#[tokio::main]
async fn main() -> Result<()> {
let client = ClientV2::new(
&ConnectConfig::new()
.uri("YOUR_CLUSTER_ENDPOINT")
.token("YOUR_CLUSTER_TOKEN"),
)
.await?;
let schema = CollectionSchema::new()
.add_field(
FieldSchema::new()
.name("varchar_field1")
.data_type(DataType::VarChar)
.max_length(100)
.nullable(true)
.default_value(DefaultValue::String("Unknown".to_string())),
)
.add_field(
FieldSchema::new()
.name("varchar_field2")
.data_type(DataType::VarChar)
.max_length(200)
.nullable(true),
)
.add_field(
FieldSchema::new()
.name("pk")
.data_type(DataType::Int64)
.primary_key(true),
)
.add_field(
FieldSchema::new()
.name("embedding")
.data_type(DataType::FloatVector)
.dimension(3),
);
Ok(())
}
#include <iostream>
#include <memory>
#include "milvus/MilvusClientV2.h"
auto client = milvus::MilvusClientV2::Create();
milvus::ConnectParam connect_param{"YOUR_CLUSTER_ENDPOINT"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
std::cout << status.Message() << std::endl;
}
milvus::CollectionSchemaPtr schema = std::make_shared<milvus::CollectionSchema>();
schema->AddField({"pk", milvus::DataType::INT64, "", true, false});
schema->AddField(milvus::FieldSchema("embedding", milvus::DataType::FLOAT_VECTOR).WithDimension(3));
schema->AddField(milvus::FieldSchema("varchar_field1", milvus::DataType::VARCHAR).WithMaxLength(100).WithNullable(true).WithDefaultValue("Unknown"));
schema->AddField(milvus::FieldSchema("varchar_field2", milvus::DataType::VARCHAR).WithMaxLength(200).WithNullable(true));
import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";
const client = new MilvusClient({
address: `YOUR_CLUSTER_ENDPOINT`
});
const schema = [
{
name: "varchar_field1",
data_type: DataType.VarChar,
max_length: 100,
nullable: true,
default_value: "Unknown",
},
{
name: "varchar_field2",
data_type: DataType.VarChar,
max_length: 200,
nullable: true,
},
{
name: "pk",
data_type: DataType.Int64,
is_primary_key: true,
},
{
name: "embedding",
data_type: DataType.FloatVector,
dim: 3,
},
];
export varcharField1='{
"fieldName": "varchar_field1",
"dataType": "VarChar",
"elementTypeParams": {
"max_length": 100
},
"nullable": true,
"defaultValue": "Unknown"
}'
export varcharField2='{
"fieldName": "varchar_field2",
"dataType": "VarChar",
"elementTypeParams": {
"max_length": 200
},
"nullable": true
}'
export primaryField='{
"fieldName": "pk",
"dataType": "Int64",
"isPrimary": true
}'
export vectorField='{
"fieldName": "embedding",
"dataType": "FloatVector",
"elementTypeParams": {
"dim": 3
}
}'
export schema="{
\"autoID\": false,
\"fields\": [
$varcharField1,
$varcharField2,
$primaryField,
$vectorField
]
}"
インデックスパラメーターを設定する
インデックス作成は、検索とクエリのパフォーマンス向上に役立ちます。Zilliz Cloud クラスターでは、インデックス作成はベクトルフィールドでは必須ですが、スカラーフィールドでは任意です。
次の例では、ベクトルフィールド embedding とスカラーフィールド varchar_field1 にインデックスを作成します。どちらも AUTOINDEX インデックスタイプを使用します。このタイプでは、Milvus がデータタイプに基づいて最適なインデックスを自動的に選択します。
- Python
- Java
- Go
- Rust
- C++
- NodeJS
- cURL
# Set index params
index_params = client.prepare_index_params()
# Index `varchar_field1` with AUTOINDEX
index_params.add_index(
field_name="varchar_field1",
index_type="AUTOINDEX",
index_name="varchar_index"
)
# Index `embedding` with AUTOINDEX and specify metric_type
index_params.add_index(
field_name="embedding",
index_type="AUTOINDEX", # Use automatic indexing to simplify complex index settings
metric_type="COSINE" # Specify similarity metric type, options include L2, COSINE, or IP
)
import io.milvus.v2.common.IndexParam;
import java.util.*;
List<IndexParam> indexes = new ArrayList<>();
indexes.add(IndexParam.builder()
.fieldName("varchar_field1")
.indexName("varchar_index")
.indexType(IndexParam.IndexType.AUTOINDEX)
.build());
indexes.add(IndexParam.builder()
.fieldName("embedding")
.indexType(IndexParam.IndexType.AUTOINDEX)
.metricType(IndexParam.MetricType.COSINE)
.build());
indexOption1 := milvusclient.NewCreateIndexOption("my_collection", "embedding",
index.NewAutoIndex(index.MetricType(entity.COSINE)))
indexOption2 := milvusclient.NewCreateIndexOption("my_collection", "varchar_field1",
index.NewInvertedIndex())
let indexes = vec![
IndexParam::new()
.field_name("varchar_field1")
.index_name("varchar_index")
.index_type(IndexType::AutoIndex),
IndexParam::new()
.field_name("embedding")
.index_type(IndexType::AutoIndex)
.metric_type(MetricType::Cosine),
];
std::vector<milvus::IndexDesc> indexes = {
milvus::IndexDesc("varchar_field1", "varchar_index", milvus::IndexType::AUTOINDEX),
milvus::IndexDesc("embedding", "", milvus::IndexType::AUTOINDEX, milvus::MetricType::COSINE)
};
import { IndexType, MetricType } from "@zilliz/milvus2-sdk-node";
const indexParams = [{
index_name: 'varchar_index',
field_name: 'varchar_field1',
index_type: IndexType.AUTOINDEX,
}];
indexParams.push({
field_name: 'embedding',
metric_type: MetricType.COSINE,
index_type: IndexType.AUTOINDEX,
});
export indexParams='[
{
"fieldName": "varchar_field1",
"indexName": "varchar_index",
"indexType": "AUTOINDEX"
},
{
"fieldName": "embedding",
"metricType": "COSINE",
"indexType": "AUTOINDEX"
}
]'
コレクションを作成する
スキーマとインデックスを定義したら、文字列フィールドを含むコレクションを作成します。
- Python
- Java
- Go
- Rust
- C++
- NodeJS
- cURL
# Create Collection
client.create_collection(
collection_name="my_collection",
schema=schema,
index_params=index_params
)
CreateCollectionReq requestCreate = CreateCollectionReq.builder()
.collectionName("my_collection")
.collectionSchema(schema)
.indexParams(indexes)
.build();
client.createCollection(requestCreate);
err = client.CreateCollection(ctx,
milvusclient.NewCreateCollectionOption("my_collection", schema).
WithIndexOptions(indexOption1, indexOption2))
if err != nil {
fmt.Println(err.Error())
// handle error
}
_, err = client.LoadCollection(ctx, milvusclient.NewLoadCollectionOption("my_collection"))
if err != nil {
fmt.Println(err.Error())
// handle error
}
client
.create_collection(
CreateCollectionRequest::builder()
.collection_name("my_collection")
.schema(schema)
.index_params(indexes)
.build()?,
)
.await?;
auto status = client->CreateCollection(milvus::CreateCollectionRequest()
.WithCollectionName("my_collection")
.WithIndexes(std::move(indexes))
.WithCollectionSchema(schema));
if (!status.IsOk()) {
std::cout << status.Message() << std::endl;
}
await client.createCollection({
collection_name: "my_collection",
schema: schema,
index_params: indexParams
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d "{
\"collectionName\": \"my_collection\",
\"schema\": $schema,
\"indexParams\": $indexParams
}"
## {"code":0,"data":{}}
データを挿入する
コレクションを作成したら、スキーマに一致するエンティティを挿入します。
- Python
- Java
- Go
- Rust
- C++
- NodeJS
- cURL
# Sample data
data = [
{"varchar_field1": "Product A", "varchar_field2": "High quality product", "pk": 1, "embedding": [0.1, 0.2, 0.3]},
{"varchar_field1": "Product B", "pk": 2, "embedding": [0.4, 0.5, 0.6]}, # varchar_field2 field is missing, which should be NULL
{"varchar_field1": None, "varchar_field2": None, "pk": 3, "embedding": [0.2, 0.3, 0.1]}, # `varchar_field1` should default to `Unknown`, `varchar_field2` is NULL
{"varchar_field1": "Product C", "varchar_field2": None, "pk": 4, "embedding": [0.5, 0.7, 0.2]}, # `varchar_field2` is NULL
{"varchar_field1": None, "varchar_field2": "Exclusive deal", "pk": 5, "embedding": [0.6, 0.4, 0.8]}, # `varchar_field1` should default to `Unknown`
{"varchar_field1": "Unknown", "varchar_field2": None, "pk": 6, "embedding": [0.8, 0.5, 0.3]}, # `varchar_field2` is NULL
{"varchar_field1": "", "varchar_field2": "Best seller", "pk": 7, "embedding": [0.8, 0.5, 0.3]}, # Empty string is not treated as NULL
]
# Insert data
client.insert(
collection_name="my_collection",
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("{\"varchar_field1\": \"Product A\", \"varchar_field2\": \"High quality product\", \"pk\": 1, \"embedding\": [0.1, 0.2, 0.3]}", JsonObject.class));
rows.add(gson.fromJson("{\"varchar_field1\": \"Product B\", \"pk\": 2, \"embedding\": [0.4, 0.5, 0.6]}", JsonObject.class));
rows.add(gson.fromJson("{\"varchar_field1\": null, \"varchar_field2\": null, \"pk\": 3, \"embedding\": [0.2, 0.3, 0.1]}", JsonObject.class));
rows.add(gson.fromJson("{\"varchar_field1\": \"Product C\", \"varchar_field2\": null, \"pk\": 4, \"embedding\": [0.5, 0.7, 0.2]}", JsonObject.class));
rows.add(gson.fromJson("{\"varchar_field1\": null, \"varchar_field2\": \"Exclusive deal\", \"pk\": 5, \"embedding\": [0.6, 0.4, 0.8]}", JsonObject.class));
rows.add(gson.fromJson("{\"varchar_field1\": \"Unknown\", \"varchar_field2\": null, \"pk\": 6, \"embedding\": [0.8, 0.5, 0.3]}", JsonObject.class));
rows.add(gson.fromJson("{\"varchar_field1\": \"\", \"varchar_field2\": \"Best seller\", \"pk\": 7, \"embedding\": [0.8, 0.5, 0.3]}", JsonObject.class));
InsertResp insertR = client.insert(InsertReq.builder()
.collectionName("my_collection")
.data(rows)
.build());
column1, _ := column.NewNullableColumnVarChar("varchar_field1",
[]string{"Product A", "Product B", "Product C", "Unknown", ""},
[]bool{true, true, false, true, false, true, true})
column2, _ := column.NewNullableColumnVarChar("varchar_field2",
[]string{"High quality product", "Exclusive deal", "Best seller"},
[]bool{true, false, false, false, true, false, true})
_, err = client.Insert(ctx, milvusclient.NewColumnBasedInsertOption("my_collection").
WithInt64Column("pk", []int64{1, 2, 3, 4, 5, 6, 7}).
WithFloatVectorColumn("embedding", 3, [][]float32{
{0.1, 0.2, 0.3},
{0.4, 0.5, 0.6},
{0.2, 0.3, 0.1},
{0.5, 0.7, 0.2},
{0.6, 0.4, 0.8},
{0.8, 0.5, 0.3},
{0.8, 0.5, 0.3},
}).
WithColumns(column1, column2),
)
if err != nil {
fmt.Println(err.Error())
// handle err
}
client
.insert(
InsertRequest::builder()
.collection_name("my_collection")
.columns(vec![
FieldData::nullable(
FieldData::varchar(
"varchar_field1",
vec![
"Product A".to_string(),
"Product B".to_string(),
"Product C".to_string(),
"Unknown".to_string(),
"".to_string(),
],
),
vec![true, true, false, true, false, true, true],
)?,
FieldData::nullable(
FieldData::varchar(
"varchar_field2",
vec![
"High quality product".to_string(),
"Exclusive deal".to_string(),
"Best seller".to_string(),
],
),
vec![true, false, false, false, true, false, true],
)?,
FieldData::int64("pk", vec![1, 2, 3, 4, 5, 6, 7]),
FieldData::float_vector(
"embedding",
vec![
vec![0.1, 0.2, 0.3],
vec![0.4, 0.5, 0.6],
vec![0.2, 0.3, 0.1],
vec![0.5, 0.7, 0.2],
vec![0.6, 0.4, 0.8],
vec![0.8, 0.5, 0.3],
vec![0.8, 0.5, 0.3],
],
),
])
.build()?,
)
.await?;
milvus::EntityRows data = {{{"varchar_field1", "Product A"}, {"varchar_field2", "High quality product"}, {"pk", 1}, {"embedding", std::vector<float>{0.1, 0.2, 0.3}}},
{{"varchar_field1", "Product B"}, {"pk", 2}, {"embedding", std::vector<float>{0.4, 0.5, 0.6}}},
{{"varchar_field1", nullptr}, {"varchar_field2", nullptr}, {"pk", 3}, {"embedding", std::vector<float>{0.2, 0.3, 0.1}}},
{{"varchar_field1", "Product C"}, {"varchar_field2", nullptr}, {"pk", 4}, {"embedding", std::vector<float>{0.5, 0.7, 0.2}}},
{{"varchar_field1", nullptr}, {"varchar_field2", "Exclusive deal"}, {"pk", 5}, {"embedding", std::vector<float>{0.5, 0.4, 0.8}}},
{{"varchar_field1", "Unknown"}, {"varchar_field2", nullptr}, {"pk", 6}, {"embedding", std::vector<float>{0.8, 0.5, 0.3}}},
{{"varchar_field1", ""}, {"varchar_field2", "Best seller"}, {"pk", 7}, {"embedding", std::vector<float>{0.8, 0.5, 0.3}}}};
milvus::InsertResponse response;
auto status = client->Insert(milvus::InsertRequest()
.WithCollectionName("my_collection")
.WithRowsData(std::move(data)),
response);
if (!status.IsOk()) {
std::cout << status.Message() << std::endl;
}
const data = [
{
varchar_field1: "Product A",
varchar_field2: "High quality product",
pk: 1,
embedding: [0.1, 0.2, 0.3],
},
{
varchar_field1: "Product B",
pk: 2,
embedding: [0.4, 0.5, 0.6],
},
{
varchar_field1: null,
varchar_field2: null,
pk: 3,
embedding: [0.2, 0.3, 0.1],
},
{
varchar_field1: "Product C",
varchar_field2: null,
pk: 4,
embedding: [0.5, 0.7, 0.2],
},
{
varchar_field1: null,
varchar_field2: "Exclusive deal",
pk: 5,
embedding: [0.6, 0.4, 0.8],
},
{
varchar_field1: "Unknown",
varchar_field2: null,
pk: 6,
embedding: [0.8, 0.5, 0.3],
},
{
varchar_field1: "",
varchar_field2: "Best seller",
pk: 7,
embedding: [0.8, 0.5, 0.3],
},
];
await client.insert({
collection_name: "my_collection",
data: data,
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/insert" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
--data '{
"data": [
{"varchar_field1": "Product A", "varchar_field2": "High quality product", "pk": 1, "embedding": [0.1, 0.2, 0.3]},
{"varchar_field1": "Product B", "pk": 2, "embedding": [0.4, 0.5, 0.6]},
{"varchar_field1": null, "varchar_field2": null, "pk": 3, "embedding": [0.2, 0.3, 0.1]},
{"varchar_field1": "Product C", "varchar_field2": null, "pk": 4, "embedding": [0.5, 0.7, 0.2]},
{"varchar_field1": null, "varchar_field2": "Exclusive deal", "pk": 5, "embedding": [0.6, 0.4, 0.8]},
{"varchar_field1": "Unknown", "varchar_field2": null, "pk": 6, "embedding": [0.8, 0.5, 0.3]},
{"varchar_field1": "", "varchar_field2": "Best seller", "pk": 7, "embedding": [0.8, 0.5, 0.3]}
],
"collectionName": "my_collection"
}'
## {"code":0,"cost":0,"data":{"insertCount":7,"insertIds":[1,2,3,4,5,6,7]}}
フィルター式を使用したクエリ
エンティティを挿入したら、query メソッドを使用して、指定したフィルター式に一致するエンティティを取得します。
varchar_field1 が文字列 "Product A" に一致するエンティティを取得するには、以下のとおりです。
- Python
- Java
- Go
- Rust
- C++
- NodeJS
- cURL
# Filter `varchar_field1` with value "Product A"
filter = 'varchar_field1 == "Product A"'
res = client.query(
collection_name="my_collection",
filter=filter,
output_fields=["varchar_field1", "varchar_field2"]
)
print(res)
# Example output:
# data: [
# "{'varchar_field1': 'Product A', 'varchar_field2': 'High quality product', 'pk': 1}"
# ]
import io.milvus.v2.service.vector.request.QueryReq;
import io.milvus.v2.service.vector.response.QueryResp;
String filter = "varchar_field1 == \"Product A\"";
QueryResp resp = client.query(QueryReq.builder()
.collectionName("my_collection")
.filter(filter)
.outputFields(Arrays.asList("varchar_field1", "varchar_field2"))
.build());
System.out.println(resp.getQueryResults());
// Output
//
// [QueryResp.QueryResult(entity={varchar_field1=Product A, varchar_field2=High quality product, pk=1})]
filter := "varchar_field1 == \"Product A\""
queryResult, err := client.Query(ctx, milvusclient.NewQueryOption("my_collection").
WithFilter(filter).
WithOutputFields("varchar_field1", "varchar_field2"))
if err != nil {
fmt.Println(err.Error())
// handle error
}
fmt.Println("varchar_field1", queryResult.GetColumn("varchar_field1").FieldData().GetScalars())
fmt.Println("varchar_field2", queryResult.GetColumn("varchar_field2").FieldData().GetScalars())
// Output
//
// varchar_field1 string_data:{data:"Product A"}
// varchar_field2 string_data:{data:"High quality product"}
let res = client
.query(
QueryRequest::builder()
.collection_name("my_collection")
.filter(r#"varchar_field1 == "Product A""#)
.output_fields(["varchar_field1", "varchar_field2"])
.build()?,
)
.await?;
println!("{:?}", res.results());
auto request = milvus::QueryRequest()
.WithCollectionName("my_collection")
.WithFilter(R"(varchar_field1 == "Product A")")
.AddOutputField("varchar_field1")
.AddOutputField("varchar_field2");
milvus::QueryResponse response;
auto status = client->Query(request, response);
if (!status.IsOk()) {
std::cout << status.Message() << std::endl;
}
milvus::EntityRows output_rows;
status = response.Results().OutputRows(output_rows);
for (const auto& row : output_rows) {
std::cout << "\t" << row << std::endl;
}
await client.query({
collection_name: 'my_collection',
filter: 'varchar_field1 == "Product A"',
output_fields: ['varchar_field1', 'varchar_field2']
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
"collectionName": "my_collection",
"filter": "varchar_field1 == \"Product A\"",
"outputFields": ["varchar_field1", "varchar_field2"]
}'
## {"code":0,"cost":0,"data":[{"pk":1,"varchar_field1":"Product A","varchar_field2":"High quality product"}]}
varchar_field2 が null であるエンティティを取得するには、以下のとおりです。
- Python
- Java
- Go
- Rust
- C++
- NodeJS
- cURL
# Filter entities where `varchar_field2` is null
filter = 'varchar_field2 is null'
res = client.query(
collection_name="my_collection",
filter=filter,
output_fields=["varchar_field1", "varchar_field2"]
)
print(res)
# Example output:
# data: [
# "{'varchar_field1': 'Product B', 'varchar_field2': None, 'pk': 2}",
# "{'varchar_field1': 'Unknown', 'varchar_field2': None, 'pk': 3}",
# "{'varchar_field1': 'Product C', 'varchar_field2': None, 'pk': 4}",
# "{'varchar_field1': 'Unknown', 'varchar_field2': None, 'pk': 6}"
# ]
String filter = "varchar_field2 is null";
QueryResp resp = client.query(QueryReq.builder()
.collectionName("my_collection")
.filter(filter)
.outputFields(Arrays.asList("varchar_field1", "varchar_field2"))
.build());
System.out.println(resp.getQueryResults());
// Output
//
// [
// QueryResp.QueryResult(entity={varchar_field1=Product B, varchar_field2=null, pk=2}),
// QueryResp.QueryResult(entity={varchar_field1=Unknown, varchar_field2=null, pk=3}),
// QueryResp.QueryResult(entity={varchar_field1=Product C, varchar_field2=null, pk=4}),
// QueryResp.QueryResult(entity={varchar_field1=Unknown, varchar_field2=null, pk=6})
// ]
filter = "varchar_field2 is null"
queryResult, err = client.Query(ctx, milvusclient.NewQueryOption("my_collection").
WithFilter(filter).
WithOutputFields("varchar_field1", "varchar_field2"))
if err != nil {
fmt.Println(err.Error())
// handle error
}
fmt.Println("varchar_field1", queryResult.GetColumn("varchar_field1"))
fmt.Println("varchar_field2", queryResult.GetColumn("varchar_field2"))
let res = client
.query(
QueryRequest::builder()
.collection_name("my_collection")
.filter("varchar_field2 is null")
.output_fields(["varchar_field1", "varchar_field2"])
.build()?,
)
.await?;
println!("{:?}", res.results());
auto request = milvus::QueryRequest()
.WithCollectionName("my_collection")
.WithFilter("varchar_field2 IS NULL")
.AddOutputField("varchar_field1")
.AddOutputField("varchar_field2");
milvus::QueryResponse response;
auto status = client->Query(request, response);
if (!status.IsOk()) {
std::cout << status.Message() << std::endl;
}
milvus::EntityRows output_rows;
status = response.Results().OutputRows(output_rows);
for (const auto& row : output_rows) {
std::cout << "\t" << row << std::endl;
}
await client.query({
collection_name: 'my_collection',
filter: 'varchar_field2 is null',
output_fields: ['varchar_field1', 'varchar_field2']
});
# restful
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
"collectionName": "my_collection",
"filter": "varchar_field2 is null",
"outputFields": ["varchar_field1", "varchar_field2"]
}'
varchar_field1 の値が "Unknown" であるエンティティを取得するには、以下の式を使用します。varchar_field1 のデフォルト値は "Unknown" であるため、期待される結果には、varchar_field1 が明示的に "Unknown" に設定されたエンティティ、または varchar_field1 が null に設定されたエンティティが含まれます。
- Python
- Java
- Go
- Rust
- C++
- NodeJS
- cURL
# Filter entities with `varchar_field1` with value `Unknown`
filter = 'varchar_field1 == "Unknown"'
res = client.query(
collection_name="my_collection",
filter=filter,
output_fields=["varchar_field1", "varchar_field2"]
)
print(res)
# Example output:
# data: [
# "{'varchar_field1': 'Unknown', 'varchar_field2': None, 'pk': 3}",
# "{'varchar_field1': 'Unknown', 'varchar_field2': 'Exclusive deal', 'pk': 5}",
# "{'varchar_field1': 'Unknown', 'varchar_field2': None, 'pk': 6}"
# ]
String filter = "varchar_field1 == \"Unknown\"";
QueryResp resp = client.query(QueryReq.builder()
.collectionName("my_collection")
.filter(filter)
.outputFields(Arrays.asList("varchar_field1", "varchar_field2"))
.build());
System.out.println(resp.getQueryResults());
// Output
//
// [
// QueryResp.QueryResult(entity={varchar_field1=Unknown, varchar_field2=null, pk=3}),
// QueryResp.QueryResult(entity={varchar_field1=Unknown, varchar_field2=Exclusive deal, pk=5}),
// QueryResp.QueryResult(entity={varchar_field1=Unknown, varchar_field2=null, pk=6})
// ]
filter = "varchar_field1 == \"Unknown\""
queryResult, err = client.Query(ctx, milvusclient.NewQueryOption("my_collection").
WithFilter(filter).
WithOutputFields("varchar_field1", "varchar_field2"))
if err != nil {
fmt.Println(err.Error())
// handle error
}
fmt.Println("varchar_field1", queryResult.GetColumn("varchar_field1"))
fmt.Println("varchar_field2", queryResult.GetColumn("varchar_field2"))
let res = client
.query(
QueryRequest::builder()
.collection_name("my_collection")
.filter(r#"varchar_field1 == "Unknown""#)
.output_fields(["varchar_field1", "varchar_field2"])
.build()?,
)
.await?;
println!("{:?}", res.results());
auto request = milvus::QueryRequest()
.WithCollectionName("my_collection")
.WithFilter(R"(varchar_field1 == "Unknown")")
.AddOutputField("varchar_field1")
.AddOutputField("varchar_field2");
milvus::QueryResponse response;
auto status = client->Query(request, response);
if (!status.IsOk()) {
std::cout << status.Message() << std::endl;
}
milvus::EntityRows output_rows;
status = response.Results().OutputRows(output_rows);
for (const auto& row : output_rows) {
std::cout << "\t" << row << std::endl;
}
// node
await client.query({
collection_name: 'my_collection',
filter: 'varchar_field1 == "Unknown"',
output_fields: ['varchar_field1', 'varchar_field2']
});
# restful
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
"collectionName": "my_collection",
"filter": "varchar_field1 == \"Unknown\"",
"outputFields": ["varchar_field1", "varchar_field2"]
}'
フィルター式を使用したベクトル検索
基本的なスカラーフィールドのフィルタリングに加えて、ベクトル類似検索とスカラーフィールドフィルターを組み合わせることができます。たとえば、次のコードは、ベクトル検索にスカラーフィールドフィルターを追加する方法を示しています。
- Python
- Java
- Go
- Rust
- C++
- NodeJS
- cURL
# Search with string filtering
# Filter `varchar_field2` with value "Best seller"
filter = 'varchar_field2 == "Best seller"'
res = client.search(
collection_name="my_collection",
data=[[0.3, -0.6, 0.1]],
limit=5,
search_params={"params": {"nprobe": 10}},
output_fields=["varchar_field1", "varchar_field2"],
filter=filter
)
print(res)
# Example output:
# data: [
# "[{'id': 7, 'distance': -0.04468163847923279, 'entity': {'varchar_field1': '', 'varchar_field2': 'Best seller'}}]"
# ]
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;
String filter = "varchar_field2 == \"Best seller\"";
SearchResp resp = client.search(SearchReq.builder()
.collectionName("my_collection")
.annsField("embedding")
.data(Collections.singletonList(new FloatVec(new float[]{0.3f, -0.6f, 0.1f})))
.topK(5)
.outputFields(Arrays.asList("varchar_field1", "varchar_field2"))
.filter(filter)
.build());
System.out.println(resp.getSearchResults());
// Output
//
// [[SearchResp.SearchResult(entity={varchar_field1=, varchar_field2=Best seller}, score=-0.04468164, id=7)]]
queryVector := []float32{0.3, -0.6, 0.1}
filter = "varchar_field2 == \"Best seller\""
annParam := index.NewCustomAnnParam()
annParam.WithExtraParam("nprobe", 10)
resultSets, err := client.Search(ctx, milvusclient.NewSearchOption(
"my_collection", // collectionName
5, // limit
[]entity.Vector{entity.FloatVector(queryVector)},
).WithANNSField("embedding").
WithFilter(filter).
WithAnnParam(annParam).
WithOutputFields("varchar_field1", "varchar_field2"))
if err != nil {
fmt.Println(err.Error())
// handle error
}
for _, resultSet := range resultSets {
fmt.Println("IDs: ", resultSet.IDs.FieldData().GetScalars())
fmt.Println("Scores: ", resultSet.Scores)
fmt.Println("varchar_field1: ", resultSet.GetColumn("varchar_field1"))
fmt.Println("varchar_field2: ", resultSet.GetColumn("varchar_field2"))
}
let res = client
.search(
SearchRequest::builder()
.collection_name("my_collection")
.vector_field("embedding")
.vectors(SearchVectors::Float(vec![vec![0.3, -0.6, 0.1]]))
.filter(r#"varchar_field2 == "Best seller""#)
.output_fields(["varchar_field1", "varchar_field2"])
.limit(5)
.build()?,
)
.await?;
println!("{:?}", res.results());
std::vector<float> query_vector = {0.3, -0.6, 0.1};
auto request = milvus::SearchRequest()
.WithCollectionName("my_collection")
.WithAnnsField("embedding")
.WithFilter(R"(varchar_field2 == "Best seller")")
.WithLimit(5)
.AddExtraParam("nprobe", "10")
.AddOutputField("varchar_field1")
.AddOutputField("varchar_field2")
.AddFloatVector(query_vector);
milvus::SearchResponse response;
auto status = client->Search(request, response);
if (!status.IsOk()) {
std::cout << status.Message() << std::endl;
}
auto search_results = response.Results();
for (auto& result : search_results.Results()) {
milvus::EntityRows output_rows;
status = result.OutputRows(output_rows);
for (const auto& row : output_rows) {
std::cout << "\t" << row << std::endl;
}
}
await client.search({
collection_name: 'my_collection',
data: [0.3, -0.6, 0.1],
limit: 5,
output_fields: ['varchar_field1', 'varchar_field2'],
filter: 'varchar_field2 == "Best seller"',
params: {
nprobe: 10
}
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
"collectionName": "my_collection",
"data": [
[0.3, -0.6, 0.1]
],
"limit": 5,
"searchParams":{
"params":{"nprobe":10}
},
"outputFields": ["varchar_field1", "varchar_field2"],
"filter": "varchar_field2 == \"Best seller\""
}'
## {"code":0,"cost":0,"data":[{"distance":-0.044681635,"pk":7,"varchar_field1":"","varchar_field2":"Best seller"}]}