milvus-logo
LFAI
홈페이지
  • 사용자 가이드

가져오기 및 스칼라 쿼리

이 가이드에서는 ID로 엔티티를 가져오고 스칼라 필터링을 수행하는 방법을 설명합니다. 스칼라 필터링은 지정된 필터링 조건과 일치하는 엔티티를 검색합니다.

개요

스칼라 쿼리는 부울 표현식을 사용하여 정의된 조건에 따라 컬렉션의 엔티티를 필터링합니다. 쿼리 결과는 정의된 조건과 일치하는 엔티티의 집합입니다. 컬렉션에서 주어진 벡터에 가장 가까운 벡터를 식별하는 벡터 검색과 달리, 쿼리는 특정 기준에 따라 엔티티를 필터링합니다.

Milvus에서 필터는 항상 연산자로 결합된 필드 이름으로 구성된 문자열입니다. 이 가이드에서는 다양한 필터 예제를 찾을 수 있습니다. 연산자 세부 사항에 대해 자세히 알아보려면 참조 섹션으로 이동하세요.

준비

다음 단계에서는 Milvus에 연결하고, 컬렉션을 빠르게 설정하고, 무작위로 생성된 1,000개 이상의 엔티티를 컬렉션에 삽입하기 위해 코드의 용도를 변경합니다.

1단계: 컬렉션 만들기

를 사용하여 MilvusClient 을 사용하여 Milvus 서버에 연결하고 create_collection() 를 사용하여 컬렉션을 만듭니다.

를 사용하여 MilvusClientV2 을 사용하여 Milvus 서버에 연결하고 createCollection() 을 사용하여 컬렉션을 만듭니다.

를 사용하여 MilvusClient 을 사용하여 Milvus 서버에 연결하고 createCollection() 를 사용하여 컬렉션을 생성합니다.

파이썬 자바 Node.js
from pymilvus import MilvusClient

# 1. Set up a Milvus client
client = MilvusClient(
    uri="http://localhost:19530"
)

# 2. Create a collection
client.create_collection(
    collection_name="quick_setup",
    dimension=5,
)

import com.google.gson.Gson;
import com.google.gson.JsonObject;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.common.ConsistencyLevel;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import io.milvus.v2.service.collection.request.DropCollectionReq;
import io.milvus.v2.service.partition.request.CreatePartitionReq;
import io.milvus.v2.service.vector.request.GetReq;
import io.milvus.v2.service.vector.request.InsertReq;
import io.milvus.v2.service.vector.response.GetResp;
import io.milvus.v2.service.vector.response.InsertResp;

import java.util.*;

String CLUSTER_ENDPOINT = "http://localhost:19530";

// 1. Connect to Milvus server
ConnectConfig connectConfig = ConnectConfig.builder()
    .uri(CLUSTER_ENDPOINT)
    .build();

MilvusClientV2 client = new MilvusClientV2(connectConfig);  

// 2. Create a collection in quick setup mode
CreateCollectionReq quickSetupReq = CreateCollectionReq.builder()
    .collectionName("quick_setup")
    .dimension(5)
    .metricType("IP")
    .build();

client.createCollection(quickSetupReq);

const { MilvusClient, DataType, sleep } = require("@zilliz/milvus2-sdk-node")

const address = "http://localhost:19530"

// 1. Set up a Milvus Client
client = new MilvusClient({address}); 

// 2. Create a collection in quick setup mode
await client.createCollection({
    collection_name: "quick_setup",
    dimension: 5,
});

2단계: 무작위로 생성된 엔티티 삽입하기

를 사용하여 insert() 를 사용하여 컬렉션에 엔티티를 삽입합니다.

사용 insert() 를 사용하여 컬렉션에 엔티티를 삽입합니다.

사용 insert() 를 사용하여 컬렉션에 엔티티를 삽입합니다.

파이썬 자바 노드.js
# 3. Insert randomly generated vectors 
colors = ["green", "blue", "yellow", "red", "black", "white", "purple", "pink", "orange", "brown", "grey"]
data = []

for i in range(1000):
    current_color = random.choice(colors)
    current_tag = random.randint(1000, 9999)
    data.append({
        "id": i,
        "vector": [ random.uniform(-1, 1) for _ in range(5) ],
        "color": current_color,
        "tag": current_tag,
        "color_tag": f"{current_color}_{str(current_tag)}"
    })

