Milvus 소개
시작하기
개념
사용자 가이드
데이터 가져오기
AI 도구
관리 가이드
도구
연동 기능
튜토리얼
자주 묻는 질문
API Reference

JSON 필드

Milvus에서는 ` JSON ` 데이터형을 사용하여 단일 필드 내에 구조화된 데이터를 저장하고 색인을 생성할 수 있습니다. 이를 통해 중첩된 속성을 가진 유연한 스키마를 구성할 수 있으며, 동시에 JSON 색인화를 통해 효율적인 필터링이 가능합니다.

JSON 필드란 무엇인가요?

JSON 필드는 Milvus에서 구조화된 키-값 데이터를 저장하는 스키마 정의 필드입니다. 값에는 문자열, 숫자, 부울, 배열 또는 깊게 중첩된 객체가 포함될 수 있습니다.

다음은 문서 내에서 JSON 필드가 어떻게 표시될 수 있는지에 대한 예시입니다:

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

이 예시에서:

metadata 는 스키마에 정의된 JSON 필드입니다.
플랫 값(예: category, in_stock), 배열(tags), 중첩된 객체(supplier)를 저장할 수 있습니다.

스키마에서 JSON 필드 정의하기

JSON 필드를 사용하려면 컬렉션 스키마에서 DataType 을 JSON 으로 명시적으로 정의해야 합니다.

아래 예제는 다음 필드를 포함하는 스키마를 가진 컬렉션을 생성합니다:

기본 키(product_id)
vector 필드(각 컬렉션에 필수)
JSON 유형의 metadata 필드(플랫 값, 배열 또는 중첩된 객체와 같은 구조화된 데이터를 저장할 수 있음)

Python Java NodeJS Go cURL

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: 'http://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: "http://localhost:19530",
})
if err != nil {
    return err
}

schema := entity.NewSchema().WithDynamicFieldEnabled(true)
schema.WithField(entity.NewField().
    WithName("product_id").
    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",
  "elementTypeParams": {
    "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" \
--header "Request-Timeout: 10" \
--data "{
  \"collectionName\": \"product_catalog\",
  \"schema\": $schema
}"

동적 필드 기능을 활성화하여 선언되지 않은 필드를 유연하게 저장할 수도 있지만, JSON 필드가 작동하는 데 필수적인 기능은 아닙니다. 자세한 내용은 동적 필드를 참조하십시오.

JSON 데이터가 포함된 엔티티 삽입

컬렉션이 생성되면, ` metadata ` JSON 필드에 구조화된 JSON 객체를 포함하는 엔티티를 삽입합니다.

Python Java NodeJS Go cURL

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" \
--header "Request-Timeout: 10" \
--data "{
  \"data\": $entities
}"

JSON 필드 내 값 인덱싱

JSON 필드에 대한 스칼라 필터링 속도를 높이기 위해 Milvus는 JSON 경로 인덱싱을 지원하며, 이를 통해 선언된 스칼라 유형으로 특정 JSON 경로를 인덱싱할 수 있습니다.

JSON 필드의 인덱싱은 선택 사항입니다. 인덱스가 없어도 JSON 경로를 기준으로 쿼리하거나 필터링할 수 있지만, 무차별 대입 검색으로 인해 성능이 저하될 수 있습니다.

JSON 경로 인덱싱

JSON 경로 인덱스를 생성하려면 다음을 지정하십시오.

JSON 경로 (json_path): 인덱싱하려는 JSON 객체 내의 키 또는 중첩된 필드로 이동하는 경로입니다.
- 예:
  - 키의 경우, metadata["category"]
  - 중첩된 필드의 경우, metadata["contact"]["email"]
  이는 인덱싱 엔진이 JSON 구조 내에서 어디를 확인해야 하는지를 정의합니다.
JSON 캐스트 유형 (json_cast_type): Milvus가 지정된 경로의 값을 해석하고 색인화할 때 사용해야 하는 데이터 유형입니다.
- 이 유형은 인덱싱되는 필드의 실제 데이터 유형과 일치해야 합니다. 인덱싱 중에 데이터 유형을 다른 유형으로 변환하려면 캐스트 함수 사용을 고려하십시오.
- 전체 목록은 아래를 참조하십시오.

지원되는 JSON 형 변환 유형

캐스트 유형은 대소문자를 구분하지 않습니다. 다음 유형이 지원됩니다:

변환 유형	설명	JSON 값 예시
`bool`	부울 값	`true`, `false`
`double`	숫자 값 (정수 또는 실수)	`42`, `99.99`, `-15.5`
`varchar`	문자열 값	`"electronics"`, `"BrandA"`
`array_bool`	부울 값의 배열	`[true, false, true]`
`array_double`	숫자 배열	`[1.2, 3.14, 42]`
`array_varchar`	문자열 배열	`["tag1", "tag2", "tag3"]`

최적의 인덱싱을 위해 배열에는 동일한 유형의 요소만 포함되어야 합니다. 자세한 내용은 '배열 필드'를 참조하십시오.

예: JSON 경로 인덱스 생성

소개 부분에서 다룬 metadata JSON 구조를 사용하여, 다양한 JSON 경로에 인덱스를 생성하는 방법은 다음과 같습니다.

Python Java NodeJS Go cURL

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

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

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

import io.milvus.v2.common.IndexParam;

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

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

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

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

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

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

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

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

형식 변환을 위해 JSON 캐스트 함수 사용Compatible with Milvus 2.5.14+

JSON 필드 키에 잘못된 형식의 값(예: 문자열로 저장된 숫자)이 포함된 경우, 캐스트 함수를 사용하여 인덱싱 과정에서 값을 변환할 수 있습니다.

지원되는 캐스트 함수

캐스트 함수는 대소문자를 구분하지 않습니다. 다음 유형이 지원됩니다:

변환 함수	변환 대상 → 변환 결과	사용 사례
`"STRING_TO_DOUBLE"`	문자열 → 숫자(double)	`"99.99"` 를 다음으로 변환 `99.99`

예시: 문자열 형태의 숫자를 double로 형변환하기

Python Java NodeJS Go cURL

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

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

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

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

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

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

json_cast_type 매개변수는 필수이며, 캐스팅 함수의 출력 유형과 동일해야 합니다.
변환에 실패하는 경우(예: 숫자가 아닌 문자열), 해당 값은 건너뛰어지며 인덱싱되지 않습니다.

컬렉션에 인덱스 적용

인덱스 매개변수를 정의한 후, ` create_index()`를 사용하여 컬렉션에 인덱스를 적용할 수 있습니다:

Python Java NodeJS Go cURL

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
}
indexTask4, err := client.CreateIndex(ctx, indexOpt4)
if err != nil {
    return err
}
indexTask5, err := client.CreateIndex(ctx, indexOpt5)
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" \
--header "Request-Timeout: 10" \
--data "{
  \"collectionName\": \"product_catalog\",
  \"indexParams\": $indexParams
}"

