从陷阱到高效：Milvus Java SDK listIndexes方法的字段过滤逻辑深度解析与最佳实践

原创 于 2025-06-27 09:09:10 发布 · 253 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

从陷阱到高效：Milvus Java SDK listIndexes方法的字段过滤逻辑深度解析与最佳实践

【免费下载链接】milvus-sdk-java Java SDK for Milvus. 【免费下载链接】milvus-sdk-java 项目地址: https://gitcode.com/gh_mirrors/mi/milvus-sdk-java

引言：被忽略的索引过滤陷阱

你是否曾在使用Milvus Java SDK的listIndexes方法时，遇到返回结果与预期不符的情况？明明指定了字段名进行过滤，却依然返回了所有字段的索引信息？这种看似简单的API调用背后，可能隐藏着影响系统性能和开发效率的潜在问题。本文将深入剖析Milvus Java SDK中listIndexes方法的字段过滤行为，揭示其实现原理，并提供经过验证的解决方案，帮助你避免常见陷阱，提升向量数据库操作的准确性和效率。

读完本文后，你将能够：

  • 理解listIndexes方法的内部工作机制和字段过滤逻辑
  • 识别并解决字段过滤失效的常见问题
  • 掌握基于字段名和索引名进行精确过滤的正确方法
  • 优化索引管理操作，提升应用性能
  • 避免因索引信息获取不当导致的资源浪费和潜在bug

Milvus索引管理基础

在深入探讨listIndexes方法之前，让我们先回顾一下Milvus中的索引管理基础知识。Milvus作为一款高性能向量数据库，索引管理是其核心功能之一，直接影响查询性能和资源消耗。

Milvus索引基本概念

索引（Index） 是一种数据结构，用于加速向量相似性搜索。在Milvus中，索引可以建立在向量字段上，通过预计算和存储向量的某种表示形式，显著减少查询时所需的计算量。

索引类型 是指构建索引所采用的算法和数据结构。Milvus支持多种索引类型，如FLAT、IVF_FLAT、IVF_SQ8、IVF_PQ、HNSW等，每种类型都有其适用场景和性能特点。

索引参数 是指构建索引时需要指定的配置选项，如IVF_FLAT中的nlist参数，HNSW中的M和efConstruction参数等。这些参数直接影响索引的构建时间、存储空间占用和查询性能。

索引管理主要操作

Milvus Java SDK提供了一套完整的索引管理API，主要包括：

  • createIndex: 为指定字段创建索引
  • describeIndex: 获取指定索引的详细信息
  • listIndexes: 列出集合中的索引
  • alterIndexProperties: 修改索引属性
  • dropIndex: 删除指定索引

其中，listIndexes方法看似简单，却常常在实际使用中引发困惑，特别是在涉及字段过滤时。

listIndexes方法原理解析

方法定义与参数

在Milvus Java SDK v2中，listIndexes方法定义如下：

public List<String> listIndexes(ListIndexesReq request) {
    return rpcUtils.retry(()->indexService.listIndexes(this.getRpcStub(), request));
}

该方法接受一个ListIndexesReq对象作为参数，并返回一个字符串列表，包含符合条件的索引名称。

ListIndexesReq类的主要参数包括：

  • collectionName: 集合名称（必填）
  • databaseName: 数据库名称（可选，默认为当前数据库）
  • fieldName: 字段名称（可选，用于过滤特定字段的索引）

内部实现逻辑

要理解listIndexes方法的行为，我们需要查看其在IndexService中的实现：

public List<String> listIndexes(MilvusServiceGrpc.MilvusServiceBlockingStub blockingStub, ListIndexesReq request) {
    String title = String.format("ListIndexesRequest collectionName:%s", request.getCollectionName());
    DescribeIndexRequest describeIndexRequest = DescribeIndexRequest.newBuilder()
            .setCollectionName(request.getCollectionName())
            .build();
    if (request.getFieldName() != null) {
        describeIndexRequest = describeIndexRequest.toBuilder()
                .setFieldName(request.getFieldName())
                .build();
    }
    DescribeIndexResponse response = blockingStub.describeIndex(describeIndexRequest);
    // 如果集合没有索引，返回空列表，而不是抛出异常
    if (response.getStatus().getErrorCode() == io.milvus.grpc.ErrorCode.IndexNotExist ||
            response.getStatus().getCode() == 700) {
        return new ArrayList<>();
    }
    rpcUtils.handleResponse(title, response.getStatus());

    return response.getIndexDescriptionsList().stream()
            .filter(desc -> request.getFieldName() == null || desc.getFieldName().equals(request.getFieldName()))
            .map(IndexDescription::getIndexName)
            .collect(Collectors.toList());
}