print(data[0])

# Output
#
# {
#     "id": 0,
#     "vector": [
#         0.7371107800002366,
#         -0.7290389773227746,
#         0.38367002049157417,
#         0.36996000494220627,
#         -0.3641898951462792
#     ],
#     "color": "yellow",
#     "tag": 6781,
#     "color_tag": "yellow_6781"
# }

res = client.insert(
    collection_name="quick_setup",
    data=data
)

print(res)

# Output
#
# {
#     "insert_count": 1000,
#     "ids": [
#         0,
#         1,
#         2,
#         3,
#         4,
#         5,
#         6,
#         7,
#         8,
#         9,
#         "(990 more items hidden)"
#     ]
# }

// 3. Insert randomly generated vectors into the collection
List<String> colors = Arrays.asList("green", "blue", "yellow", "red", "black", "white", "purple", "pink", "orange", "brown", "grey");
List<JsonObject> data = new ArrayList<>();
Gson gson = new Gson();
for (int i=0; i<1000; i++) {
    Random rand = new Random();
    String current_color = colors.get(rand.nextInt(colors.size()-1));
    int current_tag = rand.nextInt(8999) + 1000;
    JsonObject row = new JsonObject();
    row.addProperty("id", (long) i);
    row.add("vector", gson.toJsonTree(Arrays.asList(rand.nextFloat(), rand.nextFloat(), rand.nextFloat(), rand.nextFloat(), rand.nextFloat())));
    row.addProperty("color", current_color);
    row.addProperty("tag", current_tag);
    row.addProperty("color_tag", current_color + '_' + String.valueOf(rand.nextInt(8999) + 1000));
    data.add(row);
}

InsertReq insertReq = InsertReq.builder()
        .collectionName("quick_setup")
        .data(data)
        .build();

InsertResp insertResp = client.insert(insertReq);

System.out.println(insertResp.getInsertCnt());

// Output:
// 1000

// 3. Insert randomly generated vectors
const colors = ["green", "blue", "yellow", "red", "black", "white", "purple", "pink", "orange", "brown", "grey"]
var data = []

for (let i = 0; i < 1000; i++) {
    current_color = colors[Math.floor(Math.random() * colors.length)]
    current_tag = Math.floor(Math.random() * 8999 + 1000)
    data.push({
        "id": i,
        "vector": [Math.random(), Math.random(), Math.random(), Math.random(), Math.random()],
        "color": current_color,
        "tag": current_tag,
        "color_tag": `${current_color}_${current_tag}`
    })
}

console.log(data[0])

// Output
// 
// {
//   id: 0,
//   vector: [
//     0.16022394821966035,
//     0.6514875214491056,
//     0.18294484964044666,
//     0.30227694168725394,
//     0.47553087493572255
//   ],
//   color: 'blue',
//   tag: 8907,
//   color_tag: 'blue_8907'
// }
// 

res = await client.insert({
    collection_name: "quick_setup",
    data: data
})

console.log(res.insert_cnt)

// Output
// 
// 1000
//

3단계: 파티션 생성 및 더 많은 엔티티 삽입하기

를 사용하여 create_partition() 를 사용하여 파티션을 만들고 insert() 을 사용하여 컬렉션에 더 많은 엔티티를 삽입합니다.

를 사용하여 createPartition() 를 사용하여 파티션을 만들고 insert() 를 사용하여 컬렉션에 더 많은 엔티티를 삽입합니다.

사용 createPartition() 을 사용하여 파티션을 만들고 insert() 를 사용하여 컬렉션에 더 많은 엔티티를 삽입합니다.

파이썬 자바 Node.js
# 4. Create partitions and insert more entities
client.create_partition(
    collection_name="quick_setup",
    partition_name="partitionA"
)

client.create_partition(
    collection_name="quick_setup",
    partition_name="partitionB"
)

data = []

for i in range(1000, 1500):
    current_color = random.choice(colors)
    data.append({
        "id": i,
        "vector": [ random.uniform(-1, 1) for _ in range(5) ],
        "color": current_color,
        "tag": current_tag,
        "color_tag": f"{current_color}_{str(current_tag)}"
    })

res = client.insert(
    collection_name="quick_setup",
    data=data,
    partition_name="partitionA"
)

print(res)

