Row 操作

更新时间：2026-09-01

插入记录

功能介绍

将一条或者一批记录插入到指定的表中。插入语义为Insert，若记录的主键已存在，则插入失败并报错。当插入一批时，该接口暂不支持批次的原子性。

请求示例

                Java
                
            

                import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.entity.Row;
import com.baidu.mochow.model.entity.RowField;
import com.baidu.mochow.model.InsertRequest;
import com.baidu.mochow.model.InsertResponse;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";
        
        List<Row> rows = new ArrayList<Row>();
        rows.add(Row.builder()
                    .addField(new RowField("id", "0001"))
                    .addField(new RowField("vector", Arrays.asList(1, 0.21, 0.213, 0)))
                    .addField(new RowField("bookName", "西游记"))
                    .addField(new RowField("author", "吴承恩"))
                    .addField(new RowField("page", 21))
                    .addField(new RowField("segment", "富贵功名，前缘分定，为人切莫欺心。")).build()
        );
        InsertRequest insertRequest = InsertRequest.builder().database(databaseName).table(tableName).rows(rows).build();
        InsertResponse insertResponse = mochowClient.insert(insertRequest);
        System.out.printf("Insert affected count:%d\n", insertResponse.getAffectedCount());
    }
}
            

成员名	类型	成员含义
fields	Map<String, Object>	存储一行数据，key为插入的字段名，value为值

方法	参数类型	返回值类型	功能
addField	RowField	无	为行增加一个字段值

成员名	类型	成员含义
name	String	字段名
value	String	值

成员名	类型	成员含义
affectedCount	int	插入请求影响的数据库行数

插入或更新记录

功能介绍

将一条或者一批记录插入到指定的表中。插入语义为Upsert（Insert or else Update），即，当记录的主键不存在时，则正常插入，若发现主键已存在，则用新的记录覆盖旧的记录。当插入一批时，该接口暂不支持批次的原子性。该接口可用于批量迁移/灌库等场景。

请求示例

                Python
                
            

                import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.entity.Row;
import com.baidu.mochow.model.entity.RowField;
import com.baidu.mochow.model.UpsertRequest;
import com.baidu.mochow.model.UpsertResponse;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";
        
        List<Row> rows = new ArrayList<Row>();
        rows.add(Row.builder()
                    .addField(new RowField("id", "0001"))
                    .addField(new RowField("vector", Arrays.asList(1, 0.21, 0.213, 0)))
                    .addField(new RowField("bookName", "西游记"))
                    .addField(new RowField("author", "吴承恩"))
                    .addField(new RowField("page", 21))
                    .addField(new RowField("segment", "富贵功名，前缘分定，为人切莫欺心。")).build()
        );
        UpsertRequest upsertRequest = UpsertRequest.builder().database(databaseName).table(tableName).rows(rows).build();
        UpsertResponse upsertResponse = mochowClient.upsert(upsertRequest);
        System.out.printf("Upsert affected count:%d\n", upsertResponse.getAffectedCount());
    }
}
            

成员名	类型	参数含义
fields	Map<String, Object>	存储一行数据，key为插入的字段名，value为值

方法	参数类型	返回值类型	功能
addField	RowField	无	为行增加一个字段值

成员名	类型	成员含义
name	String	字段名
value	String	值

成员名	类型	参数含义
affectedCount	int	插入或更新请求影响的数据库行数

更新记录

功能介绍

更新表中指定记录的一个或多个标量字段的值

请求示例

                Java
                
            

                public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";
        
        UpdateRequest updateRequest = UpdateRequest.builder()
                .database(databaseName)
                .table(tableName)
                .addPrimaryKey("id", "0001")
                .addUpdate("bookName", "红楼梦")
                .addUpdate("author", "曹雪芹")
                .addUpdate("page", 21)
                .addUpdate("segment", "满纸荒唐言，一把辛酸泪").build();
        mochowClient.update(updateRequest);
    }
}
            

方法	参数类型	返回值类型	功能
database	String	无	设置UpdateRequest的database
table	String	无	设置UpdateRequest的table
primaryKey	GeneralParams	无	设置UpdateRequest的primaryKey
addPrimaryKey	String, Object	无	为UpdateRequest增加一个primaryKey
partitionKey	GeneralParams	无	设置UpdateRequest的partitionKey
addPartitionKey	String, Object	无	为UpdateRequest增加一个partitionKey
update	GeneralParams	无	设置UpdateRequest的update
addUpdate	String, Object	无	为UpdateRequest增加一个update
build	无	UpdateRequest	返回一个构建好的UpdateRequest

删除记录

功能介绍

删除表中的指定记录。

请求示例

                Java
                
            

                import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.DeleteRequest;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";
        
        DeleteRequest deleteRequest = DeleteRequest.builder()
                .database(databaseName)
                .table(tableName)
                .addPrimaryKey("id", "0001")
                .build();
        mochowClient.delete(deleteRequest);
    }
}
            

成员名	类型	是否必选	参数含义
database	String	是	删除数据的库名
table	String	是	删除数据的表名
filter	String	否	删除的标量过滤条件。当要删除全部记录，可设置为"*"；Filter表达式语法参照SQL的WHERE子句语法进行设计，其详细描述和使用示例请参见Filter条件表达式。必须填写主键值或过滤条件，二者有且仅能选其一。
primaryKey	GeneralParams	否	指定记录的主键值。
partitionKey	GeneralParams	否	指定记录的分区键值。如果该表的分区键和主键是同一个键，则不需要填写分区键值。只有在有主键值的情况下，分区键值才会生效。

方法	参数类型	返回值类型	功能
database	String	无	设置DeleteRequest的database
table	String	无	设置DeleteRequest的table
primaryKey	GeneralParams	无	设置DeleteRequest的primaryKey
addPrimaryKey	String, Object	无	为DeleteRequest增加一个primaryKey
partitionKey	GeneralParams	无	设置DeleteRequest的partitionKey
addPartitionKey	String, Object	无	为DeleteRequest增加一个partitionKey
filter	GeneralParams	无	设置DeleteRequest的filter
build	无	DeleteRequest	返回一个构建好的DeleteRequest

标量查询

功能介绍

基于主键值进行点查。

请求示例

                Java
                
            

                import java.util.Arrays;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.QueryRequest;