这段代码揭示了几个关键信息：

  1. listIndexes方法实际上是通过调用describeIndex接口实现的
  2. 它首先构建一个DescribeIndexRequest对象，并根据传入的参数设置集合名称和字段名称
  3. 调用blockingStub.describeIndex获取所有索引的详细描述
  4. 对返回的索引描述列表进行过滤，只保留与指定字段名匹配的索引
  5. 提取过滤后索引的名称，形成最终返回的列表

字段过滤逻辑分析

上述实现中的过滤逻辑是理解字段过滤行为的关键：

return response.getIndexDescriptionsList().stream()
        .filter(desc -> request.getFieldName() == null || desc.getFieldName().equals(request.getFieldName()))
        .map(IndexDescription::getIndexName)
        .collect(Collectors.toList());

这段代码的逻辑是：如果请求中指定了fieldName，则只保留那些字段名与请求中fieldName完全相等的索引描述；否则，返回所有索引描述。

这个逻辑看似合理，但在实际使用中可能会产生与预期不符的结果，主要原因有两点：

  1. 参数传递时机问题：fieldName参数既被设置到DescribeIndexRequest中，又在结果处理时再次用于过滤。这可能导致双重过滤，或者在某些情况下过滤逻辑不一致。

  2. 字段名匹配精确性：使用equals方法进行字段名匹配，要求完全精确匹配，不支持模糊匹配或部分匹配。

常见问题与陷阱分析

问题1：字段过滤失效

现象：当调用listIndexes方法并指定fieldName参数时，返回的索引列表仍然包含其他字段的索引，或者根本没有按预期过滤。

原因分析：

通过查看IndexService中的listIndexes实现，我们发现fieldName参数被用于两个地方：

  1. 设置到DescribeIndexRequest中：
if (request.getFieldName() != null) {
    describeIndexRequest = describeIndexRequest.toBuilder()
            .setFieldName(request.getFieldName())
            .build();
}
  1. 结果过滤时再次使用：
.filter(desc -> request.getFieldName() == null || desc.getFieldName().equals(request.getFieldName()))

这种双重使用可能导致不一致。如果Milvus服务器在处理DescribeIndexRequest时已经应用了fieldName过滤，那么客户端再次过滤可能是多余的；反之，如果服务器没有应用过滤，那么客户端过滤就是必要的。

更复杂的情况是，如果服务器和客户端对fieldName的处理方式不同（例如大小写敏感性），可能导致意外结果。

示例代码：

// 预期：只返回字段"vector_field"上的索引
List<String> indexes = milvusClient.listIndexes(ListIndexesReq.builder()
        .collectionName("my_collection")
        .fieldName("vector_field")
        .build());

如果服务器端API已经根据fieldName进行了过滤，那么客户端再次过滤就是多余的。但如果服务器端忽略了fieldName参数，只返回所有索引，那么客户端过滤就是正确的。这种不确定性可能导致用户困惑。

问题2：空字段名处理不当

现象：当传递空字符串或null作为fieldName参数时，行为不一致。

原因分析：

在Java中，null和空字符串是不同的，但在Milvus服务器API中，可能对这两种情况有不同的处理方式。在IndexService的实现中：

.setFieldName(request.getFieldName() == null ? "" : request.getFieldName())

这行代码将null转换为空字符串，但随后的过滤逻辑却使用：

.filter(desc -> request.getFieldName() == null || desc.getFieldName().equals(request.getFieldName()))

如果request.getFieldName()是null，那么过滤条件永远为true，返回所有索引；如果request.getFieldName()是空字符串，那么只返回那些字段名为空字符串的索引（这通常不是用户想要的）。

示例代码：

// 情况1：传递null，返回所有索引
List<String> indexes1 = milvusClient.listIndexes(ListIndexesReq.builder()
        .collectionName("my_collection")
        .fieldName(null)
        .build());

// 情况2：传递空字符串，可能返回空列表（如果没有字段名为空字符串的索引）
List<String> indexes2 = milvusClient.listIndexes(ListIndexesReq.builder()
        .collectionName("my_collection")
        .fieldName("")
        .build());

这种行为差异可能导致用户在不经意间传递了空字符串而非null时，得到意外的空结果。