# Output
#
# {
#     "insert_count": 500,
#     "ids": [
#         1000,
#         1001,
#         1002,
#         1003,
#         1004,
#         1005,
#         1006,
#         1007,
#         1008,
#         1009,
#         "(490 more items hidden)"
#     ]
# }

data = []

for i in range(1500, 2000):
    current_color = random.choice(colors)
    data.append({
        "id": i,
        "vector": [ random.uniform(-1, 1) for _ in range(5) ],
        "color": current_color,
        "tag": current_tag,
        "color_tag": f"{current_color}_{str(current_tag)}"
    })

res = client.insert(
    collection_name="quick_setup",
    data=data,
    partition_name="partitionB"
)

print(res)

# Output
#
# {
#     "insert_count": 500,
#     "ids": [
#         1500,
#         1501,
#         1502,
#         1503,
#         1504,
#         1505,
#         1506,
#         1507,
#         1508,
#         1509,
#         "(490 more items hidden)"
#     ]
# }

// 4. Create partitions and insert some more data
CreatePartitionReq createPartitionReq = CreatePartitionReq.builder()
        .collectionName("quick_setup")
        .partitionName("partitionA")
        .build();

client.createPartition(createPartitionReq);

createPartitionReq = CreatePartitionReq.builder()
        .collectionName("quick_setup")
        .partitionName("partitionB")
        .build();

client.createPartition(createPartitionReq);

data.clear();

for (int i=1000; i<1500; i++) {
    Random rand = new Random();
    String current_color = colors.get(rand.nextInt(colors.size()-1));
    int current_tag = rand.nextInt(8999) + 1000;
    JsonObject row = new JsonObject();
    row.addProperty("id", (long) i);
    row.add("vector", gson.toJsonTree(Arrays.asList(rand.nextFloat(), rand.nextFloat(), rand.nextFloat(), rand.nextFloat(), rand.nextFloat())));
    row.addProperty("color", current_color);
    row.addProperty("tag", current_tag);
    data.add(row);
}

insertReq = InsertReq.builder()
        .collectionName("quick_setup")
        .data(data)
        .partitionName("partitionA")
        .build();

insertResp = client.insert(insertReq);

System.out.println(insertResp.getInsertCnt());

// Output:
// 500

data.clear();

for (int i=1500; i<2000; i++) {
    Random rand = new Random();
    String current_color = colors.get(rand.nextInt(colors.size()-1));
    int current_tag = rand.nextInt(8999) + 1000;
    JsonObject row = new JsonObject();
    row.addProperty("id", (long) i);
    row.add("vector", gson.toJsonTree(Arrays.asList(rand.nextFloat(), rand.nextFloat(), rand.nextFloat(), rand.nextFloat(), rand.nextFloat())));
    row.addProperty("color", current_color);
    row.addProperty("tag", current_tag);
    data.add(row);
}

insertReq = InsertReq.builder()
        .collectionName("quick_setup")
        .data(data)
        .partitionName("partitionB")
        .build();

insertResp = client.insert(insertReq);

System.out.println(insertResp.getInsertCnt());

// Output:
// 500

// 4. Create partitions and insert more entities
await client.createPartition({
    collection_name: "quick_setup",
    partition_name: "partitionA"
})

await client.createPartition({
    collection_name: "quick_setup",
    partition_name: "partitionB"
})

data = []

for (let i = 1000; i < 1500; i++) {
    current_color = colors[Math.floor(Math.random() * colors.length)]
    current_tag = Math.floor(Math.random() * 8999 + 1000)
    data.push({
        "id": i,
        "vector": [Math.random(), Math.random(), Math.random(), Math.random(), Math.random()],
        "color": current_color,
        "tag": current_tag,
        "color_tag": `${current_color}_${current_tag}`
    })
}

res = await client.insert({
    collection_name: "quick_setup",
    data: data,
    partition_name: "partitionA"
})

console.log(res.insert_cnt)

// Output
// 
// 500
// 

await sleep(5000)

data = []

for (let i = 1500; i < 2000; i++) {
    current_color = colors[Math.floor(Math.random() * colors.length)]
    current_tag = Math.floor(Math.random() * 8999 + 1000)
    data.push({
        "id": i,
        "vector": [Math.random(), Math.random(), Math.random(), Math.random(), Math.random()],
        "color": current_color,
        "tag": current_tag,
        "color_tag": `${current_color}_${current_tag}`
    })
}