import com.baidu.mochow.model.QueryResponse;
import com.baidu.mochow.model.enums.ReadConsistency;
import com.baidu.mochow.util.JsonUtils;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";
        
        QueryRequest queryRequest = QueryRequest.builder()
                .database(databaseName)
                .table(tableName)
                .retrieveVector(true)
                .addPrimaryKey("id", "0005")
                .readConsistency(ReadConsistency.STRONG)
                .vectorIndexMembership("vector_idx")
                .projections(Arrays.asList("id", "bookName")).build();
        QueryResponse queryResponse = mochowClient.query(queryRequest);
        System.out.printf("Query result: %s\n", JsonUtils.toJsonString(queryResponse.getRow()));
        System.out.printf("Vector index membership: %s\n",
                JsonUtils.toJsonString(queryResponse.getVectorIndexMembership()));
    }
}
            

成员名	类型	是否必选	成员说明
database	String	是	查询数据的库名
table	String	是	查询数据的表名
primaryKey	GeneralParams	是	指定记录的主键值。
projections	List<String>	否	投影字段列表，默认为空，为空时查询结果默认返回所有标量字段。
partitionKey	GeneralParams	否	指定记录的分区键值。如果该表的分区键和主键是同一个键，则不需要填写分区键值。
retrieveVector	Boolean	否	是否返回结果记录中的向量字段值，默认为False
readConsistency	ReadConsistency	否	查询请求的一致性级别，取值为： EVENTUAL（默认值）：最终一致性，查询请求会随机发送给分片的所有副本； STRONG：强一致性，查询请求只会发送给分片主副本。
vectorIndexMembership	VectorIndexMembership	否	查询目标记录相对于指定向量索引的当前逻辑覆盖状态。builder提供两个重载：传入索引名称（String）或直接传入VectorIndexMembership对象。该成员仅单条查询（query）支持。

成员名	类型	是否必选	成员说明
indexName	String	是	待检查的向量索引名称，必须为当前表中已存在的索引名。
state	String	否	请求中不需要填写，仅在响应中由服务端返回，取值如下： ROW_NOT_FOUND：未查询到该主键对应的记录 NO_VECTOR：记录存在，但索引字段对应的向量为空 KNN：记录的向量尚未进入任何向量索引，检索时走暴力计算 DELTA_INDEX：记录的向量已进入增量索引 STABLE_INDEX：记录的向量已进入全量（stable）索引

方法	参数类型	返回值类型	功能
database	String	无	设置QueryRequest的database
table	String	无	设置QueryRequest的table
primaryKey	GeneralParams	无	设置QueryRequest的primaryKey
addPrimaryKey	String, Object	无	为QueryRequest增加一个primaryKey
partitionKey	GeneralParams	无	设置QueryRequest的partitionKey
addPartitionKey	String, Object	无	为QueryRequest增加一个partitionKey
projections	List<String>	无	设置QueryRequest的projections
retrieveVector	Boolean	无	设置QueryRequest的retrieveVector
readConsistency	ReadConsistency	无	设置QueryRequest的readConsistency
vectorIndexMembership	String 或 VectorIndexMembership	无	设置QueryRequest的vectorIndexMembership
build	无	DeleteRequest	返回一个构建好的DeleteRequest

成员名	类型	成员说明
row	Row	查询到的行
vectorIndexMembership	VectorIndexMembership	目标记录相对于指定向量索引的逻辑覆盖状态，仅在请求中携带vectorIndexMembership时返回，服务端只返回其中的state

标量过滤查询

功能介绍

基于标量属性过滤查询记录。

请求示例

                Java
                
            

                import java.util.Arrays;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.SelectRequest;
import com.baidu.mochow.model.SelectResponse;
import com.baidu.mochow.model.enums.ReadConsistency;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";
        
        SelectRequest selectRequest = SelectRequest.builder()
                .database(databaseName)
                .table(tableName)
                .limit(30)
                .readConsistency(ReadConsistency.EVENTUAL)
                .projections(Arrays.asList("id", "bookName")).build();
        while (true) {
            SelectResponse selectResponse = mochowClient.select(selectRequest);
            System.out.printf("Select result count: %d\n", selectResponse.getRows().size());
            if (!selectResponse.isTruncated()) {
                break;
            }
            selectRequest.setMarker(selectResponse.getNextMarker());
        }
    }
}
            

成员名	类型	是否必选	用途
database	String	是	标量过滤数据的库名
table	String	是	标量过滤数据的表名
filter	String	否	标量过滤条件。当要删除全部记录，可设置为"*"；Filter表达式语法参照SQL的WHERE子句语法进行设计，其详细描述和使用示例请参见Filter条件表达式。必须填写主键值或过滤条件，二者有且仅能选其一。
projections	List<String>	否	投影字段列表，默认为空，为空时查询结果默认返回所有标量字段。
marker	GeneralParams	否	查询的分页起始点，用于控制分页查询返回结果的起始位置，方便用户对数据进行分页展示和浏览，用户不填时，默认从第一条符合条件的记录开始返回。
limit	int	否	查询返回的记录条数，在进行分页查询时，即每页的记录条数。默认为10，取值范围[1, 1000]。
readConsistency	ReadConsistency	否	查询请求的一致性级别，取值为： EVENTUAL（默认值）：最终一致性，查询请求会随机发送给分片的所有副本； STRONG：强一致性，查询请求只会发送给分片主副本。

方法	参数类型	返回值类型	功能
database	String	无	设置SelectRequest的database
table	String	无	设置SelectRequest的table
primaryKey	GeneralParams	无	设置SelectRequest的primaryKey
addPrimaryKey	String, Object	无	为SelectRequest增加一个primaryKey
partitionKey	GeneralParams	无	设置SelectRequest的partitionKey
addPartitionKey	String, Object	无	为SelectRequest增加一个partitionKey
projections	List<String>	无	设置SelectRequest的projections
retrieveVector	Boolean	无	设置SelectRequest的retrieveVector
readConsistency	ReadConsistency	无	设置SelectRequest的readConsistency
limit	int	无	设置SelectRequest的limit
build	无	SelectRequest	返回一个构建好的SelectRequest