问题3：索引名重复处理

现象：当不同字段上存在同名索引时，listIndexes返回的索引名称列表可能导致混淆。

原因分析：

listIndexes方法返回的是索引名称的列表，而不是包含字段信息的复杂对象。如果不同字段上存在同名索引，这个列表将包含重复的名称，无法区分它们属于哪个字段。

示例场景：

  • 在字段"vector_field1"上创建名为"ivf_index"的索引
  • 在字段"vector_field2"上创建名为"ivf_index"的索引
  • 调用listIndexes不指定fieldName，返回["ivf_index", "ivf_index"]

这种情况下，无法从返回结果中判断这两个同名索引分别属于哪个字段，可能导致后续操作（如删除索引）时误操作。

解决方案与最佳实践

针对上述问题，我们提出以下解决方案和最佳实践，帮助你正确、高效地使用listIndexes方法。

方案1：精确字段过滤实现

要确保字段过滤按预期工作，最可靠的方法是使用精确的字段名进行过滤，并在调用listIndexes之后，显式验证返回的索引是否确实属于目标字段。

推荐实现代码：

public List<String> listIndexesByField(MilvusClientV2 client, String collectionName, String fieldName) {
    // 调用listIndexes方法，指定字段名
    List<String> indexNames = client.listIndexes(ListIndexesReq.builder()
            .collectionName(collectionName)
            .fieldName(fieldName)
            .build());
    
    // 验证每个索引是否确实属于目标字段（额外检查）
    List<String> validatedIndexes = new ArrayList<>();
    for (String indexName : indexNames) {
        DescribeIndexResp indexInfo = client.describeIndex(DescribeIndexReq.builder()
                .collectionName(collectionName)
                .indexName(indexName)
                .build());
        
        // 检查索引描述中的字段名是否与目标字段名一致
        if (indexInfo.getIndexDescriptions() != null && !indexInfo.getIndexDescriptions().isEmpty()) {
            String actualFieldName = indexInfo.getIndexDescriptions().get(0).getFieldName();
            if (fieldName.equals(actualFieldName)) {
                validatedIndexes.add(indexName);
            }
        }
    }
    
    return validatedIndexes;
}

这个方法通过两步确保了过滤的准确性：

  1. 首先调用listIndexes方法，传入fieldName参数进行初步过滤
  2. 然后对每个返回的索引名，调用describeIndex方法获取详细信息，验证其字段名是否与目标字段名一致

虽然这个方法增加了额外的API调用，但大大提高了过滤的可靠性，特别适合在关键业务逻辑中使用。

方案2：索引名命名规范

为了避免不同字段上的索引名称冲突，我们强烈建议采用一套清晰的索引命名规范。一个好的命名规范应该能够从索引名称直接推断出其所属的字段和采用的索引类型。

推荐命名规范：

{field_name}_{index_type}_{major_parameters}

示例：

  • vector_field_ivfflat_nlist1024: 字段vector_field上的IVF_FLAT索引，nlist参数为1024
  • embedding_field_hnsw_m16_efc200: 字段embedding_field上的HNSW索引，M参数为16，efConstruction参数为200

采用这种命名规范的好处是：

  1. 即使不调用describeIndex，也能从索引名了解其基本信息
  2. 避免不同字段上的索引名称冲突
  3. 便于索引管理和维护
  4. 简化日志分析和问题排查

方案3：获取扩展索引信息

如果需要获取索引的详细信息（如所属字段、索引类型、参数等），而不仅仅是索引名称，可以实现一个扩展方法，结合listIndexes和describeIndex的功能。

实现代码：

public List<Map<String, Object>> listIndexesWithDetails(MilvusClientV2 client, String collectionName, String fieldName) {
    // 首先获取指定字段的所有索引名称
    List<String> indexNames = client.listIndexes(ListIndexesReq.builder()
            .collectionName(collectionName)
            .fieldName(fieldName)
            .build());
    
    // 为每个索引获取详细信息
    List<Map<String, Object>> indexDetails = new ArrayList<>();
    for (String indexName : indexNames) {
        DescribeIndexResp descResp = client.describeIndex(DescribeIndexReq.builder()
                .collectionName(collectionName)
                .indexName(indexName)
                .build());
        
        if (descResp.getIndexDescriptions() != null && !descResp.getIndexDescriptions().isEmpty()) {
            DescribeIndexResp.IndexDesc indexDesc = descResp.getIndexDescriptions().get(0);
            
            // 构建包含详细信息的Map
            Map<String, Object> details = new HashMap<>();
            details.put("indexName", indexName);
            details.put("fieldName", indexDesc.getFieldName());
            details.put("indexType", indexDesc.getIndexType());
            details.put("metricType", indexDesc.getMetricType());
            details.put("indexState", indexDesc.getIndexState());
            details.put("buildProgress", indexDesc.getBuildProgress());
            details.put("extraParams", indexDesc.getExtraParams());
            
            indexDetails.add(details);
        }
    }
    
    return indexDetails;
}