JSON 필드 값으로 필터링

JSON 필드를 삽입하고 인덱싱한 후에는 JSON 경로 구문을 사용하는 표준 필터 표현식을 통해 해당 필드를 기준으로 필터링할 수 있습니다.

예:

Python Java NodeJS Go cURL

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

String filterCategory = "metadata[\"category\"] == \"electronics\"";
String filterPrice = "metadata[\"price\"] > 50";
String filterTags = "json_contains(metadata[\"tags\"], \"featured\")";

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

filterCategory := `metadata["category"] == "electronics"`
filterPrice := `metadata["price"] > 50`
filterTags := `json_contains(metadata["tags"], "featured")`

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

검색이나 쿼리에서 이러한 표현식을 사용하려면 다음 사항을 확인하십시오:

각 벡터 필드에 대해 인덱스를 생성했어야 합니다.
컬렉션이 메모리에 로드되어 있어야 합니다.

지원되는 연산자 및 표현식의 전체 목록은 JSON 연산자를 참조하십시오.

모든 내용을 종합해 봅시다

지금까지 JSON 필드 내에서 구조화된 값을 정의하고, 삽입하며, 필요에 따라 인덱스를 생성하는 방법을 배웠습니다.

실제 애플리케이션에서 워크플로를 완료하려면 다음 작업도 수행해야 합니다.

벡터 필드에 인덱스를 생성합니다 (컬렉션 내 각 벡터 필드에 대해 필수).

'인덱스 매개변수 설정'을 참조하십시오
컬렉션 로드하기

'로드 및 릴리스' 참조
JSON 경로 필터를 사용하여 검색하거나 쿼리하기

'필터링된 검색 및 JSON 연산자' 참조

자주 묻는 질문

JSON 필드와 동적 필드의 차이점은 무엇입니까?

JSON 필드는 스키마로 정의됩니다. 스키마에서 해당 필드를 명시적으로 선언해야 합니다.
동적 필드는 스키마에 정의되지 않은 모든 필드를 자동으로 저장하는 숨겨진 JSON 객체($meta)입니다.

둘 다 중첩 구조와 JSON 경로 인덱싱을 지원하지만, 동적 필드는 선택적 또는 진화하는 데이터 구조에 더 적합합니다.

자세한 내용은 동적 필드를 참조하십시오.

JSON 필드의 크기에 제한이 있습니까?

예. 각 JSON 필드는 65,536바이트로 제한됩니다.

JSON 필드에서 기본값 설정이 가능한가요?

아니요, JSON 필드는 기본값을 지원하지 않습니다. 그러나 필드를 정의할 때 ` nullable=True `를 설정하여 빈 항목을 허용할 수 있습니다.

자세한 내용은 'Nullable 및 기본값 '을 참조하십시오.

JSON 필드 키에 대한 명명 규칙이 있나요?

예, 쿼리 및 인덱싱과의 호환성을 보장하기 위해:

JSON 키에는 영문자, 숫자 및 밑줄(_)만 사용하십시오.
특수 문자, 공백 또는 점(., / 등)의 사용은 피하십시오.
호환되지 않는 키를 사용하면 필터 표현식에서 구문 분석 문제가 발생할 수 있습니다.

Milvus는 JSON 필드의 문자열 값을 어떻게 처리하나요?

Milvus는 의미적 변환 없이 JSON 입력에 표시된 그대로 문자열 값을 저장합니다. 따옴표가 올바르게 지정되지 않은 문자열은 파싱 중에 오류를 일으킬 수 있습니다.

유효한 문자열의 예:

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

유효하지 않은 문자열의 예:

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

Milvus는 인덱싱된 JSON 경로에 대해 어떤 필터링 로직을 사용하나요?

숫자 인덱싱:

json_cast_type="double" 로 인덱스가 생성된 경우, 숫자형 필터 조건(예: >, <, == 42)만 해당 인덱스를 활용합니다. 숫자가 아닌 조건의 경우 무차별 스캔으로 대체될 수 있습니다.
문자열 인덱싱:

인덱스가 ` json_cast_type="varchar"`를 사용하는 경우, 문자열 필터 조건만 해당 인덱스의 이점을 누릴 수 있으며, 다른 유형의 조건은 무차별 스캔으로 전환될 수 있습니다.
부울 인덱싱:

부울 인덱싱은 문자열 인덱싱과 유사하게 작동하며, 조건이 true 또는 false와 정확히 일치할 때만 인덱스가 사용됩니다.

JSON 필드를 인덱싱할 때 숫자 정밀도는 어떻게 되나요?

Milvus는 인덱싱된 모든 숫자 값을 double 형식으로 저장합니다.

숫자 값이 2^53을 초과하면 정밀도가 떨어질 수 있습니다. 이러한 정밀도 손실로 인해 필터 쿼리가 범위 외 값과 정확히 일치하지 않을 수 있습니다.

동일한 JSON 경로에 서로 다른 캐스트 유형을 사용하여 여러 인덱스를 생성할 수 있나요?

아니요, 각 JSON 경로는 하나의 인덱스만 지원합니다. 데이터에 맞는 단일 변환 유형( json_cast_type )을 선택해야 합니다. 동일한 경로에 서로 다른 변환 유형을 사용하여 여러 인덱스를 생성하는 것은 지원되지 않습니다.

JSON 경로의 값 유형이 일관되지 않은 경우에는 어떻게 되나요?

엔티티 간에 유형이 일관되지 않으면 부분 인덱싱이 발생할 수 있습니다. 예를 들어, metadata["price"] 가 숫자(99.99)와 문자열("99.99")로 모두 저장되어 있고, 인덱스가 json_cast_type="double" 로 정의된 경우, 숫자 값만 인덱싱됩니다. 문자열 형식의 항목은 건너뛰어지며 필터 결과에 표시되지 않습니다.

인덱싱된 캐스트 유형과 다른 유형의 필터를 사용할 수 있나요?

필터 표현식이 인덱스의 json_cast_type 과 다른 유형을 사용하는 경우, 시스템은 해당 인덱스를 사용하지 않으며, 데이터가 허용하는 경우 더 느린 무차별 대입(brute-force) 스캔으로 대체될 수 있습니다. 최상의 성능을 얻으려면 항상 필터 표현식을 인덱스의 캐스트 유형과 일치시켜야 합니다.

번역 DeepL

목차 목록

JSON 필드
JSON 필드란 무엇인가요?
스키마에서 JSON 필드 정의하기
JSON 데이터가 포함된 엔티티 삽입
JSON 필드 내 값 인덱싱
JSON 경로 인덱싱
컬렉션에 인덱스 적용
JSON 필드 값으로 필터링
모든 내용을 종합해 봅시다
자주 묻는 질문
JSON 필드와 동적 필드의 차이점은 무엇입니까?
JSON 필드의 크기에 제한이 있습니까?
JSON 필드에서 기본값 설정이 가능한가요?
JSON 필드 키에 대한 명명 규칙이 있나요?
Milvus는 JSON 필드의 문자열 값을 어떻게 처리하나요?
Milvus는 인덱싱된 JSON 경로에 대해 어떤 필터링 로직을 사용하나요?
JSON 필드를 인덱싱할 때 숫자 정밀도는 어떻게 되나요?
동일한 JSON 경로에 서로 다른 캐스트 유형을 사용하여 여러 인덱스를 생성할 수 있나요?
JSON 경로의 값 유형이 일관되지 않은 경우에는 어떻게 되나요?
인덱싱된 캐스트 유형과 다른 유형의 필터를 사용할 수 있나요?

관리형 Milvus를 무료로 사용해 보세요

Zilliz Cloud는 번거로움이 없으며, Milvus 기반으로 10배 더 빠릅니다.

시작하기

피드백

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