成员名	类型	用途
truncated	Boolean	后续是否还有数据
nextMarker	GeneralParams	查询的分页起始点，用于控制分页查询返回结果的起始位置，方便用户对数据进行分页展示和浏览，用户不填时，默认从第一条符合条件的记录开始返回。
rows	List<Row>	插入的记录列表

向量检索

功能介绍

基于向量字段值的KNN或ANN查询，支持通过标量字段值进行过滤。

请求示例

                Java
                
            

                import java.util.Arrays;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.SearchRequest;
import com.baidu.mochow.model.SearchResponse;
import com.baidu.mochow.model.entity.ANNSearchParams;
import com.baidu.mochow.model.entity.HNSWSearchParams;
import com.baidu.mochow.util.JsonUtils;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";
        
        SearchRequest searchRequest = SearchRequest.builder()
                .database(databaseName)
                .table(tableName)
                .anns(
                        ANNSearchParams.builder()
                                .vectorField("vector")
                                .vectorFloats(Arrays.asList(1F, 0.21F, 0.213F, 0F))
                                .filter("bookName='三国演义'")
                                .params(HNSWSearchParams.builder().ef(200).limit(10).build()).build()
                ).build();
        SearchResponse searchResponse = mochowClient.search(searchRequest);
        System.out.printf("Search response: %s\n", JsonUtils.toJsonString(searchResponse));
    }
}
            

请求参数

SearchRequest

基于向量字段值的KNN或ANN支持通过标量字段值进行过滤。拥有constructor、getter、setter等通用方法，通用方法详情可以参考通用说明。其builder方法和通用的builder有区别，在下面有具体说明。

                Java
                
                import com.baidu.mochow.model.SearchRequest; //导入包

成员名	类型	是否必选	参数含义
database	String	是	插入数据的库名
table	String	是	插入数据的表名
anns	ANNSearchParams	无	检索请求参数详情。
retrieveVector	Boolean	否	是否返回结果记录中的向量字段值，默认为False
partitionKey	GeneralParams	否	指定记录的分区键值。如果该表的分区键和主键是同一个键，则不需要填写分区键值。
projections	List<String>	否	投影字段列表，默认为空，为空时查询结果默认返回所有标量字段。
readConsistency	ReadConsistency	否	查询请求的一致性级别，取值为： EVENTUAL（默认值）：最终一致性，查询请求会随机发送给分片的所有副本； STRONG：强一致性，查询请求只会发送给分片主副本。

可以使用SearchRequest.builder()获取SearchRequest的builder类，builder类拥有如下方法

方法	参数类型	返回值类型	功能
database	String	无	设置SearchRequest的database
table	String	无	设置SearchRequest的table
partitionKey	GeneralParams	无	设置SearchRequest的partitionKey
addPartitionKey	String, Object	无	为SearchRequest增加一个partitionKey
projections	List<String>	无	设置SearchRequest的projections
retrieveVector	Boolean	无	设置SearchRequest的retrieveVector
readConsistency	ReadConsistency	无	设置SearchRequest的readConsistency
anns	ANNSearchParams	无	设置SearchRequest的anns
build	无	SearchRequest	返回一个构建好的SearchRequest

ANNSearchParams

                Java
                
                import com.baidu.mochow.model.entity.ANNSearchParams; //导入包

成员名	类型	是否必选	参数含义
vectorField	String	是	检索的指定向量字段名称
vectorFloats	List<Float>	是	检索的目标向量字段值。
params	SearchParam	是	检索算法的参数详情。
filter	String	否	检索的标量过滤条件，表示仅在符合过滤条件的候选集中进行检索，默认为空。Filter表达式语法参照SQL的WHERE子句语法进行设计，其详细描述和使用示例请参见Filter条件表达式。

SearchParams

HNSWSearchParams

                Java
                
                import com.baidu.mochow.model.entity.HNSWSearchParams; //导入包

成员名	类型	是否必选	参数含义
ef	int	是	HNSW算法检索过程的动态候选列表的大小。
distanceNear	float	是	范围检索场景中的最近距离，表示仅检索候选集中与目标向量的距离大于该值的向量。取值约束同上。
distanceFar	distanceFar	否	范围检索场景中的最远距离，表示仅检索候选集中与目标向量的距离小于该值的向量。取值约束如下：任意距离算法下，distance_far都必须大于distance_near，不支持等于和小于；当索引距离为L2时，distance_far和distance_near仅支持正数；当索引距离为COSINE时，distance_far和distance_near的取值范围为[-1.0, 1.0]； distance_far与distance_ear需要成对出现。

PUCKSearchParams

                Java
                
                import com.baidu.mochow.model.entity.PUCKSearchParams; //导入包

成员名	类型	是否必选	参数含义
ef	int	是	HNSW算法检索过程的动态候选列表的大小。
distanceNear	float	是	范围检索场景中的最近距离，表示仅检索候选集中与目标向量的距离大于该值的向量。取值约束同上。
distanceFar	distanceFar	否	范围检索场景中的最远距离，表示仅检索候选集中与目标向量的距离小于该值的向量。取值约束如下：任意距离算法下，distance_far都必须大于distance_near，不支持等于和小于；当索引距离为L2时，distance_far和distance_near仅支持正数；当索引距离为COSINE时，distance_far和distance_near的取值范围为[-1.0, 1.0]； distance_far与distance_ear需要成对出现。

SearchResponse

插入或更新回复，向量数据库向客户端返回插入或更新请求的执行结果，拥有getter通用方法，通用方法可以参考通用说明。

                Java
                
                import com.baidu.mochow.model.SearchResponse; //导入包

成员名	类型	用途
searchVectorFloats	List	查询的向量
rows	List	查询结果行

批量向量检索

功能介绍

基于向量字段值的KNN或ANN批量查询，支持通过标量字段值进行过滤。

请求示例

                Java
                
            

                import java.util.Arrays;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.BatchSearchRequest;
import com.baidu.mochow.model.BatchSearchResponse;
import com.baidu.mochow.model.entity.BatchANNSearchParams;
import com.baidu.mochow.model.entity.HNSWSearchParams;
import com.baidu.mochow.util.JsonUtils;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";
        
        BatchSearchRequest searchRequest = BatchSearchRequest.builder()
                .database(databaseName)
                .table(tableName)
                .anns(
                        BatchANNSearchParams.builder()
                                .vectorField("vector")
                                .vectorFloats(Arrays.asList(Arrays.asList(1F, 0.21F, 0.213F, 0F)))
                                .filter("bookName='三国演义'")
                                .params(HNSWSearchParams.builder().ef(200).limit(10).build()).build()
                ).build();
        BatchSearchResponse searchResponse = mochowClient.batchSearch(searchRequest);
        System.out.printf("Search response: %s\n", JsonUtils.toJsonString(searchResponse));
    }
}
            