使用示例：

List<Map<String, Object>> indexes = listIndexesWithDetails(client, "my_collection", "vector_field");
for (Map<String, Object> index : indexes) {
    System.out.println("Index Name: " + index.get("indexName"));
    System.out.println("Field Name: " + index.get("fieldName"));
    System.out.println("Index Type: " + index.get("indexType"));
    System.out.println("Index State: " + index.get("indexState"));
    System.out.println("------------------------");
}

这个方法返回一个包含索引详细信息的列表，每个元素是一个Map，包含索引名称、字段名称、索引类型、状态等信息。这在需要进行复杂索引管理时非常有用。

完整解决方案：修正字段过滤行为

基于以上分析，我们可以实现一个修正版的字段过滤方法，解决原生listIndexes方法的不足。

修正实现

public class IndexUtils {
    
    /**
     * 列出指定集合中指定字段的所有索引，确保精确过滤
     * 
     * @param client MilvusClientV2实例
     * @param collectionName 集合名称
     * @param fieldName 字段名称，为null时返回所有字段的索引
     * @return 索引名称列表
     */
    public static List<String> listIndexesForField(MilvusClientV2 client, String collectionName, String fieldName) {
        // 参数验证
        if (client == null) {
            throw new IllegalArgumentException("MilvusClientV2 instance cannot be null");
        }
        if (StringUtils.isEmpty(collectionName)) {
            throw new IllegalArgumentException("Collection name cannot be empty");
        }
        
        // 构建请求
        ListIndexesReq.Builder reqBuilder = ListIndexesReq.builder().collectionName(collectionName);
        if (StringUtils.isNotEmpty(fieldName)) {
            reqBuilder.fieldName(fieldName);
        }
        
        // 获取索引名称列表
        List<String> indexNames = client.listIndexes(reqBuilder.build());
        
        // 验证每个索引的实际字段名，确保过滤正确
        List<String> filteredIndexes = new ArrayList<>();
        for (String indexName : indexNames) {
            DescribeIndexResp descResp = client.describeIndex(DescribeIndexReq.builder()
                    .collectionName(collectionName)
                    .indexName(indexName)
                    .build());
            
            if (descResp.getIndexDescriptions() != null && !descResp.getIndexDescriptions().isEmpty()) {
                String actualFieldName = descResp.getIndexDescriptions().get(0).getFieldName();
                
                // 检查实际字段名是否与目标字段名匹配
                if (fieldName == null || fieldName.equals(actualFieldName)) {
                    filteredIndexes.add(indexName);
                }
            }
        }
        
        return filteredIndexes;
    }
    
    /**
     * 获取指定集合中所有索引的详细信息
     * 
     * @param client MilvusClientV2实例
     * @param collectionName 集合名称
     * @return 包含索引详细信息的列表
     */
    public static List<IndexDetail> listAllIndexesWithDetails(MilvusClientV2 client, String collectionName) {
        // 参数验证
        if (client == null) {
            throw new IllegalArgumentException("MilvusClientV2 instance cannot be null");
        }
        if (StringUtils.isEmpty(collectionName)) {
            throw new IllegalArgumentException("Collection name cannot be empty");
        }
        
        // 获取所有索引名称
        List<String> indexNames = client.listIndexes(ListIndexesReq.builder()
                .collectionName(collectionName)
                .build());
        
        // 获取每个索引的详细信息
        List<IndexDetail> indexDetails = new ArrayList<>();
        for (String indexName : indexNames) {
            DescribeIndexResp descResp = client.describeIndex(DescribeIndexReq.builder()
                    .collectionName(collectionName)
                    .indexName(indexName)
                    .build());
            
            if (descResp.getIndexDescriptions() != null && !descResp.getIndexDescriptions().isEmpty()) {
                DescribeIndexResp.IndexDesc indexDesc = descResp.getIndexDescriptions().get(0);
                
                IndexDetail detail = new IndexDetail();
                detail.setIndexName(indexName);
                detail.setFieldName(indexDesc.getFieldName());
                detail.setIndexType(indexDesc.getIndexType());
                detail.setMetricType(indexDesc.getMetricType());
                detail.setIndexState(indexDesc.getIndexState());
                detail.setBuildProgress(indexDesc.getBuildProgress());
                detail.setExtraParams(indexDesc.getExtraParams());
                
                indexDetails.add(detail);
            }
        }
        
        return indexDetails;
    }
    