res = await client.insert({
    collection_name: "quick_setup",
    data: data,
    partition_name: "partitionB"
})

console.log(res.insert_cnt)

// Output
// 
// 500
//

ID로 엔티티 가져오기

관심 있는 엔티티의 ID를 알고 있는 경우에는 get() 메서드를 사용할 수 있습니다.

관심 있는 엔티티의 ID를 알고 있는 경우에는 get() 메서드를 사용할 수 있습니다.

관심 있는 엔티티의 ID를 알고 있는 경우에는 get() 메서드를 사용할 수 있습니다.

Python Java Node.js
# 4. Get entities by ID
res = client.get(
    collection_name="quick_setup",
    ids=[0, 1, 2]
)

print(res)

# Output
#
# [
#     {
#         "id": 0,
#         "vector": [
#             0.68824464,
#             0.6552274,
#             0.33593303,
#             -0.7099536,
#             -0.07070546
#         ],
#         "color_tag": "green_2006",
#         "color": "green"
#     },
#     {
#         "id": 1,
#         "vector": [
#             -0.98531723,
#             0.33456197,
#             0.2844234,
#             0.42886782,
#             0.32753858
#         ],
#         "color_tag": "white_9298",
#         "color": "white"
#     },
#     {
#         "id": 2,
#         "vector": [
#             -0.9886812,
#             -0.44129863,
#             -0.29859528,
#             0.06059075,
#             -0.43817034
#         ],
#         "color_tag": "grey_5312",
#         "color": "grey"
#     }
# ]

// 5. Get entities by ID
GetReq getReq = GetReq.builder()
        .collectionName("quick_setup")
        .ids(Arrays.asList(0L, 1L, 2L))
        .build();

GetResp entities = client.get(getReq);

System.out.println(entities.getGetResults());

// Output:
// [
//  QueryResp.QueryResult(entity={color=blue, color_tag=blue_4025, vector=[0.64311606, 0.73486423, 0.7352375, 0.7020566, 0.9885356], id=0, tag=4018}),
//  QueryResp.QueryResult(entity={color=red, color_tag=red_4788, vector=[0.27244627, 0.7068031, 0.25976115, 0.69258106, 0.8767045], id=1, tag=6611}),
//  QueryResp.QueryResult(entity={color=yellow, color_tag=yellow_8382, vector=[0.19625628, 0.40176708, 0.13231951, 0.50702184, 0.88406855], id=2, tag=5349})
//]


// 5. Get entities by id
res = await client.get({
    collection_name: "quick_setup",
    ids: [0, 1, 2],
    output_fields: ["vector", "color_tag"]
})

console.log(res.data)

// Output
// 
// [
//   {
//     vector: [
//       0.16022394597530365,
//       0.6514875292778015,
//       0.18294484913349152,
//       0.30227693915367126,
//       0.47553086280822754
//     ],
//     '$meta': { color: 'blue', tag: 8907, color_tag: 'blue_8907' },
//     id: '0'
//   },
//   {
//     vector: [
//       0.2459285855293274,
//       0.4974019527435303,
//       0.2154673933982849,
//       0.03719571232795715,
//       0.8348019123077393
//     ],
//     '$meta': { color: 'grey', tag: 3710, color_tag: 'grey_3710' },
//     id: '1'
//   },
//   {
//     vector: [
//       0.9404329061508179,
//       0.49662265181541443,
//       0.8088793158531189,
//       0.9337621331214905,
//       0.8269071578979492
//     ],
//     '$meta': { color: 'blue', tag: 2993, color_tag: 'blue_2993' },
//     id: '2'
//   }
// ]
//

파티션에서 엔티티 가져오기

특정 파티션에서 엔티티를 가져올 수도 있습니다.

Python Java Node.js
# 5. Get entities from partitions
res = client.get(
    collection_name="quick_setup",
    ids=[1000, 1001, 1002],
    partition_names=["partitionA"]
)

print(res)