BatchSearchRequest

基于多个向量字段值的KNN或ANN检索操作，支持通过标量字段值进行过滤。仅适用于多节点标准版，不支持单节点免费测试版。拥有constructor、getter、setter等通用方法，通用方法详情可以参考通用说明。其builder方法和通用的builder有区别，在下面有具体说明。

                Java
                
                import com.baidu.mochow.model.BatchSearchRequest; //导入包

成员名	类型	是否必选	用途
database	String	是	检索数据的库名
table	String	是	检索数据的表名
anns	BatchANNSearchParams	无	检索请求参数详情。
retrieveVector	Boolean	否	是否返回结果记录中的向量字段值，默认为False
partitionKey	GeneralParams	否	指定记录的分区键值。如果该表的分区键和主键是同一个键，则不需要填写分区键值。
projections	List<String>	否	投影字段列表，默认为空，为空时查询结果默认返回所有标量字段。
readConsistency	ReadConsistency	否	查询请求的一致性级别，取值为： EVENTUAL（默认值）：最终一致性，查询请求会随机发送给分片的所有副本； STRONG：强一致性，查询请求只会发送给分片主副本。

可以使用BatchSearchRequest.builder()获取BatchSearchRequest的builder类，builder类拥有如下方法

方法	参数类型	返回值类型	功能
database	String	无	设置BatchSearchRequest的database
table	String	无	设置BatchSearchRequest的table
partitionKey	GeneralParams	无	设置BatchSearchRequest的partitionKey
addPartitionKey	String, Object	无	为BatchSearchRequest增加一个partitionKey
projections	List<String>	无	设置BatchSearchRequest的projections
retrieveVector	Boolean	无	设置BatchSearchRequest的retrieveVector
readConsistency	ReadConsistency	无	设置BatchSearchRequest的readConsistency
anns	ANNSearchParams	无	设置BatchSearchRequest的anns
build	无	BatchSearchRequest	返回一个构建好的BatchSearchRequest

BatchANNSearchParams

                Java
                
                import com.baidu.mochow.model.entity.ANNSearchParams; //导入包

成员名	类型	是否必选	参数含义
vectorField	String	是	检索的指定向量字段名称
vectorFloats	List<List<FloatVector>>	是	检索的目标向量字段值。
params	SearchParam	是	检索算法的参数详情。
filter	String	否	检索的标量过滤条件，表示仅在符合过滤条件的候选集中进行检索，默认为空。Filter表达式语法参照SQL的WHERE子句语法进行设计，其详细描述和使用示例请参见Filter条件表达式。

BatchSearchParams

HNSWSearchParams

                Java
                
                import com.baidu.mochow.model.entity.HNSWSearchParams; //导入包

成员名	类型	是否必选	参数含义
ef	int	是	HNSW算法检索过程的动态候选列表的大小。
distanceNear	float	是	范围检索场景中的最近距离，表示仅检索候选集中与目标向量的距离大于该值的向量。取值约束同上。
distanceFar	distanceFar	否	范围检索场景中的最远距离，表示仅检索候选集中与目标向量的距离小于该值的向量。取值约束如下：任意距离算法下，distance_far都必须大于distance_near，不支持等于和小于；当索引距离为L2时，distance_far和distance_near仅支持正数；当索引距离为COSINE时，distance_far和distance_near的取值范围为[-1.0, 1.0]； distance_far与distance_ear需要成对出现。

PUCKSearchParams

                Java
                
                import com.baidu.mochow.model.entity.PUCKSearchParams; //导入包

成员名	类型	是否必选	参数含义
ef	int	是	HNSW算法检索过程的动态候选列表的大小。
distanceNear	float	是	范围检索场景中的最近距离，表示仅检索候选集中与目标向量的距离大于该值的向量。取值约束同上。
distanceFar	distanceFar	否	范围检索场景中的最远距离，表示仅检索候选集中与目标向量的距离小于该值的向量。取值约束如下：任意距离算法下，distance_far都必须大于distance_near，不支持等于和小于；当索引距离为L2时，distance_far和distance_near仅支持正数；当索引距离为COSINE时，distance_far和distance_near的取值范围为[-1.0, 1.0]； distance_far与distance_ear需要成对出现。

BatchSearchResponse

插入或更新回复，向量数据库向客户端返回插入或更新请求的执行结果，拥有getter通用方法，通用方法可以参考通用说明。

                Java
                
                import com.baidu.mochow.model.BatchSearchResponse; //导入包

成员名	类型	用途
results	List<SearchResponse>	查询的结果

SearchResponse

插入或更新回复，向量数据库向客户端返回插入或更新请求的执行结果，拥有getter通用方法，通用方法可以参考通用说明。

                Java
                
                import com.baidu.mochow.model.SearchResponse; //导入包

成员名	类型	用途
searchVectorFloats	List	查询的向量
rows	List	查询结果行

多向量检索

功能介绍

基于多个单向量检索请求的融合查询，支持将多个向量检索结果按照不同的融合策略进行合并，支持通过标量字段值进行过滤和分页查询。

请求示例

                Java
                
            

                import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.MultiVectorSearchRequest;