    // 索引详细信息POJO类
    public static class IndexDetail {
        private String indexName;
        private String fieldName;
        private String indexType;
        private String metricType;
        private String indexState;
        private float buildProgress;
        private Map<String, Object> extraParams;
        
        // getter和setter方法省略
    }
}

解决方案优势

  1. 精确过滤：通过双重验证确保只返回指定字段的索引，解决了原生方法可能出现的过滤失效问题。

  2. 详细信息获取：提供了获取索引详细信息的方法，满足复杂索引管理需求。

  3. 参数验证：增加了必要的参数验证，提前发现并抛出无效参数异常。

  4. 空安全处理：妥善处理null值和空字符串，避免意外行为。

  5. 易用性：封装为工具类，便于在项目中复用。

性能优化建议

批量操作优化

如果需要对多个集合或字段进行索引管理操作，建议批量执行，并合理设置批处理大小。

示例代码：

public Map<String, List<String>> batchListIndexesForFields(MilvusClientV2 client, Map<String, List<String>> collectionFields) {
    Map<String, List<String>> result = new HashMap<>();
    
    // 控制并发数量，避免 overwhelming Milvus 服务器
    ExecutorService executor = Executors.newFixedThreadPool(Math.min(collectionFields.size(), 10));
    CompletionService<Map.Entry<String, List<String>>> completionService = new ExecutorCompletionService<>(executor);
    
    // 提交任务
    for (Map.Entry<String, List<String>> entry : collectionFields.entrySet()) {
        String collection = entry.getKey();
        List<String> fields = entry.getValue();
        
        completionService.submit(() -> {
            Map<String, List<String>> collectionResult = new HashMap<>();
            for (String field : fields) {
                List<String> indexes = IndexUtils.listIndexesForField(client, collection, field);
                collectionResult.put(field, indexes);
            }
            return new AbstractMap.SimpleEntry<>(collection, collectionResult);
        });
    }
    
    // 获取结果
    for (int i = 0; i < collectionFields.size(); i++) {
        try {
            Map.Entry<String, Map<String, List<String>>> entry = completionService.take().get();
            result.put(entry.getKey(), entry.getValue());
        } catch (InterruptedException | ExecutionException e) {
            logger.error("Error in batch index listing", e);
        }
    }
    
    executor.shutdown();
    return result;
}

缓存策略

对于不频繁变化的索引信息，可以考虑实现缓存机制，减少对Milvus服务器的API调用次数。

实现思路：

  1. 使用Guava Cache或Caffeine等缓存库
  2. 设置合理的缓存过期时间（如5分钟）
  3. 在索引创建、删除或修改操作后主动清除相关缓存
  4. 缓存键使用"collectionName:fieldName"的格式

示例代码：

public class IndexCacheManager {
    private final LoadingCache<String, List<String>> indexCache;
    private final MilvusClientV2 client;
    
    public IndexCacheManager(MilvusClientV2 client) {
        this.client = client;
        this.indexCache = CacheBuilder.newBuilder()
                .maximumSize(1000)
                .expireAfterWrite(5, TimeUnit.MINUTES)
                .build(new CacheLoader<String, List<String>>() {
                    @Override
                    public List<String> load(String key) throws Exception {
                        String[] parts = key.split(":", 2);
                        String collection = parts[0];
                        String field = parts.length > 1 ? parts[1] : null;
                        return IndexUtils.listIndexesForField(client, collection, field);
                    }
                });
    }
    
    // 获取缓存的索引列表
    public List<String> getIndexes(String collection, String field) throws ExecutionException {
        String key = collection + ":" + (field != null ? field : "all");
        return indexCache.get(key);
    }
    
    // 清除指定集合的缓存
    public void invalidateCollection(String collection) {
        indexCache.asMap().keySet().stream()
                .filter(key -> key.startsWith(collection + ":"))
                .forEach(indexCache::invalidate);
    }
    