# Output
#
# [
#     {
#         "color": "green",
#         "tag": 1995,
#         "color_tag": "green_1995",
#         "id": 1000,
#         "vector": [
#             0.7807706,
#             0.8083741,
#             0.17276904,
#             -0.8580777,
#             0.024156934
#         ]
#     },
#     {
#         "color": "red",
#         "tag": 1995,
#         "color_tag": "red_1995",
#         "id": 1001,
#         "vector": [
#             0.065074645,
#             -0.44882354,
#             -0.29479212,
#             -0.19798489,
#             -0.77542555
#         ]
#     },
#     {
#         "color": "green",
#         "tag": 1995,
#         "color_tag": "green_1995",
#         "id": 1002,
#         "vector": [
#             0.027934508,
#             -0.44199976,
#             -0.40262738,
#             -0.041511405,
#             0.024782438
#         ]
#     }
# ]

// 5. Get entities by ID in a partition
getReq = GetReq.builder()
        .collectionName("quick_setup")
        .ids(Arrays.asList(1001L, 1002L, 1003L))
        .partitionName("partitionA")
        .build();

entities = client.get(getReq);

System.out.println(entities.getGetResults());

// Output:
// [
//  QueryResp.QueryResult(entity={color=pink, vector=[0.28847772, 0.5116072, 0.5695933, 0.49643654, 0.3461541], id=1001, tag=9632}), 
//  QueryResp.QueryResult(entity={color=blue, vector=[0.22428268, 0.8648047, 0.78426147, 0.84020555, 0.60779166], id=1002, tag=4523}), 
//  QueryResp.QueryResult(entity={color=white, vector=[0.4081068, 0.9027214, 0.88685805, 0.38036376, 0.27950126], id=1003, tag=9321})
// ]

// 5.1 Get entities by id in a partition
res = await client.get({
    collection_name: "quick_setup",
    ids: [1000, 1001, 1002],
    partition_names: ["partitionA"],
    output_fields: ["vector", "color_tag"]
})

console.log(res.data)

// Output
// 
// [
//   {
//     id: '1000',
//     vector: [
//       0.014254206791520119,
//       0.5817716121673584,
//       0.19793470203876495,
//       0.8064294457435608,
//       0.7745839357376099
//     ],
//     '$meta': { color: 'white', tag: 5996, color_tag: 'white_5996' }
//   },
//   {
//     id: '1001',
//     vector: [
//       0.6073881983757019,
//       0.05214758217334747,
//       0.730999231338501,
//       0.20900958776474,
//       0.03665429726243019
//     ],
//     '$meta': { color: 'grey', tag: 2834, color_tag: 'grey_2834' }
//   },
//   {
//     id: '1002',
//     vector: [
//       0.48877206444740295,
//       0.34028753638267517,
//       0.6527213454246521,
//       0.9763909578323364,
//       0.8031482100486755
//     ],
//     '$meta': { color: 'pink', tag: 9107, color_tag: 'pink_9107' }
//   }
// ]
//

기본 연산자 사용

이 섹션에서는 스칼라 필터링에서 기본 연산자를 사용하는 방법에 대한 예제를 찾을 수 있습니다. 이러한 필터를 벡터 검색 및 데이터 삭제에도 적용할 수 있습니다.

자세한 내용은 SDK 참조에서 query() 를 참조하세요.

자세한 내용은 SDK 레퍼런스에서 query() 를 참조하세요.

자세한 내용은 query() 를 참조하세요.

  • 태그 값이 1,000에서 1,500 사이인 엔티티를 필터링합니다.

    Python JavaNode.js

    # 6. Use basic operators

res = client.query(
    collection_name="quick_setup",
    filter="1000 < tag < 1500",
    output_fields=["color_tag"],
    limit=3
)

print(res)

# Output
#
# [
#     {
#         "id": 1,
#         "color_tag": "pink_1023"
#     },
#     {
#         "id": 41,
#         "color_tag": "red_1483"
#     },
#     {
#         "id": 44,
#         "color_tag": "grey_1146"
#     }
# ]

    // 6. Use basic operators

QueryReq queryReq = QueryReq.builder()
    .collectionName("quick_setup")
    .filter("1000 < tag < 1500")
    .outputFields(Arrays.asList("color_tag"))
    .limit(3)
    .build();

QueryResp queryResp = client.query(queryReq);

System.out.println(JSONObject.toJSON(queryResp));

// Output:
// {"queryResults": [
//     {"entity": {
//         "color_tag": "white_7588",
//         "id": 34
//     }},
//     {"entity": {
//         "color_tag": "orange_4989",
//         "id": 64
//     }},
//     {"entity": {
//         "color_tag": "white_3415",
//         "id": 73
//     }}
// ]}

    // 6. Use basic operators