import com.baidu.mochow.model.SearchRowResponse;
import com.baidu.mochow.model.SingleVectorSearchRequestInterface;
import com.baidu.mochow.model.VectorTopkSearchRequest;
import com.baidu.mochow.model.entity.FloatVector;
import com.baidu.mochow.model.entity.RRFRank;
import com.baidu.mochow.model.entity.WeightedRank;
import com.baidu.mochow.util.JsonUtils;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";

        // 创建多个单向量检索请求
        List<SingleVectorSearchRequestInterface> requests = new ArrayList<>();
        requests.add(VectorTopkSearchRequest.builder("vector",
                new FloatVector(Arrays.asList(1F, 0.21F, 0.213F, 0F)), 10).build());
        requests.add(VectorTopkSearchRequest.builder("vector",
                new FloatVector(Arrays.asList(0.8F, 0.15F, 0.25F, 0.1F)), 10).build());

        // 使用RRF融合策略构建多向量检索请求
        MultiVectorSearchRequest searchRequest = MultiVectorSearchRequest.builder(requests)
                .rankPolicy(new RRFRank(60))
                .limit(10)
                .filter("bookName='三国演义'")
                .projections(Arrays.asList("id", "bookName"))
                .build();

        // 执行检索
        SearchRowResponse searchResponse = mochowClient.vectorSearch(databaseName, tableName, searchRequest);
        System.out.printf("Multi-vector search response: %s\n", JsonUtils.toJsonString(searchResponse));
    }
}
            

请求参数

MultiVectorSearchRequest

基于多个单向量检索请求的融合查询，支持多种融合策略和标量过滤。拥有builder模式进行构建。

                Java
                
                import com.baidu.mochow.model.MultiVectorSearchRequest; //导入包

Builder方法	参数类型	是否必选	参数含义
builder	List<SingleVectorSearchRequestInterface>	是	构建多向量检索请求的静态方法，传入单向量检索请求列表
rankPolicy	FusionRankPolicy	否	融合策略，支持RRF和加权求和两种策略
limit	int	否	返回结果数量限制，默认为10
filter	String	否	标量过滤条件，Filter表达式语法参照SQL的WHERE子句语法
projections	List<String>	否	投影字段列表，默认为空时返回所有标量字段
partitionKey	GeneralParams	否	指定记录的分区键值
readConsistency	ReadConsistency	否	查询请求的一致性级别，默认为EVENTUAL
advancedOptions	AdvancedOptions	否	高级搜索选项
iteratedIds	String	否	分页查询的迭代ID，用于支持分页查询

FusionRankPolicy 融合策略接口

向量融合策略的基接口，具体实现类包括：

RRFRank (Reciprocal Rank Fusion)

倒数排名融合策略，基于多个检索结果的排名进行融合。

                Java
                
                import com.baidu.mochow.model.entity.RRFRank; //导入包

构造方法	参数类型	参数含义
RRFRank	int	融合参数k值，用于控制排名融合的权重，通常设置为60

WeightedRank

加权求和融合策略，基于多个检索结果的相似度分数按权重求和。

                Java
                
                import com.baidu.mochow.model.entity.WeightedRank; //导入包

构造方法	参数类型	参数含义
WeightedRank	List<Float>	权重列表，每个权重对应一个单向量检索请求，权重值范围通常为[0.0, 1.0]

VectorTopkSearchRequest

单向量检索请求，用于构建多向量检索的输入。

                Java
                
                import com.baidu.mochow.model.VectorTopkSearchRequest; //导入包

Builder方法	参数类型	是否必选	参数含义
builder	String, FloatVector, int	是	构建单向量检索请求的静态方法，参数分别为向量字段名、向量值、返回数量
config	VectorSearchConfig	否	检索算法的运行参数
filter	String	否	该单向量检索的过滤条件
projections	List<String>	否	投影字段列表
partitionKey	GeneralParams	否	指定记录的分区键值
readConsistency	ReadConsistency	否	查询请求的一致性级别，默认为EVENTUAL
advancedOptions	AdvancedOptions	否	高级搜索选项
iteratedIds	String	否	分页查询的迭代ID
decay	List<DecayFunction>	否	衰变排名器配置，返回的score为衰变后的最终得分，参数结构参见下文DecayFunction

SearchResultRow

检索结果中的单行记录。

                Java
                
                import com.baidu.mochow.model.entity.SearchResultRow; //导入包

成员名	类型	用途
row	Row	一行记录
distance	float	向量距离
score	float	记录得分。如请求携带decay，该值为衰变后的最终得分
highlight	Map<String, List<String>>	全文检索高亮片段，仅在BM25检索请求携带highlight时返回

SearchRowResponse

多向量检索回复，向量数据库向客户端返回检索请求的执行结果，拥有getter通用方法。

                Java
                
                import com.baidu.mochow.model.SearchRowResponse; //导入包

成员名	类型	用途
rows	List<SearchResultRow>	融合后的查询结果行列表
truncated	Boolean	后续是否还有数据
iteratedIds	String	分页查询的迭代ID，用于获取下一页结果

全文检索

功能介绍

基于关键字的全文检索（BM25），支持通过标量字段值进行过滤，支持请求级同义词、高亮和衰变排名器。

发起检索前，目标倒排索引的state必须为NORMAL；索引仍处于BUILDING状态时，检索会返回错误码95（Index Building）。

请求示例

                Java
                
            

                import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.BM25SearchRequest;
import com.baidu.mochow.model.SearchRowResponse;
import com.baidu.mochow.model.entity.DecayFunction;
import com.baidu.mochow.model.entity.HighlightParamField;
import com.baidu.mochow.model.entity.HighlightParams;
import com.baidu.mochow.util.JsonUtils;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";

        // 高亮配置：全局默认值 + 字段级配置
        HighlightParams highlight = new HighlightParams();
        highlight.setPreTags(Arrays.asList("<em>"));
        highlight.setPostTags(Arrays.asList("</em>"));
        highlight.setFragmentSize(100);
        highlight.setNumberOfFragments(3);
        Map<String, HighlightParamField> highlightFields = new HashMap<>();
        highlightFields.put("segment", new HighlightParamField(80, 2));
        highlight.setFields(highlightFields);

        // 衰变排名器：按 publishTime 做线性衰变
        DecayFunction publishTimeDecay = new DecayFunction();
        publishTimeDecay.setName("publish_time_decay");
        publishTimeDecay.setType("LINEAR");
        publishTimeDecay.setFieldName("publishTime");
        publishTimeDecay.setOrigin(1735660800L);
        publishTimeDecay.setScale(31536000L);
        publishTimeDecay.setWeight(0.3);

        BM25SearchRequest searchRequest = BM25SearchRequest.builder("segment_inverted_idx", "segment:吕布")
                .limit(10)
                .filter("bookName='三国演义'")
                .projections(Arrays.asList("id", "segment"))
                .synonyms(Arrays.asList(Arrays.asList("吕布", "奉先")))
                .highlight(highlight)
                .decay(Arrays.asList(publishTimeDecay))
                .build();

        SearchRowResponse searchResponse = mochowClient.bm25Search(databaseName, tableName, searchRequest);
        System.out.printf("BM25 search response: %s\n", JsonUtils.toJsonString(searchResponse.getRows()));
    }
}
            