    // 完全清除缓存
    public void clearCache() {
        indexCache.invalidateAll();
    }
}

索引管理最佳实践总结

  1. 合理规划索引：只为频繁查询的向量字段创建索引，非向量字段通常不需要创建索引。

  2. 选择合适的索引类型：根据数据量、查询性能要求和资源限制选择合适的索引类型。小规模数据集可使用FLAT索引，大规模数据集可考虑IVF_FLAT或HNSW。

  3. 优化索引参数：通过实验确定最佳索引参数，如IVF_FLAT的nlist，HNSW的M和efConstruction等。

  4. 定期维护索引：监控索引状态，及时处理失败的索引，定期重建长时间运行的索引。

  5. 使用连接池：在高并发场景下，使用Milvus连接池管理客户端连接，避免频繁创建和销毁连接的开销。

  6. 监控与告警：监控索引构建进度和状态，设置合理的告警阈值，及时发现并处理索引问题。

总结与展望

本文深入剖析了Milvus Java SDK中listIndexes方法的字段过滤行为，揭示了其实现原理和潜在问题，并提供了经过验证的解决方案。我们了解到：

  • listIndexes方法通过调用describeIndex接口实现，并在客户端进行结果过滤
  • 字段过滤可能因参数传递方式和服务器处理逻辑的差异而失效
  • 通过双重验证、合理的索引命名规范和扩展信息获取，可以有效解决这些问题
  • 提供的IndexUtils工具类封装了最佳实践，可直接应用于项目中

随着Milvus的不断发展，未来的SDK版本可能会改进这些行为，提供更直观、更可靠的索引管理API。作为开发者，我们应该：

  1. 深入理解所使用工具的内部机制，而不仅仅停留在表面API调用
  2. 建立良好的开发规范，如索引命名规范，提高代码质量和可维护性
  3. 封装通用功能，形成内部工具库，提升开发效率和代码一致性
  4. 关注Milvus和Java SDK的更新，及时应用新特性和改进

通过本文介绍的方法和最佳实践，你应该能够避免listIndexes方法的常见陷阱，更高效地管理Milvus索引，从而构建性能更优的向量数据库应用。

最后，我们提供一个完整的索引管理工作流示例，整合了本文介绍的各种最佳实践：

public class IndexManagementWorkflow {
    private final MilvusClientV2 client;
    private final IndexCacheManager cacheManager;
    
    public IndexManagementWorkflow(ConnectConfig config) {
        this.client = new MilvusClientV2(config);
        this.cacheManager = new IndexCacheManager(this.client);
    }
    
    // 创建索引并更新缓存
    public void createAndCacheIndex(CreateIndexReq request) {
        client.createIndex(request);
        cacheManager.invalidateCollection(request.getCollectionName());
    }
    
    // 获取指定字段的索引，使用缓存优化性能
    public List<String> getIndexesWithCache(String collection, String field) throws ExecutionException {
        return cacheManager.getIndexes(collection, field);
    }
    
    // 删除索引并更新缓存
    public void deleteAndInvalidateIndex(DropIndexReq request) {
        client.dropIndex(request);
        cacheManager.invalidateCollection(request.getCollectionName());
    }
    
    // 打印索引详细信息
    public void printIndexDetails(String collection) {
        List<IndexUtils.IndexDetail> details = IndexUtils.listAllIndexesWithDetails(client, collection);
        
        System.out.println("Indexes in collection '" + collection + "':");
        System.out.println("------------------------------------------------");
        
        for (IndexUtils.IndexDetail detail : details) {
            System.out.println("Index Name: " + detail.getIndexName());
            System.out.println("Field Name: " + detail.getFieldName());
            System.out.println("Index Type: " + detail.getIndexType());
            System.out.println("Metric Type: " + detail.getMetricType());
            System.out.println("State: " + detail.getIndexState());
            System.out.println("Build Progress: " + detail.getBuildProgress() * 100 + "%");
            System.out.println("Parameters: " + detail.getExtraParams());
            System.out.println("------------------------------------------------");
        }
    }
}

这个工作流示例整合了索引创建、查询、删除和信息展示等功能，并结合了缓存机制提升性能，是一个在实际项目中可以参考的完整实现。

【免费下载链接】milvus-sdk-java Java SDK for Milvus. 【免费下载链接】milvus-sdk-java 项目地址: https://gitcode.com/gh_mirrors/mi/milvus-sdk-java

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值