res = await client.query({
    collection_name: "quick_setup",
    filter: "1000 < tag < 1500",
    output_fields: ["color_tag"],
    limit: 3
})

console.log(res.data)

// Output
// 
// [
//   {
//     '$meta': { color: 'pink', tag: 1050, color_tag: 'pink_1050' },
//     id: '6'
//   },
//   {
//     '$meta': { color: 'purple', tag: 1174, color_tag: 'purple_1174' },
//     id: '24'
//   },
//   {
//     '$meta': { color: 'orange', tag: 1023, color_tag: 'orange_1023' },
//     id: '40'
//   }
// ]
//

  • 색상 값이 갈색으로 설정된 엔티티를 필터링합니다.

    Python JavaNode.js

    res = client.query(
    collection_name="quick_setup",
    filter='color == "brown"',
    output_fields=["color_tag"],
    limit=3
)

print(res)

# Output
#
# [
#     {
#         "color_tag": "brown_5343",
#         "id": 15
#     },
#     {
#         "color_tag": "brown_3167",
#         "id": 27
#     },
#     {
#         "color_tag": "brown_3100",
#         "id": 30
#     }
# ]

    queryReq = QueryReq.builder()
    .collectionName("quick_setup")
    .filter("color == \"brown\"")
    .outputFields(Arrays.asList("color_tag"))
    .limit(3)
    .build();

queryResp = client.query(queryReq);

System.out.println(JSONObject.toJSON(queryResp));

// Output:
// {"queryResults": [
//     {"entity": {
//         "color_tag": "brown_7792",
//         "id": 3
//     }},
//     {"entity": {
//         "color_tag": "brown_9695",
//         "id": 7
//     }},
//     {"entity": {
//         "color_tag": "brown_2551",
//         "id": 15
//     }}
// ]}

    res = await client.query({
    collection_name: "quick_setup",
    filter: 'color == "brown"',
    output_fields: ["color_tag"],
    limit: 3
})

console.log(res.data)

// Output
// 
// [
//   {
//     '$meta': { color: 'brown', tag: 6839, color_tag: 'brown_6839' },
//     id: '22'
//   },
//   {
//     '$meta': { color: 'brown', tag: 7849, color_tag: 'brown_7849' },
//     id: '32'
//   },
//   {
//     '$meta': { color: 'brown', tag: 7855, color_tag: 'brown_7855' },
//     id: '33'
//   }
// ]
//

  • 색상 값이 녹색과 보라색으로 설정되지 않은 엔티티를 필터링합니다.

    Python JavaNode.js

    res = client.query(
    collection_name="quick_setup",
    filter='color not in ["green", "purple"]',
    output_fields=["color_tag"],
    limit=3
)

print(res)

# Output
#
# [
#     {
#         "color_tag": "yellow_6781",
#         "id": 0
#     },
#     {
#         "color_tag": "pink_1023",
#         "id": 1
#     },
#     {
#         "color_tag": "blue_3972",
#         "id": 2
#     }
# ]

    queryReq = QueryReq.builder()
    .collectionName("quick_setup")
    .filter("color not in [\"green\", \"purple\"]")
    .outputFields(Arrays.asList("color_tag"))
    .limit(3)
    .build();

queryResp = client.query(queryReq);

System.out.println(JSONObject.toJSON(queryResp));   

// Output:
// {"queryResults": [
//     {"entity": {
//         "color_tag": "white_4597",
//         "id": 0
//     }},
//     {"entity": {
//         "color_tag": "white_8708",
//         "id": 2
//     }},
//     {"entity": {
//         "color_tag": "brown_7792",
//         "id": 3
//     }}
// ]}

    res = await client.query({
    collection_name: "quick_setup",
    filter: 'color not in ["green", "purple"]',
    output_fields: ["color_tag"],
    limit: 3
})

console.log(res.data)

// Output
// 
// [
//   {
//     '$meta': { color: 'blue', tag: 8907, color_tag: 'blue_8907' },
//     id: '0'
//   },
//   {
//     '$meta': { color: 'grey', tag: 3710, color_tag: 'grey_3710' },
//     id: '1'
//   },
//   {
//     '$meta': { color: 'blue', tag: 2993, color_tag: 'blue_2993' },
//     id: '2'
//   }
// ]
//

  • 색상 태그가 빨간색으로 시작하는 문서를 필터링합니다.

    Python JavaNode.js

    res = client.query(
    collection_name="quick_setup",
    filter='color_tag like "red%"',
    output_fields=["color_tag"],
    limit=3
)