请求参数

BM25SearchRequest

全文检索请求，通过builder模式构建。

                Java
                
                import com.baidu.mochow.model.BM25SearchRequest; //导入包

Builder方法	参数类型	是否必选	参数含义
builder	String, String	是	构建全文检索请求的静态方法，参数分别为倒排索引名称indexName和检索表达式searchText（UTF-8编码）
limit	int	否	指定返回相关性最高的条目数
filter	String	否	检索的标量过滤条件，表示仅在符合过滤条件的候选集中进行检索，默认为空。Filter表达式语法参照SQL的WHERE子句语法进行设计，其详细描述和使用示例请参见Filter条件表达式。
projections	List<String>	否	投影字段列表，默认为空，为空时检索结果返回所有标量字段
partitionKey	GeneralParams	否	指定记录的分区键值。如果没有指定分区键值，该检索请求可能会退化为在该表所有分片上都执行的MPP检索
readConsistency	ReadConsistency	否	检索请求的一致性级别，取值为： EVENTUAL（默认值）：最终一致性，查询请求会随机发送给分片的所有副本 STRONG：强一致性，查询请求只会发送给分片主副本
synonyms	List<List<String>>	否	请求级同义词规则，每个内部列表表示一组等价同义词，例如`Arrays.asList(Arrays.asList("土豆", "马铃薯"))`，检索“土豆”时可以匹配到“马铃薯”。使用说明：同义词仅支持单个term（大致等价于一个单词），超过该范围的同义词行为未定义内部列表包含0个或1个词时会被忽略；同义词为空字符串时请求失败每个同义词会使用indexName指定的倒排索引的分词器解析，包括分词、大小写归一化和停用词过滤；如某个成员被停用词完全消除，整个请求会失败，不会自动忽略该成员 synonyms只影响本次检索的解析与召回，不会写入索引，也不影响后续请求
highlight	HighlightParams	否	全文检索高亮配置。传入`new HighlightParams()`时使用默认配置；不传时不返回高亮信息。注：过宽的通配、前缀或范围查询（如PrefixQuery命中term数超过1024）可能导致请求失败，此时请调窄查询条件或关闭高亮。
decay	List<DecayFunction>	否	衰变排名器配置。配置后服务端会基于指定的数值或时间类型字段对原始相关性得分做衰变重排，返回的score为衰变后的最终得分。注：decay与advancedOptions中的两阶段检索不兼容。
iteratedIds	String	否	分页查询的迭代ID，通常由SearchIterator自动维护

检索表达式searchText的常见用法

检索类型	用法	例子	例子含义	备注
关键词检索	`field_name:keyword` `field_name:(keyword_1, keyword_2)`	`title:数据库` `title:(数据库百度)`	在title这列搜索“数据库”关键字在title这列搜索“数据库”、“百度”关键字，满足任意一个即可
关键词检索	`keyword` `keyword_1 AND keyword_2`	`数据库` `数据库 AND 百度`	在content这列上搜索“数据库”关键字在content这列上搜索，要求同时包括“数据库”、“百度”关键字	只适用于在单列上建立倒排索引的情况。对于多列倒排索引，必须使用`field_name:keyword`的方式指定检索词。
复合检索	`query_1 AND query_2` `query_1 OR query_2`	`title:数据库 AND title:百度` `title:数据库 OR title:百度`	在title这列搜索，要求同时包括这2个关键字在title这列搜索，要求包括任意一个
Phrase检索	`field_name:"phrase"`	`title:"百度VectorDB数据库"`	在title这列搜索“百度VectorDB数据库”短语	短语必须使用双引号
Match检索	`field_name:statement`	`content:百度VectorDB的优缺点`	在content这列搜索语句中的任意词，匹配词数量越多，相关性得分越高
Prefix检索	`field_name:keyword*`	`title:数据*`	在title这列检索，包含以“数据”为前缀词的文档
更改查询权重	`field_name:keyword^boost`	`title:数据库^2 OR content:百度`	title列匹配的文档权重系数为2，content列匹配的权重系数为1	不设置boost的话，默认权重都是1

全文检索表达式会将一些特殊字符用于专用目的，如想在表达式中匹配这些特殊字符，需要用\符号进行转义。当前被征用的特殊字符包括：

+ - && || ! ( ) { } [ ] ^ " ~ * ? : `

HighlightParams

全文检索高亮配置，拥有无参constructor以及getter、setter等通用方法。

                Java
                
                import com.baidu.mochow.model.entity.HighlightParams; //导入包

成员名	类型	是否必填	成员含义
fields	Map<String, HighlightParamField>	否	需要高亮的字段，key为字段名，value为字段级配置。字段必须属于indexName指定的倒排索引；不传时默认对该倒排索引覆盖的所有可高亮字段生成片段。
preTags	List<String>	否	命中词前置标记，默认为`["<em>"]`。支持配置多个tag，多个命中会按顺序轮转使用。
postTags	List<String>	否	命中词后置标记，默认为`["</em>"]`。同时显式配置preTags和postTags时，二者数量必须一致。
fragmentSize	Integer	否	高亮片段的目标长度，默认100，取值范围为[1, 2147483647]。字段级未设置时使用该值。
numberOfFragments	Integer	否	每个字段最多返回的片段数，默认3，取值范围为[0, 10000]。设置为0时不切片，返回完整字段的高亮结果。字段级未设置时使用该值。

HighlightParamField

字段级高亮配置。

                Java
                
                import com.baidu.mochow.model.entity.HighlightParamField; //导入包

                Java
                
                public HighlightParamField(Integer fragmentSize, Integer numberOfFragments)

成员名	类型	是否必填	成员含义
fragmentSize	Integer	否	当前字段每个高亮片段的目标长度，默认100，取值范围为[1, 2147483647]。该值为目标长度而非严格上限，为保留完整词语，实际片段长度可能存在差异，preTags和postTags也会增加返回字符串的长度。
numberOfFragments	Integer	否	当前字段最多返回的片段数，默认3，取值范围为[0, 10000]。设置为0时不切片，返回完整字段的高亮结果，此时fragmentSize不生效。

DecayFunction

衰变排名器配置，拥有无参、全参constructor以及getter、setter等通用方法。

                Java
                
                import com.baidu.mochow.model.entity.DecayFunction; //导入包

成员名	类型	是否必填	成员含义
type	String	是	衰变函数类型，取值为： LINEAR：线性衰变 EXPONENTIAL：指数衰变，需同时指定decayRate GAUSSIAN：高斯衰变
fieldName	String	是	参与衰变计算的字段名，需为表中已存在的数值或时间类型标量字段（BOOL、整数、FLOAT、DOUBLE、DATE、DATETIME、TIMESTAMP）。注：序列化后的JSON字段名为fieldName。
origin	Number	是	衰变的原点，字段值距离原点越远，衰变得分越低。
scale	Number	是	衰变的尺度，用于控制衰变速度，必须大于1e-6。
name	String	否	衰变函数名称，便于区分多个衰变函数，不参与得分计算。
decayRate	Number	否	指数衰变率，仅EXPONENTIAL类型生效且必填，取值必须大于0。值越大衰变越快，1.0为常用基准。
offset	Number	否	距离容忍区间，字段值与origin的距离在offset之内时不衰变，默认为0。
weight	Number	否	该衰变函数在最终得分中的权重，默认为1.0，多个衰变函数按权重加权平均。

注：decay为一个列表，每个元素表示一个独立的衰变函数，多个函数可以使用相同或不同的字段，不按列表顺序依次执行。origin、scale、offset必须与字段值使用相同单位。

返回参数

请求中携带highlight时，每条命中结果会额外返回highlight成员。

成员名	类型	成员含义
rows	List<SearchResultRow>	检索结果行列表
iteratedIds	String	分页查询的迭代ID

SearchResultRow成员

成员名	类型	成员含义
row	Row	一行记录
score	float	全文检索相关性得分。如请求携带decay，该值为衰变后的最终得分
highlight	Map<String, List<String>>	仅在请求携带highlight时返回，key为字段名，value为高亮片段数组，例如`{"segment": ["<em>吕布</em>字奉先"]}`。已请求高亮但当前行没有可返回片段时返回空对象

注：preTags和postTags会原样插入返回片段，服务端不做HTML转义；如需直接渲染为HTML，请自行处理转义与可信渲染策略。

混合检索

功能介绍

同时进行关键字全文检索和向量检索，检索结果融合排序后返回，也支持通过标量属性进行过滤。

请求示例

                Java
                
            

                import java.util.Arrays;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.BM25SearchRequest;
import com.baidu.mochow.model.HybridSearchRequest;
import com.baidu.mochow.model.SearchRowResponse;
import com.baidu.mochow.model.VectorTopkSearchRequest;
import com.baidu.mochow.model.entity.FloatVector;
import com.baidu.mochow.model.entity.VectorSearchConfig;
import com.baidu.mochow.util.JsonUtils;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";

        VectorTopkSearchRequest vectorRequest = VectorTopkSearchRequest.builder(
                        "vector", new FloatVector(Arrays.asList(1F, 0.21F, 0.213F, 0F)), 10)
                .config(VectorSearchConfig.builder().ef(200).build())
                .build();

        // BM25 的同义词与高亮在 bm25Request 中配置
        BM25SearchRequest bm25Request = BM25SearchRequest.builder("segment_inverted_idx", "segment:吕布")
                .synonyms(Arrays.asList(Arrays.asList("吕布", "奉先")))
                .build();

        HybridSearchRequest hybridSearchRequest = HybridSearchRequest.builder(
                        vectorRequest, bm25Request, 0.5F, 0.5F)
                .limit(10)
                .filter("bookName='三国演义'")
                .projections(Arrays.asList("id", "segment"))
                .build();

        SearchRowResponse searchResponse = mochowClient.hybridSearch(databaseName, tableName, hybridSearchRequest);
        System.out.printf("Hybrid search response: %s\n", JsonUtils.toJsonString(searchResponse.getRows()));
    }
}
            

请求参数

HybridSearchRequest

混合检索请求，通过builder模式构建。

                Java
                
                import com.baidu.mochow.model.HybridSearchRequest; //导入包

Builder方法	参数类型	是否必选	参数含义
builder	VectorSearchRequestInterface, BM25SearchRequestInterface, float, float	是	构建混合检索请求的静态方法，参数分别为向量检索请求、全文检索请求、向量检索权重vectorWeight、全文检索权重bm25Weight
limit	int	否	返回的最相关条目数
filter	String	否	检索的标量过滤条件，Filter表达式语法参照SQL的WHERE子句语法进行设计，其详细描述和使用示例请参见Filter条件表达式。
projections	List<String>	否	投影字段列表，默认为空，为空时检索结果返回所有标量字段
partitionKey	GeneralParams	否	指定记录的分区键值
readConsistency	ReadConsistency	否	检索请求的一致性级别，默认为EVENTUAL
decay	List<DecayFunction>	否	衰变排名器配置，作用于融合排序后的结果，返回的score为衰变后的最终得分。参数结构参见全文检索接口中的DecayFunction
iteratedIds	String	否	分页查询的迭代ID，通常由SearchIterator自动维护

注：混合检索中的BM25同义词（synonyms）和高亮（highlight）在bm25Request中配置；limit和filter为全局参数，会覆盖vectorRequest、bm25Request中的同名设置。

返回参数

与全文检索一致，返回SearchRowResponse，其中每条SearchResultRow的score为融合排序（以及可选的衰变重排）后的得分；如bm25Request中配置了highlight，还会返回highlight。

SearchIterator

功能介绍

SearchIterator提供了一种分页获取检索结果的机制。在SearchIterator请求中，limit参数用于指定当前分页的返回结果数量。通过多次调用迭代器，可以突破单次检索的topK数量限制，逐步获取完整的结果集。对于topK值较大的检索请求，推荐使用SearchIterator来实现结果的分批次获取。

请求示例

                Java
                
            

                import java.util.Arrays;
import java.util.List;