print(res)

# Output
#
# [
#     {
#         "color_tag": "red_6443",
#         "id": 17
#     },
#     {
#         "color_tag": "red_1483",
#         "id": 41
#     },
#     {
#         "color_tag": "red_4348",
#         "id": 47
#     }
# ]

    queryReq = QueryReq.builder()
    .collectionName("quick_setup")
    .filter("color_tag like \"red%\"")
    .outputFields(Arrays.asList("color_tag"))
    .limit(3)
    .build();

queryResp = client.query(queryReq);

System.out.println(JSONObject.toJSON(queryResp));  

// Output:
// {"queryResults": [
//     {"entity": {
//         "color_tag": "red_4929",
//         "id": 9
//     }},
//     {"entity": {
//         "color_tag": "red_8284",
//         "id": 13
//     }},
//     {"entity": {
//         "color_tag": "red_3021",
//         "id": 44
//     }}
// ]}

    res = await client.query({
    collection_name: "quick_setup",
    filter: 'color_tag like "red%"',
    output_fields: ["color_tag"],
    limit: 3
})

console.log(res.data)

// Output
// 
// [
//   {
//     '$meta': { color: 'red', tag: 8773, color_tag: 'red_8773' },
//     id: '17'
//   },
//   {
//     '$meta': { color: 'red', tag: 9197, color_tag: 'red_9197' },
//     id: '34'
//   },
//   {
//     '$meta': { color: 'red', tag: 7914, color_tag: 'red_7914' },
//     id: '46'
//   }
// ]
//

  • 색상이 빨간색으로 설정되어 있고 태그 값이 1,000에서 1,500 범위 내에 있는 항목을 필터링합니다.

    Python JavaNode.js

    res = client.query(
    collection_name="quick_setup",
    filter='(color == "red") and (1000 < tag < 1500)',
    output_fields=["color_tag"],
    limit=3
)

print(res)

# Output
#
# [
#     {
#         "color_tag": "red_1483",
#         "id": 41
#     },
#     {
#         "color_tag": "red_1100",
#         "id": 94
#     },
#     {
#         "color_tag": "red_1343",
#         "id": 526
#     }
# ]

    queryReq = QueryReq.builder()
    .collectionName("quick_setup")
    .filter("(color == \"red\") and (1000 < tag < 1500)")
    .outputFields(Arrays.asList("color_tag"))
    .limit(3)
    .build();

queryResp = client.query(queryReq);

System.out.println(JSONObject.toJSON(queryResp));  

// Output:
// {"queryResults": [
//     {"entity": {
//         "color_tag": "red_8124",
//         "id": 83
//     }},
//     {"entity": {
//         "color_tag": "red_5358",
//         "id": 501
//     }},
//     {"entity": {
//         "color_tag": "red_3564",
//         "id": 638
//     }}
// ]}

    res = await client.query({
    collection_name: "quick_setup",
    filter: '(color == "red") and (1000 < tag < 1500)',
    output_fields: ["color_tag"],
    limit: 3
})

console.log(res.data)

// Output
// 
// [
//   {
//     '$meta': { color: 'red', tag: 1436, color_tag: 'red_1436' },
//     id: '67'
//   },
//   {
//     '$meta': { color: 'red', tag: 1463, color_tag: 'red_1463' },
//     id: '160'
//   },
//   {
//     '$meta': { color: 'red', tag: 1073, color_tag: 'red_1073' },
//     id: '291'
//   }
// ]
//

고급 연산자 사용

이 섹션에서는 스칼라 필터링에서 고급 연산자를 사용하는 방법에 대한 예제를 찾을 수 있습니다. 이러한 필터를 벡터 검색 및 데이터 삭제에도 적용할 수 있습니다.

엔티티 카운트

  • 컬렉션의 총 엔티티 수를 계산합니다.

    Python JavaNode.js

    # 7. Use advanced operators

# Count the total number of entities in a collection
res = client.query(
    collection_name="quick_setup",
    output_fields=["count(*)"]
)

print(res)