import com.baidu.mochow.auth.Credentials;
import com.baidu.mochow.client.ClientConfiguration;
import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.SearchIterator;
import com.baidu.mochow.model.SearchIteratorArgs;
import com.baidu.mochow.model.VectorTopkSearchRequest;
import com.baidu.mochow.model.entity.FloatVector;
import com.baidu.mochow.model.entity.SearchResultRow;
import com.baidu.mochow.model.entity.VectorSearchConfig;
import com.baidu.mochow.util.JsonUtils;

public class Main {
    public static void main(String[] args) {
        String account = "root";
        String apiKey = "*********";
        String endpoint = "*.*.*.*:*"; // example: 127.0.0.1:5287
        ClientConfiguration clientConfiguration = new ClientConfiguration();
                clientConfiguration.setCredentials(new Credentials(account, apiKey));
                clientConfiguration.setEndpoint(endpoint);
        MochowClient mochowClient = new MochowClient(clientConfiguration);
        String databaseName = "test";
        String tableName = "test";

        VectorTopkSearchRequest request = VectorTopkSearchRequest.builder(
                        "vector", new FloatVector(Arrays.asList(1F, 0.21F, 0.213F, 0F)), 1000)
                .config(VectorSearchConfig.builder().ef(2000).build())
                .build();

        SearchIteratorArgs iteratorArgs = new SearchIteratorArgs();
        iteratorArgs.database = databaseName;
        iteratorArgs.table = tableName;
        iteratorArgs.request = request;
        iteratorArgs.batchSize = 1000;
        iteratorArgs.totalSize = 10000;

        SearchIterator iterator = mochowClient.searchIterator(iteratorArgs); // 初始化 SearchIterator
        while (true) {
            List<SearchResultRow> rows = iterator.next(); // 获取下一批检索结果
            if (rows == null || rows.isEmpty()) {
                break;
            }
            System.out.printf("Iterator rows: %s\n", JsonUtils.toJsonString(rows));
        }
        iterator.close(); // 释放 iterator
    }
}
            

全文检索与混合检索同样支持SearchIterator，只需将iteratorArgs.request替换为BM25SearchRequest或HybridSearchRequest：

                Java
                
            

                import java.util.Arrays;
import java.util.List;

import com.baidu.mochow.client.MochowClient;
import com.baidu.mochow.model.BM25SearchRequest;
import com.baidu.mochow.model.SearchIterator;
import com.baidu.mochow.model.SearchIteratorArgs;
import com.baidu.mochow.model.entity.SearchResultRow;

// 省略 client 初始化，参见上文
BM25SearchRequest bm25Request = BM25SearchRequest.builder("segment_inverted_idx", "segment:吕布")
        .limit(10)
        .projections(Arrays.asList("id", "segment"))
        .build();

SearchIteratorArgs bm25Args = new SearchIteratorArgs();
bm25Args.database = "test";
bm25Args.table = "test";
bm25Args.request = bm25Request;
bm25Args.batchSize = 10;
bm25Args.totalSize = 100;

SearchIterator bm25Iterator = mochowClient.searchIterator(bm25Args);
while (true) {
    List<SearchResultRow> rows = bm25Iterator.next();
    if (rows == null || rows.isEmpty()) {
        break;
    }
}
bm25Iterator.close();
            

接口描述

MochowClient.searchIterator

功能：初始化SearchIterator对象。
参数：SearchIteratorArgs。
返回类型：SearchIterator。

SearchIteratorArgs

                Java
                
                import com.baidu.mochow.model.SearchIteratorArgs; //导入包

SearchIteratorArgs为公开成员的普通类，直接赋值即可。

成员名	类型	是否必填	成员含义
database	String	是	检索的库名
table	String	是	检索的表名
request	IterableSearchRequestInterface	是	检索请求，支持VectorTopkSearchRequest、MultiVectorSearchRequest、BM25SearchRequest、HybridSearchRequest
batchSize	int	是	每批次检索获取的记录条数，必须与request中的limit相等
totalSize	int	是	获取记录的总条数，不能小于batchSize

SearchIterator.next

功能：执行检索，并返回检索结果。当返回结果为空，说明SearchIterator执行结束。
参数：无。
返回类型：List<SearchResultRow>。

SearchIterator.close

功能：释放SearchIterator。执行close后，不应该再调用next。
参数：无。
返回类型：无。

限制

索引类型方面，仅支持HNSW、HNSWPQ、IVF、IVFSQ、IVFPQ（服务端还支持IVFRABITQ，Java SDK当前的IndexType枚举尚未包含该类型）。
检索类型方面，仅支持向量TopK检索（VectorTopkSearchRequest）、多向量检索（MultiVectorSearchRequest）、全文检索（BM25SearchRequest）、混合检索（HybridSearchRequest），不支持向量范围检索（VectorRangeSearchRequest）和批量向量检索（VectorBatchSearchRequest）。
对于多向量检索，仅支持ws（WeightedRank）融合排序算法。

评价此篇文章

有帮助没帮助

Alias 操作

Index 操作

向量数据库 VectorDB

Row 操作

插入记录

功能介绍

请求示例

相关类说明

InsertRequest

Row

RowField

InsertResponse

插入或更新记录

功能介绍

请求示例

相关类说明

UpsertRequest

Row

RowField

UpsertResponse

更新记录

功能介绍

请求示例

相关类说明

UpdateRequest

删除记录

功能介绍

请求示例

相关类说明

DeleteRequest

标量查询

功能介绍

请求示例

相关类说明

QueryRequest

VectorIndexMembership

QueryResponse

标量过滤查询

功能介绍

请求示例

相关类说明

SelectRequest

SelectResponse

向量检索

功能介绍

请求示例

请求参数

SearchRequest

ANNSearchParams

SearchParams

HNSWSearchParams

PUCKSearchParams

SearchResponse

批量向量检索

功能介绍

请求示例

BatchSearchRequest

BatchANNSearchParams

BatchSearchParams

HNSWSearchParams

PUCKSearchParams

BatchSearchResponse

SearchResponse

多向量检索

功能介绍

请求示例

请求参数

MultiVectorSearchRequest

FusionRankPolicy 融合策略接口

RRFRank (Reciprocal Rank Fusion)

WeightedRank

VectorTopkSearchRequest

SearchResultRow

SearchRowResponse

全文检索

功能介绍

请求示例

请求参数

BM25SearchRequest

HighlightParams

HighlightParamField

DecayFunction