# Output
#
# [
#     {
#         "count(*)": 2000
#     }
# ]

    // 7. Use advanced operators
// Count the total number of entities in the collection
queryReq = QueryReq.builder()
    .collectionName("quick_setup")
    .filter("")
    .outputFields(Arrays.asList("count(*)"))
    .build();

queryResp = client.query(queryReq);

System.out.println(JSONObject.toJSON(queryResp));

// Output:
// {"queryResults": [{"entity": {"count(*)": 2000}}]}

    // 7. Use advanced operators
// Count the total number of entities in a collection
res = await client.query({
    collection_name: "quick_setup",
    output_fields: ["count(*)"]
})

console.log(res.data)   

// Output
// 
// [ { 'count(*)': '2000' } ]
//

  • 특정 파티션에 있는 엔티티의 총 개수를 계산합니다.

    Python JavaNode.js

    # Count the number of entities in a partition
res = client.query(
    collection_name="quick_setup",
    output_fields=["count(*)"],
    partition_names=["partitionA"]
)

print(res)

# Output
#
# [
#     {
#         "count(*)": 500
#     }
# ]

    // Count the number of entities in a partition
queryReq = QueryReq.builder()
    .collectionName("quick_setup")
    .partitionNames(Arrays.asList("partitionA"))
    .filter("")
    .outputFields(Arrays.asList("count(*)"))
    .build();

queryResp = client.query(queryReq);

System.out.println(JSONObject.toJSON(queryResp));

// Output:
// {"queryResults": [{"entity": {"count(*)": 500}}]}

    // Count the number of entities in a partition
res = await client.query({
    collection_name: "quick_setup",
    output_fields: ["count(*)"],
    partition_names: ["partitionA"]
})

console.log(res.data)     

// Output
// 
// [ { 'count(*)': '500' } ]
//

  • 필터링 조건에 일치하는 엔티티의 수를 계산합니다.

    Python JavaNode.js

    # Count the number of entities that match a specific filter
res = client.query(
    collection_name="quick_setup",
    filter='(color == "red") and (1000 < tag < 1500)',
    output_fields=["count(*)"],
)

print(res)

# Output
#
# [
#     {
#         "count(*)": 3
#     }
# ]

    // Count the number of entities that match a specific filter
queryReq = QueryReq.builder()
    .collectionName("quick_setup")
    .filter("(color == \"red\") and (1000 < tag < 1500)")
    .outputFields(Arrays.asList("count(*)"))
    .build();

queryResp = client.query(queryReq);

System.out.println(JSONObject.toJSON(queryResp));

// Output:
// {"queryResults": [{"entity": {"count(*)": 7}}]}

    // Count the number of entities that match a specific filter
res = await client.query({
    collection_name: "quick_setup",
    filter: '(color == "red") and (1000 < tag < 1500)',
    output_fields: ["count(*)"]
})

console.log(res.data)   

// Output
// 
// [ { 'count(*)': '10' } ]
//

스칼라 필터에 대한 참조

기본 연산자

부울 표현식은 항상 연산자로 결합된 필드 이름으로 구성된 문자열입니다. 이 섹션에서는 기본 연산자에 대해 자세히 알아봅니다.

연산자설명
및 (&&)두 피연산자가 모두 참이면 참
또는 (||)피연산자 중 하나가 참이면 참
+, -, *, /덧셈, 뺄셈, 곱셈, 나눗셈
**지수
%모듈러스
<, >보다 작음, 보다 큼
==, !=같음, 같지 않음
<=, >=보다 작거나 같음, 보다 크거나 같음
not주어진 조건의 결과를 반전시킵니다.
like와일드카드 연산자를 사용하여 값을 유사한 값과 비교합니다.
예를 들어, '접두사%'는 '접두사'로 시작하는 문자열과 일치합니다.
in표현식이 값 목록의 어떤 값과 일치하는지 테스트합니다.

고급 연산자

  • count(*)

    컬렉션에 있는 엔티티의 정확한 개수를 계산합니다. 컬렉션 또는 파티션의 정확한 엔티티 수를 가져오려면 이 값을 출력 필드로 사용합니다.

    참고

    로드된 컬렉션에 적용됩니다. 유일한 출력 필드로 사용해야 합니다.

번역DeepL

목차 목록

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started
피드백

이 페이지가 도움이 되었나요?