admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-02-02 01:06:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix Java Test Format (#4110)

Browse Source 
Signed-off-by: sahuang <xiaohai.xu@zilliz.com>
This commit is contained in:
Xiaohai Xu 2020-10-28 10:00:21 +08:00 committed by GitHub
parent a97aa93166
commit fa667011fe
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 2693 additions and 2398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
tests/milvus-java-test/MilvusSDkJavaTest.iml
View File

@ -1,68 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_8">
<output url="file://$MODULE_DIR$/target/classes" />
<output-test url="file://$MODULE_DIR$/target/test-classes" />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
<excludeFolder url="file://$MODULE_DIR$/target" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-lang3:3.10" level="project" />
<orderEntry type="library" name="Maven: com.alibaba:fastjson:1.2.68" level="project" />
<orderEntry type="library" name="Maven: io.milvus:milvus-sdk-java:0.8.0-SNAPSHOT" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: io.grpc:grpc-netty-shaded:1.27.2" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: io.grpc:grpc-core:1.27.2" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-protobuf:1.27.2" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-api:1.27.2" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-context:1.27.2" level="project" />
<orderEntry type="library" name="Maven: com.google.protobuf:protobuf-java:3.11.0" level="project" />
<orderEntry type="library" name="Maven: com.google.guava:guava:28.1-android" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-protobuf-lite:1.27.2" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-stub:1.27.2" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-lang3:3.11" level="project" />
<orderEntry type="library" name="Maven: commons-cli:commons-cli:1.4" level="project" />
<orderEntry type="library" name="Maven: org.testng:testng:6.14.3" level="project" />
<orderEntry type="library" name="Maven: com.beust:jcommander:1.72" level="project" />
<orderEntry type="library" name="Maven: org.apache-extras.beanshell:bsh:2.0b6" level="project" />
<orderEntry type="library" name="Maven: com.alibaba:fastjson:1.2.73" level="project" />
<orderEntry type="library" name="Maven: junit:junit:4.13" level="project" />
<orderEntry type="library" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
<orderEntry type="library" name="Maven: io.milvus:milvus-sdk-java:0.9.0-SNAPSHOT" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-protobuf:1.30.2" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-api:1.30.2" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-context:1.30.2" level="project" />
<orderEntry type="library" name="Maven: com.google.code.findbugs:jsr305:3.0.2" level="project" />
<orderEntry type="library" name="Maven: com.google.protobuf:protobuf-java:3.12.0" level="project" />
<orderEntry type="library" name="Maven: com.google.api.grpc:proto-google-common-protos:1.17.0" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-protobuf-lite:1.30.2" level="project" />
<orderEntry type="library" name="Maven: com.google.guava:guava:28.2-android" level="project" />
<orderEntry type="library" name="Maven: com.google.guava:failureaccess:1.0.1" level="project" />
<orderEntry type="library" name="Maven: com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava" level="project" />
<orderEntry type="library" name="Maven: org.checkerframework:checker-compat-qual:2.5.5" level="project" />
<orderEntry type="library" name="Maven: com.google.j2objc:j2objc-annotations:1.3" level="project" />
<orderEntry type="library" name="Maven: com.google.errorprone:error_prone_annotations:2.3.4" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: org.codehaus.mojo:animal-sniffer-annotations:1.18" level="project" />
<orderEntry type="library" name="Maven: io.grpc:grpc-stub:1.30.2" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: io.grpc:grpc-netty-shaded:1.30.2" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: io.grpc:grpc-core:1.30.2" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.google.code.gson:gson:2.8.6" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: com.google.android:annotations:4.1.1.4" level="project" />
<orderEntry type="library" scope="RUNTIME" name="Maven: io.perfmark:perfmark-api:0.19.0" level="project" />
<orderEntry type="library" name="Maven: org.json:json:20190722" level="project" />
<orderEntry type="library" name="Maven: org.slf4j:slf4j-api:1.7.30" level="project" />
<orderEntry type="library" name="Maven: org.testcontainers:testcontainers:1.14.3" level="project" />
<orderEntry type="library" name="Maven: org.jetbrains:annotations:19.0.0" level="project" />
<orderEntry type="library" name="Maven: org.apache.commons:commons-compress:1.20" level="project" />
<orderEntry type="library" name="Maven: org.rnorth.duct-tape:duct-tape:1.0.8" level="project" />
<orderEntry type="library" name="Maven: org.rnorth.visible-assertions:visible-assertions:2.1.2" level="project" />
<orderEntry type="library" name="Maven: org.rnorth:tcp-unix-socket-proxy:1.0.2" level="project" />
<orderEntry type="library" name="Maven: com.kohlschutter.junixsocket:junixsocket-native-common:2.0.4" level="project" />
<orderEntry type="library" name="Maven: org.scijava:native-lib-loader:2.0.2" level="project" />
<orderEntry type="library" name="Maven: com.kohlschutter.junixsocket:junixsocket-common:2.0.4" level="project" />
<orderEntry type="library" name="Maven: net.java.dev.jna:jna-platform:5.5.0" level="project" />
<orderEntry type="library" name="Maven: net.java.dev.jna:jna:5.5.0" level="project" />
<orderEntry type="library" scope="TEST" name="Maven: org.slf4j:slf4j-simple:1.7.30" level="project" />
</component>
</module>

58
tests/milvus-java-test/src/main/java/com/Constants.java
View File

@ -2,63 +2,65 @@ package com;
import io.milvus.client.IndexType;
import io.milvus.client.MetricType;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.Map;
public final class Constants {
public static final int dimension = 128;
public static final int dimension = 128;
public static final int n_list = 128;
public static final int n_list = 128;
public static final int n_probe = 64;
public static final int n_probe = 64;
public static final int nq = 5;
public static final int nq = 5;
public static final int topk = 10;
public static final int topk = 10;
public static final int nb = 8000;
public static final int nb = 8000;
public static final double epsilon = 0.001;
public static final double epsilon = 0.001;
public static final int segmentRowLimit = 5000;
public static final int segmentRowLimit = 5000;
public static final String fieldNameKey = "name";
public static final String fieldNameKey = "name";
public static final String vectorType = "float";
public static final String vectorType = "float";
public static final String binaryVectorType = "binary";
public static final String binaryVectorType = "binary";
public static final MetricType defaultMetricType = MetricType.L2;
public static final MetricType defaultMetricType = MetricType.L2;
public static final IndexType indexType = IndexType.IVF_SQ8;
public static final IndexType indexType = IndexType.IVF_SQ8;
public static final IndexType defaultIndexType = IndexType.FLAT;
public static final IndexType defaultIndexType = IndexType.FLAT;
public static final IndexType defaultBinaryIndexType = IndexType.BIN_IVF_FLAT;
public static final IndexType defaultBinaryIndexType = IndexType.BIN_IVF_FLAT;
public static final MetricType defaultBinaryMetricType = MetricType.JACCARD;
public static final MetricType defaultBinaryMetricType = MetricType.JACCARD;
public static final String intFieldName = "int64";
public static final String intFieldName = "int64";
public static final String floatFieldName = "float";
public static final String floatFieldName = "float";
public static final String floatVectorFieldName = "float_vector";
public static final String floatVectorFieldName = "float_vector";
public static final String binaryVectorFieldName = "binary_vector";
public static final String binaryVectorFieldName = "binary_vector";
public static final List<List<Float>> vectors = Utils.genVectors(nb, dimension, true);
public static final List<List<Float>> vectors = Utils.genVectors(nb, dimension, true);
public static final List<ByteBuffer> vectorsBinary = Utils.genBinaryVectors(nb, dimension);
public static final List<ByteBuffer> vectorsBinary = Utils.genBinaryVectors(nb, dimension);
public static final Map<String, List> defaultEntities = Utils.genDefaultEntities(nb, vectors);
public static final Map<String, List> defaultEntities = Utils.genDefaultEntities(nb, vectors);
public static final Map<String, List> defaultBinaryEntities = Utils.genDefaultBinaryEntities(nb, vectorsBinary);
public static final Map<String, List> defaultBinaryEntities =
Utils.genDefaultBinaryEntities(nb, vectorsBinary);
public static final String searchParam = Utils.setSearchParam(defaultMetricType, vectors.subList(0, nq), topk, n_probe);
public static final String binarySearchParam = Utils.setBinarySearchParam(defaultBinaryMetricType, vectorsBinary.subList(0, nq), topk, n_probe);
public static final String searchParam =
Utils.setSearchParam(defaultMetricType, vectors.subList(0, nq), topk, n_probe);
public static final String binarySearchParam =
Utils.setBinarySearchParam(
defaultBinaryMetricType, vectorsBinary.subList(0, nq), topk, n_probe);
}

298
tests/milvus-java-test/src/main/java/com/MainClass.java
View File

@ -1,7 +1,18 @@
package com;
import io.milvus.client.*;
import org.apache.commons.cli.*;
import io.milvus.client.CollectionMapping;
import io.milvus.client.ConnectParam;
import io.milvus.client.DataType;
import io.milvus.client.JsonBuilder;
import io.milvus.client.MilvusClient;
import io.milvus.client.MilvusGrpcClient;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.lang3.RandomStringUtils;
import org.testng.TestNG;
import org.testng.annotations.DataProvider;
@ -9,159 +20,150 @@ import org.testng.xml.XmlClass;
import org.testng.xml.XmlSuite;
import org.testng.xml.XmlTest;
import java.util.ArrayList;
import java.util.List;
public class MainClass {
private static String HOST = "127.0.0.1";
// private static String HOST = "192.168.1.238";
private static int PORT = 19530;
private static final ConnectParam CONNECT_PARAM = new ConnectParam.Builder()
.withHost(HOST)
.withPort(PORT)
.build();
private static MilvusClient client;
private final int segmentRowCount = 5000;
private static String HOST = "127.0.0.1";
// private static String HOST = "192.168.1.238";
private static int PORT = 19530;
private static final ConnectParam CONNECT_PARAM =
new ConnectParam.Builder().withHost(HOST).withPort(PORT).build();
private static MilvusClient client;
private final int segmentRowCount = 5000;
public static String getHost() {
return MainClass.HOST;
public static String getHost() {
return MainClass.HOST;
}
public static void setHost(String host) {
MainClass.HOST = host;
}
public static int getPort() {
return MainClass.PORT;
}
public static void setPort(int port) {
MainClass.PORT = port;
}
@DataProvider(name = "DefaultConnectArgs")
public static Object[][] defaultConnectArgs() {
return new Object[][] {{HOST, PORT}};
}
public static void main(String[] args) {
CommandLineParser parser = new DefaultParser();
Options options = new Options();
options.addOption("h", "host", true, "milvus-server hostname/ip");
options.addOption("p", "port", true, "milvus-server port");
try {
CommandLine cmd = parser.parse(options, args);
String host = cmd.getOptionValue("host");
if (host != null) {
setHost(host);
}
String port = cmd.getOptionValue("port");
if (port != null) {
setPort(Integer.parseInt(port));
}
System.out.println("Host: " + host + ", Port: " + port);
} catch (ParseException exp) {
System.err.println("Parsing failed. Reason: " + exp.getMessage());
}
public static void setHost(String host) {
MainClass.HOST = host;
XmlSuite suite = new XmlSuite();
suite.setName("TmpSuite");
XmlTest test = new XmlTest(suite);
test.setName("TmpTest");
List<XmlClass> classes = new ArrayList<XmlClass>();
// classes.add(new XmlClass("com.TestPing"));
// classes.add(new XmlClass("com.TestInsertEntities"));
// classes.add(new XmlClass("com.TestConnect"));
// classes.add(new XmlClass("com.TestDeleteEntities"));
// classes.add(new XmlClass("com.TestIndex"));
// classes.add(new XmlClass("com.TestCompact"));
// classes.add(new XmlClass("com.TestSearchEntities"));
// classes.add(new XmlClass("com.TestCollection"));
// classes.add(new XmlClass("com.TestCollectionCount"));
// classes.add(new XmlClass("com.TestFlush"));
// classes.add(new XmlClass("com.TestPartition"));
// classes.add(new XmlClass("com.TestGetEntityByID"));
// classes.add(new XmlClass("com.TestCollectionInfo"));
// classes.add(new XmlClass("com.TestSearchByIds"));
classes.add(new XmlClass("com.TestBeforeAndAfter"));
test.setXmlClasses(classes);
List<XmlSuite> suites = new ArrayList<XmlSuite>();
suites.add(suite);
TestNG tng = new TestNG();
tng.setXmlSuites(suites);
tng.run();
}
@DataProvider(name = "ConnectInstance")
public Object[][] connectInstance() throws Exception {
ConnectParam connectParam = new ConnectParam.Builder().withHost(HOST).withPort(PORT).build();
client = new MilvusGrpcClient(connectParam).withLogging();
String collectionName = RandomStringUtils.randomAlphabetic(10);
return new Object[][] {{client, collectionName}};
}
@DataProvider(name = "DisConnectInstance")
public Object[][] disConnectInstance() {
// Generate connection instance
client = new MilvusGrpcClient(CONNECT_PARAM).withLogging();
client.close();
String collectionName = RandomStringUtils.randomAlphabetic(10);
return new Object[][] {{client, collectionName}};
}
private Object[][] genCollection(boolean isBinary, boolean autoId) throws Exception {
Object[][] collection;
String collectionName = Utils.genUniqueStr("collection");
// Generate connection instance
client = new MilvusGrpcClient(CONNECT_PARAM).withLogging();
CollectionMapping cm =
CollectionMapping.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64)
.addField(Constants.floatFieldName, DataType.FLOAT)
.setParamsInJson(
new JsonBuilder()
.param("segment_row_limit", segmentRowCount)
.param("auto_id", autoId)
.build());
if (isBinary) {
cm.addVectorField("binary_vector", DataType.VECTOR_BINARY, Constants.dimension);
} else {
cm.addVectorField("float_vector", DataType.VECTOR_FLOAT, Constants.dimension);
}
client.createCollection(cm);
collection = new Object[][] {{client, collectionName}};
return collection;
}
public static int getPort() {
return MainClass.PORT;
}
@DataProvider(name = "Collection")
public Object[][] provideCollection() throws Exception {
Object[][] collection = genCollection(false, true);
return collection;
}
public static void setPort(int port) {
MainClass.PORT = port;
}
@DataProvider(name = "IdCollection")
public Object[][] provideIdCollection() throws Exception {
Object[][] idCollection = genCollection(false, false);
return idCollection;
}
@DataProvider(name = "DefaultConnectArgs")
public static Object[][] defaultConnectArgs() {
return new Object[][]{{HOST, PORT}};
}
public static void main(String[] args) {
CommandLineParser parser = new DefaultParser();
Options options = new Options();
options.addOption("h", "host", true, "milvus-server hostname/ip");
options.addOption("p", "port", true, "milvus-server port");
try {
CommandLine cmd = parser.parse(options, args);
String host = cmd.getOptionValue("host");
if (host != null) {
setHost(host);
}
String port = cmd.getOptionValue("port");
if (port != null) {
setPort(Integer.parseInt(port));
}
System.out.println("Host: " + host + ", Port: " + port);
} catch (ParseException exp) {
System.err.println("Parsing failed. Reason: " + exp.getMessage());
}
XmlSuite suite = new XmlSuite();
suite.setName("TmpSuite");
XmlTest test = new XmlTest(suite);
test.setName("TmpTest");
List<XmlClass> classes = new ArrayList<XmlClass>();
// classes.add(new XmlClass("com.TestPing"));
// classes.add(new XmlClass("com.TestInsertEntities"));
// classes.add(new XmlClass("com.TestConnect"));
// classes.add(new XmlClass("com.TestDeleteEntities"));
// classes.add(new XmlClass("com.TestIndex"));
// classes.add(new XmlClass("com.TestCompact"));
// classes.add(new XmlClass("com.TestSearchEntities"));
// classes.add(new XmlClass("com.TestCollection"));
// classes.add(new XmlClass("com.TestCollectionCount"));
// classes.add(new XmlClass("com.TestFlush"));
// classes.add(new XmlClass("com.TestPartition"));
// classes.add(new XmlClass("com.TestGetEntityByID"));
// classes.add(new XmlClass("com.TestCollectionInfo"));
// classes.add(new XmlClass("com.TestSearchByIds"));
classes.add(new XmlClass("com.TestBeforeAndAfter"));
test.setXmlClasses(classes);
List<XmlSuite> suites = new ArrayList<XmlSuite>();
suites.add(suite);
TestNG tng = new TestNG();
tng.setXmlSuites(suites);
tng.run();
}
@DataProvider(name = "ConnectInstance")
public Object[][] connectInstance() throws Exception {
ConnectParam connectParam = new ConnectParam.Builder()
.withHost(HOST)
.withPort(PORT)
.build();
client = new MilvusGrpcClient(connectParam).withLogging();
String collectionName = RandomStringUtils.randomAlphabetic(10);
return new Object[][]{{client, collectionName}};
}
@DataProvider(name = "DisConnectInstance")
public Object[][] disConnectInstance() {
// Generate connection instance
client = new MilvusGrpcClient(CONNECT_PARAM).withLogging();
client.close();
String collectionName = RandomStringUtils.randomAlphabetic(10);
return new Object[][]{{client, collectionName}};
}
private Object[][] genCollection(boolean isBinary, boolean autoId) throws Exception {
Object[][] collection;
String collectionName = Utils.genUniqueStr("collection");
// Generate connection instance
client = new MilvusGrpcClient(CONNECT_PARAM).withLogging();
CollectionMapping cm = CollectionMapping
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64)
.addField(Constants.floatFieldName, DataType.FLOAT)
.setParamsInJson(new JsonBuilder()
.param("segment_row_limit", segmentRowCount)
.param("auto_id", autoId)
.build());
if (isBinary) {
cm.addVectorField("binary_vector", DataType.VECTOR_BINARY, Constants.dimension);
} else {
cm.addVectorField("float_vector", DataType.VECTOR_FLOAT, Constants.dimension);
}
client.createCollection(cm);
collection = new Object[][]{{client, collectionName}};
return collection;
}
@DataProvider(name = "Collection")
public Object[][] provideCollection() throws Exception {
Object[][] collection = genCollection(false, true);
return collection;
}
@DataProvider(name = "IdCollection")
public Object[][] provideIdCollection() throws Exception {
Object[][] idCollection = genCollection(false, false);
return idCollection;
}
@DataProvider(name = "BinaryCollection")
public Object[][] provideBinaryCollection() throws Exception {
Object[][] binaryCollection = genCollection(true, true);
return binaryCollection;
}
@DataProvider(name = "BinaryIdCollection")
public Object[][] provideBinaryIdCollection() throws Exception {
Object[][] binaryIdCollection = genCollection(true, false);
return binaryIdCollection;
}
@DataProvider(name = "BinaryCollection")
public Object[][] provideBinaryCollection() throws Exception {
Object[][] binaryCollection = genCollection(true, true);
return binaryCollection;
}
@DataProvider(name = "BinaryIdCollection")
public Object[][] provideBinaryIdCollection() throws Exception {
Object[][] binaryIdCollection = genCollection(true, false);
return binaryIdCollection;
}
}

289
tests/milvus-java-test/src/main/java/com/TestCollection.java
View File

@ -1,151 +1,178 @@
package com;
import com.alibaba.fastjson.JSONObject;
import io.milvus.client.*;
import io.milvus.client.CollectionMapping;
import io.milvus.client.DataType;
import io.milvus.client.JsonBuilder;
import io.milvus.client.MilvusClient;
import io.milvus.client.exception.ClientSideMilvusException;
import io.milvus.client.exception.ServerSideMilvusException;
import org.testng.Assert;
import org.testng.annotations.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.testng.Assert;
import org.testng.annotations.Test;
public class TestCollection {
String intFieldName = Constants.intFieldName;
String floatFieldName = Constants.floatFieldName;
String floatVectorFieldName = Constants.floatVectorFieldName;
Boolean autoId = true;
String intFieldName = Constants.intFieldName;
String floatFieldName = Constants.floatFieldName;
String floatVectorFieldName = Constants.floatVectorFieldName;
Boolean autoId = true;
// case-01
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testCreateCollection(MilvusClient client, String collectionName) {
// Generate connection instance
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true,false);
client.createCollection(cm);
Assert.assertEquals(client.hasCollection(collectionName), true);
// case-01
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testCreateCollection(MilvusClient client, String collectionName) {
// Generate connection instance
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false);
client.createCollection(cm);
Assert.assertEquals(client.hasCollection(collectionName), true);
}
// case-02
@Test(
dataProvider = "DisConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ClientSideMilvusException.class)
public void testCreateCollectionDisconnect(MilvusClient client, String collectionName) {
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false);
client.createCollection(cm);
}
// case-03
@Test(
dataProvider = "ConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testCreateCollectionRepeatably(MilvusClient client, String collectionName) {
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false);
client.createCollection(cm);
Assert.assertEquals(client.hasCollection(collectionName), true);
client.createCollection(cm);
}
// case-04
@Test(
dataProvider = "ConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testCreateCollectionWrongParams(MilvusClient client, String collectionName) {
Integer dim = 0;
CollectionMapping cm =
CollectionMapping.create(collectionName)
.addField(intFieldName, DataType.INT64)
.addField(floatFieldName, DataType.FLOAT)
.addVectorField(floatVectorFieldName, DataType.VECTOR_FLOAT, dim)
.setParamsInJson(
new JsonBuilder()
.param("segment_row_limit", Constants.segmentRowLimit)
.param("auto_id", autoId)
.build());
client.createCollection(cm);
}
// case-05
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testShowCollections(MilvusClient client, String collectionName) {
Integer collectionNum = 10;
List<String> originCollections = new ArrayList<>();
for (int i = 0; i < collectionNum; ++i) {
String collectionNameNew = collectionName + "_" + i;
originCollections.add(collectionNameNew);
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionNameNew, true, false);
client.createCollection(cm);
}
List<String> listCollections = client.listCollections();
originCollections.stream().forEach(listCollections::contains);
}
// case-02
@Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
public void testCreateCollectionDisconnect(MilvusClient client, String collectionName) {
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false);
client.createCollection(cm);
// case-06
@Test(
dataProvider = "DisConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ClientSideMilvusException.class)
public void testShowCollectionsWithoutConnect(MilvusClient client, String collectionName) {
client.listCollections();
}
// case-07
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDropCollection(MilvusClient client, String collectionName) {
client.dropCollection(collectionName);
Assert.assertEquals(client.hasCollection(collectionName), false);
// Thread.currentThread().sleep(1000);
List<String> collectionNames = client.listCollections();
Assert.assertFalse(collectionNames.contains(collectionName));
}
// case-08
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testDropCollectionNotExisted(MilvusClient client, String collectionName) {
client.dropCollection(collectionName + "_");
List<String> collectionNames = client.listCollections();
Assert.assertTrue(collectionNames.contains(collectionName));
}
// case-09
@Test(
dataProvider = "DisConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ClientSideMilvusException.class)
public void testDropCollectionWithoutConnect(MilvusClient client, String collectionName) {
client.dropCollection(collectionName);
}
// case-10
// TODO
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDescribeCollection(MilvusClient client, String collectionName) {
CollectionMapping info = client.getCollectionInfo(collectionName);
List<Map<String, Object>> fields = info.getFields();
System.out.println(fields);
int dim = 0;
for (Map<String, Object> field : fields) {
if (floatVectorFieldName.equals(field.get(Constants.fieldNameKey))) {
JSONObject jsonObject = JSONObject.parseObject(field.get("params").toString());
dim = jsonObject.getIntValue("dim");
}
continue;
}
JSONObject params = JSONObject.parseObject(info.getParamsInJson());
Assert.assertEquals(dim, Constants.dimension);
Assert.assertEquals(info.getCollectionName(), collectionName);
Assert.assertEquals(params.getIntValue("segment_row_limit"), Constants.segmentRowLimit);
}
// case-03
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testCreateCollectionRepeatably(MilvusClient client, String collectionName) {
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionName, true, false);
client.createCollection(cm);
Assert.assertEquals(client.hasCollection(collectionName), true);
client.createCollection(cm);
}
// case-11
@Test(
dataProvider = "DisConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ClientSideMilvusException.class)
public void testDescribeCollectionWithoutConnect(MilvusClient client, String collectionName) {
client.getCollectionInfo(collectionName);
}
// case-04
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testCreateCollectionWrongParams(MilvusClient client, String collectionName) {
Integer dim = 0;
CollectionMapping cm = CollectionMapping.create(collectionName)
.addField(intFieldName, DataType.INT64)
.addField(floatFieldName, DataType.FLOAT)
.addVectorField(floatVectorFieldName, DataType.VECTOR_FLOAT, dim)
.setParamsInJson(new JsonBuilder()
.param("segment_row_limit", Constants.segmentRowLimit)
.param("auto_id", autoId)
.build());
client.createCollection(cm);
}
// case-12
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testHasCollectionNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = collectionName + "_";
Assert.assertFalse(client.hasCollection(collectionNameNew));
}
// case-05
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testShowCollections(MilvusClient client, String collectionName) {
Integer collectionNum = 10;
List<String> originCollections = new ArrayList<>();
for (int i = 0; i < collectionNum; ++i) {
String collectionNameNew = collectionName+"_"+Integer.toString(i);
originCollections.add(collectionNameNew);
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionNameNew, true, false);
client.createCollection(cm);
}
List<String> listCollections = client.listCollections();
originCollections.stream().forEach(listCollections::contains);
}
// case-13
@Test(
dataProvider = "DisConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ClientSideMilvusException.class)
public void testHasCollectionWithoutConnect(MilvusClient client, String collectionName) {
client.hasCollection(collectionName);
}
// case-06
@Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
public void testShowCollectionsWithoutConnect(MilvusClient client, String collectionName) {
client.listCollections();
}
// case-07
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDropCollection(MilvusClient client, String collectionName) {
client.dropCollection(collectionName);
Assert.assertEquals(client.hasCollection(collectionName), false);
// Thread.currentThread().sleep(1000);
List<String> collectionNames = client.listCollections();
Assert.assertFalse(collectionNames.contains(collectionName));
}
// case-08
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testDropCollectionNotExisted(MilvusClient client, String collectionName) {
client.dropCollection(collectionName+"_");
List<String> collectionNames = client.listCollections();
Assert.assertTrue(collectionNames.contains(collectionName));
}
// case-09
@Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
public void testDropCollectionWithoutConnect(MilvusClient client, String collectionName) {
client.dropCollection(collectionName);
}
// case-10
// TODO
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDescribeCollection(MilvusClient client, String collectionName) {
CollectionMapping info = client.getCollectionInfo(collectionName);
List<Map<String,Object>> fields = info.getFields();
System.out.println(fields);
int dim = 0;
for(Map<String,Object> field: fields){
if (floatVectorFieldName.equals(field.get(Constants.fieldNameKey))) {
JSONObject jsonObject = JSONObject.parseObject(field.get("params").toString());
dim = jsonObject.getIntValue("dim");
}
continue;
}
JSONObject params = JSONObject.parseObject(info.getParamsInJson().toString());
Assert.assertEquals(dim, Constants.dimension);
Assert.assertEquals(info.getCollectionName(), collectionName);
Assert.assertEquals(params.getIntValue("segment_row_limit"), Constants.segmentRowLimit);
}
// case-11
@Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
public void testDescribeCollectionWithoutConnect(MilvusClient client, String collectionName) {
client.getCollectionInfo(collectionName);
}
// case-12
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testHasCollectionNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = collectionName+"_";
Assert.assertFalse(client.hasCollection(collectionNameNew));
}
// case-13
@Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
public void testHasCollectionWithoutConnect(MilvusClient client, String collectionName) {
client.hasCollection(collectionName);
}
// case-14
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testHasCollection(MilvusClient client, String collectionName) {
Assert.assertTrue(client.hasCollection(collectionName));
}
// case-14
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testHasCollection(MilvusClient client, String collectionName) {
Assert.assertTrue(client.hasCollection(collectionName));
}
}

118
tests/milvus-java-test/src/main/java/com/TestCollectionCount.java
View File

@ -1,72 +1,78 @@
package com;
import io.milvus.client.*;
import io.milvus.client.CollectionMapping;
import io.milvus.client.InsertParam;
import io.milvus.client.MilvusClient;
import io.milvus.client.exception.ClientSideMilvusException;
import io.milvus.client.exception.ServerSideMilvusException;
import java.util.List;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.util.List;
public class TestCollectionCount {
int nb = Constants.nb;
int nb = Constants.nb;
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCollectionCountNoVectors(MilvusClient client, String collectionName) {
Assert.assertEquals(client.countEntities(collectionName), 0);
}
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCollectionCountNoVectors(MilvusClient client, String collectionName) {
Assert.assertEquals(client.countEntities(collectionName), 0);
}
// case-02
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testCollectionCountCollectionNotExisted(MilvusClient client, String collectionName) {
client.countEntities(collectionName+"_");
}
// case-02
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testCollectionCountCollectionNotExisted(MilvusClient client, String collectionName) {
client.countEntities(collectionName + "_");
}
// case-03
@Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
public void testCollectionCountWithoutConnect(MilvusClient client, String collectionName) {
client.countEntities(collectionName);
}
// case-03
@Test(
dataProvider = "DisConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ClientSideMilvusException.class)
public void testCollectionCountWithoutConnect(MilvusClient client, String collectionName) {
client.countEntities(collectionName);
}
// case-04
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCollectionCount(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
// Insert returns a list of entity ids that you will be using (if you did not supply the yourself) to reference the entities you just inserted
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-04
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCollectionCount(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
// Insert returns a list of entity ids that you will be using (if you did not supply the
// yourself) to reference the entities you just inserted
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-05
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testCollectionCountBinary(MilvusClient client, String collectionName) {
// Add vectors
InsertParam insertParam = Utils.genBinaryInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-05
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testCollectionCountBinary(MilvusClient client, String collectionName) {
// Add vectors
InsertParam insertParam = Utils.genBinaryInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-06
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCollectionCountMultiCollections(MilvusClient client, String collectionName) {
Integer collectionNum = 10;
for (int i = 0; i < collectionNum; ++i) {
String collectionNameNew = collectionName + "_" + i;
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionNameNew, true, false);
client.createCollection(cm);
// Add vectors
InsertParam insertParam = Utils.genInsertParam(collectionNameNew);
List<Long> ids = client.insert(insertParam);
client.flush(collectionNameNew);
}
for (int i = 0; i < collectionNum; ++i) {
String collectionNameNew = collectionName + "_" + i;
Assert.assertEquals(client.countEntities(collectionNameNew), nb);
}
// case-06
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCollectionCountMultiCollections(MilvusClient client, String collectionName) {
Integer collectionNum = 10;
for (int i = 0; i < collectionNum; ++i) {
String collectionNameNew = collectionName + "_" + i;
CollectionMapping cm = Utils.genCreateCollectionMapping(collectionNameNew, true, false);
client.createCollection(cm);
// Add vectors
InsertParam insertParam = Utils.genInsertParam(collectionNameNew);
List<Long> ids = client.insert(insertParam);
client.flush(collectionNameNew);
}
for (int i = 0; i < collectionNum; ++i) {
String collectionNameNew = collectionName + "_" + i;
Assert.assertEquals(client.countEntities(collectionNameNew), nb);
}
}
}

109
tests/milvus-java-test/src/main/java/com/TestCollectionStats.java
View File

@ -1,62 +1,67 @@
package com;
import com.alibaba.fastjson.JSONObject;
import io.milvus.client.*;
import org.testng.annotations.Test;
import io.milvus.client.Index;
import io.milvus.client.IndexType;
import io.milvus.client.InsertParam;
import io.milvus.client.JsonBuilder;
import io.milvus.client.MetricType;
import io.milvus.client.MilvusClient;
import java.util.Collections;
import java.util.List;
import org.testng.annotations.Test;
public class TestCollectionStats {
int nb = Constants.nb;
int nb = Constants.nb;
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetEntityIdsAfterDeleteEntities(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> idsBefore = client.insert(insertParam);
client.flush(collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0)));
client.flush(collectionName);
String stats = client.getCollectionStats(collectionName);
JSONObject collectionStats = JSONObject.parseObject(stats);
int rowCount = collectionStats.getIntValue("row_count");
assert(rowCount == nb - 1);
}
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetEntityIdsAfterDeleteEntities(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> idsBefore = client.insert(insertParam);
client.flush(collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0)));
client.flush(collectionName);
String stats = client.getCollectionStats(collectionName);
JSONObject collectionStats = JSONObject.parseObject(stats);
int rowCount = collectionStats.getIntValue("row_count");
assert (rowCount == nb - 1);
}
// case-02
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetEntityIdsAfterDeleteEntitiesIndexed(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> idsBefore = client.insert(insertParam);
client.flush(collectionName);
Index index = Index
.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0)));
client.flush(collectionName);
String stats = client.getCollectionStats(collectionName);
JSONObject collectionStats = JSONObject.parseObject(stats);
int rowCount = collectionStats.getIntValue("row_count");
assert(rowCount == nb - 1);
}
// case-02
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetEntityIdsAfterDeleteEntitiesIndexed(
MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> idsBefore = client.insert(insertParam);
client.flush(collectionName);
Index index =
Index.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0)));
client.flush(collectionName);
String stats = client.getCollectionStats(collectionName);
JSONObject collectionStats = JSONObject.parseObject(stats);
int rowCount = collectionStats.getIntValue("row_count");
assert (rowCount == nb - 1);
}
// case-03
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testGetEntityIdsAfterDeleteEntitiesBinary(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genBinaryInsertParam(collectionName);
List<Long> idsBefore = client.insert(insertParam);
client.flush(collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0)));
client.flush(collectionName);
String stats = client.getCollectionStats(collectionName);
System.out.println(stats);
JSONObject collectionStats = JSONObject.parseObject(stats);
int rowCount = collectionStats.getIntValue("row_count");
assert(rowCount == nb - 1);
}
}
// case-03
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testGetEntityIdsAfterDeleteEntitiesBinary(
MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genBinaryInsertParam(collectionName);
List<Long> idsBefore = client.insert(insertParam);
client.flush(collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(idsBefore.get(0)));
client.flush(collectionName);
String stats = client.getCollectionStats(collectionName);
System.out.println(stats);
JSONObject collectionStats = JSONObject.parseObject(stats);
int rowCount = collectionStats.getIntValue("row_count");
assert (rowCount == nb - 1);
}
}

316
tests/milvus-java-test/src/main/java/com/TestCompact.java
View File

@ -1,165 +1,183 @@
package com;
import com.alibaba.fastjson.JSONObject;
import io.milvus.client.*;
import io.milvus.client.CollectionMapping;
import io.milvus.client.CompactParam;
import io.milvus.client.DataType;
import io.milvus.client.JsonBuilder;
import io.milvus.client.MilvusClient;
import io.milvus.client.exception.ServerSideMilvusException;
import java.util.List;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.util.List;
public class TestCompact {
int nb = Constants.nb;
int nb = Constants.nb;
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCompactAfterDelete(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
client.compact(CompactParam.create(collectionName));
String statsResponse = client.getCollectionStats(collectionName);
JSONObject jsonObject = JSONObject.parseObject(statsResponse);
Assert.assertEquals(jsonObject.getIntValue("data_size"), 0);
Assert.assertEquals(client.countEntities(collectionName), 0);
}
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCompactAfterDelete(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
client.compact(CompactParam.create(collectionName));
String statsResponse = client.getCollectionStats(collectionName);
JSONObject jsonObject = JSONObject.parseObject(statsResponse);
Assert.assertEquals(jsonObject.getIntValue("data_size"), 0);
Assert.assertEquals(client.countEntities(collectionName), 0);
}
// case-02
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testCompactAfterDeleteBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
client.compact(CompactParam.create(collectionName));
String stats = client.getCollectionStats(collectionName);
JSONObject jsonObject = JSONObject.parseObject(stats);
Assert.assertEquals(jsonObject.getIntValue("data_size"), 0);
Assert.assertEquals(client.countEntities(collectionName), 0);
}
// case-02
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testCompactAfterDeleteBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
client.compact(CompactParam.create(collectionName));
String stats = client.getCollectionStats(collectionName);
JSONObject jsonObject = JSONObject.parseObject(stats);
Assert.assertEquals(jsonObject.getIntValue("data_size"), 0);
Assert.assertEquals(client.countEntities(collectionName), 0);
}
// case-03
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testCompactNoCollection(MilvusClient client, String collectionName) {
String name = "";
client.compact(CompactParam.create(name));
}
// case-03
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testCompactNoCollection(MilvusClient client, String collectionName) {
String name = "";
client.compact(CompactParam.create(name));
}
// case-04
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCompactEmptyCollection(MilvusClient client, String collectionName) {
String stats = client.getCollectionStats(collectionName);
JSONObject jsonObject = JSONObject.parseObject(stats);
client.compact(CompactParam.create(collectionName));
int data_size = jsonObject.getIntValue("data_size");
Assert.assertEquals(0, data_size);
}
// case-04
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCompactEmptyCollection(MilvusClient client, String collectionName) {
String stats = client.getCollectionStats(collectionName);
JSONObject jsonObject = JSONObject.parseObject(stats);
client.compact(CompactParam.create(collectionName));
int data_size = jsonObject.getIntValue("data_size");
Assert.assertEquals(0, data_size);
}
// case-05
// TODO delete not correct
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCompactThresholdLessThanDeleted(MilvusClient client, String collectionName) {
int segmentRowLimit = nb+1000;
String collectionNameNew = collectionName+"_";
CollectionMapping cm = CollectionMapping.create(collectionNameNew)
.addField(Constants.intFieldName, DataType.INT64)
.addField(Constants.floatFieldName, DataType.FLOAT)
.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, Constants.dimension)
.setParamsInJson(new JsonBuilder()
.param("segment_row_limit", segmentRowLimit)
.param("auto_id", true)
.build());
client.createCollection(cm);
List<Long> ids = Utils.initData(client, collectionNameNew);
client.deleteEntityByID(collectionNameNew, ids.subList(0, nb / 4));
client.flush(collectionNameNew);
Assert.assertEquals(client.countEntities(collectionNameNew), nb - (nb / 4));
// before compact
String stats = client.getCollectionStats(collectionNameNew);
JSONObject segmentsBefore = (JSONObject)Utils.parseJsonArray(stats, "segments").get(0);
client.compact(CompactParam.create(collectionNameNew).setThreshold(0.9));
// after compact
String statsAfter = client.getCollectionStats(collectionNameNew);
JSONObject segmentsAfter = (JSONObject)Utils.parseJsonArray(statsAfter, "segments").get(0);
Assert.assertEquals(segmentsAfter.get("data_size"), segmentsBefore.get("data_size"));
}
// case-05
// TODO delete not correct
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCompactThresholdLessThanDeleted(MilvusClient client, String collectionName) {
int segmentRowLimit = nb + 1000;
String collectionNameNew = collectionName + "_";
CollectionMapping cm =
CollectionMapping.create(collectionNameNew)
.addField(Constants.intFieldName, DataType.INT64)
.addField(Constants.floatFieldName, DataType.FLOAT)
.addVectorField(
Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, Constants.dimension)
.setParamsInJson(
new JsonBuilder()
.param("segment_row_limit", segmentRowLimit)
.param("auto_id", true)
.build());
client.createCollection(cm);
List<Long> ids = Utils.initData(client, collectionNameNew);
client.deleteEntityByID(collectionNameNew, ids.subList(0, nb / 4));
client.flush(collectionNameNew);
Assert.assertEquals(client.countEntities(collectionNameNew), nb - (nb / 4));
// before compact
String stats = client.getCollectionStats(collectionNameNew);
JSONObject segmentsBefore = (JSONObject) Utils.parseJsonArray(stats, "segments").get(0);
client.compact(CompactParam.create(collectionNameNew).setThreshold(0.9));
// after compact
String statsAfter = client.getCollectionStats(collectionNameNew);
JSONObject segmentsAfter = (JSONObject) Utils.parseJsonArray(statsAfter, "segments").get(0);
Assert.assertEquals(segmentsAfter.get("data_size"), segmentsBefore.get("data_size"));
}
// case-06
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testCompactInvalidThreshold(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
client.compact(CompactParam.create(collectionName).setThreshold(-1.0));
}
// case-06
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testCompactInvalidThreshold(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
client.compact(CompactParam.create(collectionName).setThreshold(-1.0));
}
// // case-07, test CompactAsync callback
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void testCompactAsyncAfterDelete(MilvusClient client, String collectionName) {
// // define callback
// FutureCallback<Response> futureCallback = new FutureCallback<Response>() {
// @Override
// public void onSuccess(Response compactResponse) {
// assert(compactResponse != null);
// assert(compactResponse.ok());
//
// Response statsResponse = client.getCollectionStats(collectionName);
// assert(statsResponse.ok());
// JSONObject jsonObject = JSONObject.parseObject(statsResponse.getMessage());
// Assert.assertEquals(jsonObject.getIntValue("data_size"), 0);
// Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), 0);
// }
//
// @Override
// public void onFailure(Throwable t) {
// System.out.println(t.getMessage());
// Assert.assertTrue(false);
// }
// };
//
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFields(Constants.defaultEntities).build();
// InsertResponse res = client.insert(insertParam);
// assert(res.getResponse().ok());
// List<Long> ids = res.getEntityIds();
// client.flush(collectionName);
// Response res_delete = client.deleteEntityByID(collectionName, ids);
// assert(res_delete.ok());
// client.flush(collectionName);
// CompactParam compactParam = new CompactParam.Builder(collectionName).build();
//
// // call compactAsync
// ListenableFuture<Response> compactResponseFuture = client.compactAsync(compactParam);
// Futures.addCallback(compactResponseFuture, futureCallback, MoreExecutors.directExecutor());
//
// // execute before callback
// Response statsResponse = client.getCollectionStats(collectionName);
// assert(statsResponse.ok());
// JSONObject jsonObject = JSONObject.parseObject(statsResponse.getMessage());
// Assert.assertTrue(jsonObject.getIntValue("data_size") > 0);
// Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), 0);
// }
//
// // case-08, test CompactAsync callback with invalid collection name
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void testCompactAsyncNoCollection(MilvusClient client, String collectionName) {
// // define callback
// FutureCallback<Response> futureCallback = new FutureCallback<Response>() {
// @Override
// public void onSuccess(Response compactResponse) {
// assert(compactResponse != null);
// assert(!compactResponse.ok());
// }
//
// @Override
// public void onFailure(Throwable t) {
// System.out.println(t.getMessage());
// Assert.assertTrue(false);
// }
// };
//
// String name = "";
// CompactParam compactParam = new CompactParam.Builder(name).build();
//
// // call compactAsync
// ListenableFuture<Response> compactResponseFuture = client.compactAsync(compactParam);
// Futures.addCallback(compactResponseFuture, futureCallback, MoreExecutors.directExecutor());
// }
// // case-07, test CompactAsync callback
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void testCompactAsyncAfterDelete(MilvusClient client, String collectionName) {
// // define callback
// FutureCallback<Response> futureCallback = new FutureCallback<Response>() {
// @Override
// public void onSuccess(Response compactResponse) {
// assert(compactResponse != null);
// assert(compactResponse.ok());
//
// Response statsResponse = client.getCollectionStats(collectionName);
// assert(statsResponse.ok());
// JSONObject jsonObject = JSONObject.parseObject(statsResponse.getMessage());
// Assert.assertEquals(jsonObject.getIntValue("data_size"), 0);
//
// Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), 0);
// }
//
// @Override
// public void onFailure(Throwable t) {
// System.out.println(t.getMessage());
// Assert.assertTrue(false);
// }
// };
//
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFields(Constants.defaultEntities).build();
// InsertResponse res = client.insert(insertParam);
// assert(res.getResponse().ok());
// List<Long> ids = res.getEntityIds();
// client.flush(collectionName);
// Response res_delete = client.deleteEntityByID(collectionName, ids);
// assert(res_delete.ok());
// client.flush(collectionName);
// CompactParam compactParam = new CompactParam.Builder(collectionName).build();
//
// // call compactAsync
// ListenableFuture<Response> compactResponseFuture = client.compactAsync(compactParam);
// Futures.addCallback(compactResponseFuture, futureCallback,
// MoreExecutors.directExecutor());
//
// // execute before callback
// Response statsResponse = client.getCollectionStats(collectionName);
// assert(statsResponse.ok());
// JSONObject jsonObject = JSONObject.parseObject(statsResponse.getMessage());
// Assert.assertTrue(jsonObject.getIntValue("data_size") > 0);
// Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(),
// 0);
// }
//
// // case-08, test CompactAsync callback with invalid collection name
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void testCompactAsyncNoCollection(MilvusClient client, String collectionName) {
// // define callback
// FutureCallback<Response> futureCallback = new FutureCallback<Response>() {
// @Override
// public void onSuccess(Response compactResponse) {
// assert(compactResponse != null);
// assert(!compactResponse.ok());
// }
//
// @Override
// public void onFailure(Throwable t) {
// System.out.println(t.getMessage());
// Assert.assertTrue(false);
// }
// };
//
// String name = "";
// CompactParam compactParam = new CompactParam.Builder(name).build();
//
// // call compactAsync
// ListenableFuture<Response> compactResponseFuture = client.compactAsync(compactParam);
// Futures.addCallback(compactResponseFuture, futureCallback,
// MoreExecutors.directExecutor());
// }
}

105
tests/milvus-java-test/src/main/java/com/TestConnect.java
View File

@ -1,66 +1,65 @@
package com;
import io.milvus.client.ConnectParam;
import io.milvus.client.MilvusClient;
import io.milvus.client.MilvusGrpcClient;
import io.milvus.client.exception.ClientSideMilvusException;
import io.milvus.client.*;
import java.util.concurrent.TimeUnit;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import java.util.concurrent.TimeUnit;
public class TestConnect {
@Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
public void testConnect(String host, int port) throws Exception {
System.out.println("Host: "+host+", Port: "+port);
ConnectParam connectParam = new ConnectParam.Builder()
.withHost(host)
.withPort(port)
.build();
MilvusClient client = new MilvusGrpcClient(connectParam).withLogging();
}
@Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
public void testConnect(String host, int port) throws Exception {
System.out.println("Host: " + host + ", Port: " + port);
ConnectParam connectParam = new ConnectParam.Builder().withHost(host).withPort(port).build();
MilvusClient client = new MilvusGrpcClient(connectParam).withLogging();
}
@Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
public void testConnectRepeat(String host, int port) {
ConnectParam connectParam = new ConnectParam.Builder()
.withHost(host)
.withPort(port)
.build();
MilvusClient client = new MilvusGrpcClient(connectParam).withLogging();
MilvusClient client1 = new MilvusGrpcClient(connectParam).withLogging();
}
@Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
public void testConnectRepeat(String host, int port) {
ConnectParam connectParam = new ConnectParam.Builder().withHost(host).withPort(port).build();
MilvusClient client = new MilvusGrpcClient(connectParam).withLogging();
MilvusClient client1 = new MilvusGrpcClient(connectParam).withLogging();
}
// TODO timeout
@Test(dataProvider="InvalidConnectArgs", expectedExceptions = {ClientSideMilvusException.class, IllegalArgumentException.class})
public void testConnectInvalidConnectArgs(String ip, int port) {
ConnectParam connectParam = new ConnectParam.Builder()
.withHost(ip)
.withPort(port)
.withKeepAliveTimeout(1, TimeUnit.MILLISECONDS)
.build();
MilvusClient client = new MilvusGrpcClient(connectParam).withLogging();
}
// TODO timeout
@Test(
dataProvider = "InvalidConnectArgs",
expectedExceptions = {ClientSideMilvusException.class, IllegalArgumentException.class})
public void testConnectInvalidConnectArgs(String ip, int port) {
ConnectParam connectParam =
new ConnectParam.Builder()
.withHost(ip)
.withPort(port)
.withKeepAliveTimeout(1, TimeUnit.MILLISECONDS)
.build();
MilvusClient client = new MilvusGrpcClient(connectParam).withLogging();
}
@DataProvider(name="InvalidConnectArgs")
public Object[][] generateInvalidConnectArgs() {
int port = 19530;
return new Object[][]{
{"1.1.1.1", port},
{"255.255.0.0", port},
{"1.2.2", port},
{"中文", port},
{"www.baidu.com", 100000},
{"127.0.0.1", 100000},
{"www.baidu.com", 80},
};
}
@DataProvider(name = "InvalidConnectArgs")
public Object[][] generateInvalidConnectArgs() {
int port = 19530;
return new Object[][] {
{"1.1.1.1", port},
{"255.255.0.0", port},
{"1.2.2", port},
{"中文", port},
{"www.baidu.com", 100000},
{"127.0.0.1", 100000},
{"www.baidu.com", 80},
};
}
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testDisconnect(MilvusClient client, String collectionName){
client.close();
}
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testDisconnect(MilvusClient client, String collectionName) {
client.close();
}
// // TODO
// @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
// public void testDisconnectRepeatably(MilvusClient client, String collectionName){
// client.close();
// }
// // TODO
// @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class,
// expectedExceptions = ClientSideMilvusException.class)
// public void testDisconnectRepeatably(MilvusClient client, String collectionName){
// client.close();
// }
}

131
tests/milvus-java-test/src/main/java/com/TestDeleteEntities.java
View File

@ -1,80 +1,87 @@
package com;
import io.milvus.client.*;
import io.milvus.client.InsertParam;
import io.milvus.client.MilvusClient;
import io.milvus.client.exception.ServerSideMilvusException;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.LongStream;
import org.testng.Assert;
import org.testng.annotations.Test;
public class TestDeleteEntities {
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDeleteEntities(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(client.countEntities(collectionName), 0);
}
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDeleteEntities(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(client.countEntities(collectionName), 0);
}
// case-02
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDeleteSingleEntity(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(0)));
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(client.countEntities(collectionName), Constants.nb - 1);
// Assert getEntityByID
Map<Long, Map<String, Object>> resEntity = client.getEntityByID(collectionName, Collections.singletonList(ids.get(0)));
Assert.assertEquals(resEntity.size(), 0);
}
// case-02
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDeleteSingleEntity(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(0)));
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(client.countEntities(collectionName), Constants.nb - 1);
// Assert getEntityByID
Map<Long, Map<String, Object>> resEntity =
client.getEntityByID(collectionName, Collections.singletonList(ids.get(0)));
Assert.assertEquals(resEntity.size(), 0);
}
// case-03
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testDeleteEntitiesCollectionNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = Utils.genUniqueStr(collectionName);
client.deleteEntityByID(collectionNameNew, new ArrayList<Long>());
}
// case-03
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testDeleteEntitiesCollectionNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = Utils.genUniqueStr(collectionName);
client.deleteEntityByID(collectionNameNew, new ArrayList<Long>());
}
// case-04
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testDeleteEntitiesEmptyCollection(MilvusClient client, String collectionName) {
String collectionNameNew = Utils.genUniqueStr(collectionName);
List<Long> entityIds = LongStream.range(0, Constants.nb).boxed().collect(Collectors.toList());
client.deleteEntityByID(collectionNameNew, entityIds);
}
// case-04
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testDeleteEntitiesEmptyCollection(MilvusClient client, String collectionName) {
String collectionNameNew = Utils.genUniqueStr(collectionName);
List<Long> entityIds = LongStream.range(0, Constants.nb).boxed().collect(Collectors.toList());
client.deleteEntityByID(collectionNameNew, entityIds);
}
// case-05
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDeleteEntityIdNotExisted(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
List<Long> delIds = new ArrayList<Long>();
delIds.add(123456L);
delIds.add(1234561L);
client.deleteEntityByID(collectionName, delIds);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(client.countEntities(collectionName), Constants.nb);
}
// case-05
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDeleteEntityIdNotExisted(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
List<Long> delIds = new ArrayList<Long>();
delIds.add(123456L);
delIds.add(1234561L);
client.deleteEntityByID(collectionName, delIds);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(client.countEntities(collectionName), Constants.nb);
}
// case-06
// Below tests binary vectors
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testDeleteEntitiesBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(client.countEntities(collectionName), 0);
}
// case-06
// Below tests binary vectors
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testDeleteEntitiesBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
client.deleteEntityByID(collectionName, ids);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(client.countEntities(collectionName), 0);
}
}

170
tests/milvus-java-test/src/main/java/com/TestFlush.java
View File

@ -1,97 +1,105 @@
package com;
import io.milvus.client.*;
import io.milvus.client.CollectionMapping;
import io.milvus.client.DataType;
import io.milvus.client.InsertParam;
import io.milvus.client.JsonBuilder;
import io.milvus.client.MilvusClient;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.RandomStringUtils;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.List;
public class TestFlush {
int nb = Constants.nb;
int nb = Constants.nb;
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testFlushCollectionNotExisted(MilvusClient client, String collectionName) {
String newCollection = "not_existed";
try {
client.flush(newCollection);
} catch (Exception e) {
e.printStackTrace();
}
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testFlushCollectionNotExisted(MilvusClient client, String collectionName) {
String newCollection = "not_existed";
try {
client.flush(newCollection);
} catch (Exception e) {
e.printStackTrace();
}
}
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testFlushEmptyCollection(MilvusClient client, String collectionName) {
client.flush(collectionName);
}
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testFlushEmptyCollection(MilvusClient client, String collectionName) {
client.flush(collectionName);
}
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testAddCollectionsFlush(MilvusClient client, String collectionName) {
List<String> names = new ArrayList<>();
int collectionNum = 10;
for (int i = 0; i < collectionNum; i++) {
names.add(RandomStringUtils.randomAlphabetic(10));
CollectionMapping cm = CollectionMapping
.create(names.get(i))
.addField("int64", DataType.INT64)
.addField("float", DataType.FLOAT)
.addVectorField("float_vector", DataType.VECTOR_FLOAT, Constants.dimension)
.setParamsInJson(new JsonBuilder()
.param("segment_row_limit", Constants.segmentRowLimit)
.param("auto_id", true)
.build());
client.createCollection(cm);
InsertParam insertParam = Utils.genInsertParam(names.get(i));
client.insert(insertParam);
System.out.println("Table " + names.get(i) + " created.");
}
client.flush(names);
for (int i = 0; i < collectionNum; i++) {
// check row count
Assert.assertEquals(client.countEntities(names.get(i)), nb);
}
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
public void testAddCollectionsFlush(MilvusClient client, String collectionName) {
List<String> names = new ArrayList<>();
int collectionNum = 10;
for (int i = 0; i < collectionNum; i++) {
names.add(RandomStringUtils.randomAlphabetic(10));
CollectionMapping cm =
CollectionMapping.create(names.get(i))
.addField("int64", DataType.INT64)
.addField("float", DataType.FLOAT)
.addVectorField("float_vector", DataType.VECTOR_FLOAT, Constants.dimension)
.setParamsInJson(
new JsonBuilder()
.param("segment_row_limit", Constants.segmentRowLimit)
.param("auto_id", true)
.build());
client.createCollection(cm);
InsertParam insertParam = Utils.genInsertParam(names.get(i));
client.insert(insertParam);
System.out.println("Table " + names.get(i) + " created.");
}
client.flush(names);
for (int i = 0; i < collectionNum; i++) {
// check row count
Assert.assertEquals(client.countEntities(names.get(i)), nb);
}
}
// @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
// public void testAddCollectionsFlushAsync(MilvusClient client, String collectionName) throws ExecutionException, InterruptedException {
// List<String> names = new ArrayList<>();
// for (int i = 0; i < 100; i++) {
// names.add(RandomStringUtils.randomAlphabetic(10));
// CollectionMapping collectionSchema = new CollectionMapping.Builder(names.get(i))
// .withFields(Constants.defaultFields)
// .withParamsInJson(String.format("{\"segment_row_count\": %s}",segmentRowCount))
// .build();
// client.createCollection(collectionSchema);
// InsertParam insertParam = new InsertParam.Builder(names.get(i)).withFields(Constants.defaultEntities).build();
// client.insert(insertParam);
// System.out.println("Collection " + names.get(i) + " created.");
// }
// ListenableFuture<Response> flushResponseFuture = client.flushAsync(names);
// flushResponseFuture.get();
// for (int i = 0; i < 100; i++) {
// // check row count
// Assert.assertEquals(client.countEntities(names.get(i)).getCollectionEntityCount(), nb);
// }
// }
//
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testAddFlushMultipleTimes(MilvusClient client, String collectionName) {
for (int i = 0; i < 10; i++) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), nb * (i+1));
}
// @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
// public void testAddCollectionsFlushAsync(MilvusClient client, String collectionName)
// throws ExecutionException, InterruptedException {
// List<String> names = new ArrayList<>();
// for (int i = 0; i < 100; i++) {
// names.add(RandomStringUtils.randomAlphabetic(10));
// CollectionMapping collectionSchema = new CollectionMapping.Builder(names.get(i))
// .withFields(Constants.defaultFields)
// .withParamsInJson(String.format("{\"segment_row_count\":
// %s}",segmentRowCount))
// .build();
// client.createCollection(collectionSchema);
// InsertParam insertParam = new
// InsertParam.Builder(names.get(i)).withFields(Constants.defaultEntities).build();
// client.insert(insertParam);
// System.out.println("Collection " + names.get(i) + " created.");
// }
// ListenableFuture<Response> flushResponseFuture = client.flushAsync(names);
// flushResponseFuture.get();
// for (int i = 0; i < 100; i++) {
// // check row count
// Assert.assertEquals(client.countEntities(names.get(i)).getCollectionEntityCount(),
// nb);
// }
// }
//
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testAddFlushMultipleTimes(MilvusClient client, String collectionName) {
for (int i = 0; i < 10; i++) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), nb * (i + 1));
}
}
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testAddFlushMultipleTimesBinary(MilvusClient client, String collectionName) {
for (int i = 0; i < 10; i++) {
InsertParam insertParam = Utils.genBinaryInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), nb * (i+1));
}
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testAddFlushMultipleTimesBinary(MilvusClient client, String collectionName) {
for (int i = 0; i < 10; i++) {
InsertParam insertParam = Utils.genBinaryInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), nb * (i + 1));
}
}
}
}

164
tests/milvus-java-test/src/main/java/com/TestGetEntityByID.java
View File

@ -1,90 +1,106 @@
package com;
import io.milvus.client.*;
import io.milvus.client.DataType;
import io.milvus.client.InsertParam;
import io.milvus.client.MilvusClient;
import io.milvus.client.exception.ServerSideMilvusException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.nio.ByteBuffer;
import java.util.*;
public class TestGetEntityByID {
public List<Long> get_ids = Utils.toListIds(1111);
public List<Long> get_ids = Utils.toListIds(1111);
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetEntitiesByIdValid(MilvusClient client, String collectionName) {
int get_length = 100;
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(collectionName, ids.subList(0, get_length));
for (int i = 0; i < get_length; i++) {
Map<String,Object> fieldsMap = resEntities.get(ids.get(i));
assert (fieldsMap.get("float_vector").equals(Constants.vectors.get(i)));
}
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetEntitiesByIdValid(MilvusClient client, String collectionName) {
int get_length = 100;
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Map<Long, Map<String, Object>> resEntities =
client.getEntityByID(collectionName, ids.subList(0, get_length));
for (int i = 0; i < get_length; i++) {
Map<String, Object> fieldsMap = resEntities.get(ids.get(i));
assert (fieldsMap.get("float_vector").equals(Constants.vectors.get(i)));
}
}
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetEntityByIdAfterDelete(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(1)));
client.flush(collectionName);
List<Long> getIds = ids.subList(0,2);
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(collectionName, getIds);
Assert.assertEquals(resEntities.size(), getIds.size()-1);
Assert.assertEquals(resEntities.get(getIds.get(0)).get(Constants.floatVectorFieldName), Constants.vectors.get(0));
}
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetEntityByIdAfterDelete(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(1)));
client.flush(collectionName);
List<Long> getIds = ids.subList(0, 2);
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(collectionName, getIds);
Assert.assertEquals(resEntities.size(), getIds.size() - 1);
Assert.assertEquals(
resEntities.get(getIds.get(0)).get(Constants.floatVectorFieldName),
Constants.vectors.get(0));
}
@Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testGetEntityByIdCollectionNameNotExisted(MilvusClient client, String collectionName) {
String newCollection = "not_existed";
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(newCollection, get_ids);
}
@Test(
dataProvider = "ConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testGetEntityByIdCollectionNameNotExisted(
MilvusClient client, String collectionName) {
String newCollection = "not_existed";
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(newCollection, get_ids);
}
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetVectorIdNotExisted(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(collectionName, get_ids);
Assert.assertEquals(resEntities.size(), 0);
}
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testGetVectorIdNotExisted(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(collectionName, get_ids);
Assert.assertEquals(resEntities.size(), 0);
}
// Binary tests
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testGetEntityByIdValidBinary(MilvusClient client, String collectionName) {
int get_length = 20;
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
List<ByteBuffer> vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(collectionName, ids.subList(0, get_length));
for (int i = 0; i < get_length; i++) {
assert (resEntities.get(ids.get(i)).get(Constants.binaryVectorFieldName).equals(vectors.get(i)));
}
// Binary tests
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testGetEntityByIdValidBinary(MilvusClient client, String collectionName) {
int get_length = 20;
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
List<ByteBuffer> vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Map<Long, Map<String, Object>> resEntities =
client.getEntityByID(collectionName, ids.subList(0, get_length));
for (int i = 0; i < get_length; i++) {
assert (resEntities
.get(ids.get(i))
.get(Constants.binaryVectorFieldName)
.equals(vectors.get(i)));
}
}
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testGetEntityByIdAfterDeleteBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(0)));
client.flush(collectionName);
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(collectionName, ids.subList(0, 1));
Assert.assertEquals(resEntities.size(), 0);
}
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testGetEntityByIdAfterDeleteBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
client.deleteEntityByID(collectionName, Collections.singletonList(ids.get(0)));
client.flush(collectionName);
Map<Long, Map<String, Object>> resEntities =
client.getEntityByID(collectionName, ids.subList(0, 1));
Assert.assertEquals(resEntities.size(), 0);
}
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testGetEntityIdNotExistedBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(collectionName, get_ids);
Assert.assertEquals(resEntities.size(), 0);
}
}
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testGetEntityIdNotExistedBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
Map<Long, Map<String, Object>> resEntities = client.getEntityByID(collectionName, get_ids);
Assert.assertEquals(resEntities.size(), 0);
}
}

377
tests/milvus-java-test/src/main/java/com/TestIndex.java
View File

@ -2,197 +2,230 @@ package com;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import io.milvus.client.*;
import io.milvus.client.Index;
import io.milvus.client.IndexType;
import io.milvus.client.JsonBuilder;
import io.milvus.client.MetricType;
import io.milvus.client.MilvusClient;
import io.milvus.client.exception.ClientSideMilvusException;
import io.milvus.client.exception.ServerSideMilvusException;
import java.util.List;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.util.List;
public class TestIndex {
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCreateIndex(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
Index index = Index
.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
String stats = client.getCollectionStats(collectionName);
JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files");
filesJsonArray.stream().map(item-> (JSONObject)item).filter(item->item.containsKey("index_type")).forEach(file->
Assert.assertEquals(file.get("index_type"), Constants.indexType.toString()));
}
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCreateIndex(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
Index index =
Index.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
String stats = client.getCollectionStats(collectionName);
JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files");
filesJsonArray.stream()
.map(item -> (JSONObject) item)
.filter(item -> item.containsKey("index_type"))
.forEach(
file -> Assert.assertEquals(file.get("index_type"), Constants.indexType.toString()));
}
// case-02
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testCreateIndexBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
Index index = Index
.create(collectionName, Constants.binaryVectorFieldName)
.setIndexType(Constants.defaultBinaryIndexType)
.setMetricType(MetricType.JACCARD)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
String stats = client.getCollectionStats(collectionName);
JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files");
filesJsonArray.stream().map(item-> (JSONObject)item).filter(item->item.containsKey("index_type")).forEach(file->
Assert.assertEquals(file.get("index_type"), Constants.defaultBinaryIndexType.toString()));
}
// case-02
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testCreateIndexBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
Index index =
Index.create(collectionName, Constants.binaryVectorFieldName)
.setIndexType(Constants.defaultBinaryIndexType)
.setMetricType(MetricType.JACCARD)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
String stats = client.getCollectionStats(collectionName);
JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files");
filesJsonArray.stream()
.map(item -> (JSONObject) item)
.filter(item -> item.containsKey("index_type"))
.forEach(
file ->
Assert.assertEquals(
file.get("index_type"), Constants.defaultBinaryIndexType.toString()));
}
// case-03
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCreateIndexRepeatably(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
Index index = Index
.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
client.createIndex(index);
}
// case-03
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCreateIndexRepeatably(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
Index index =
Index.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
client.createIndex(index);
}
// case-04
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCreateIndexWithNoVector(MilvusClient client, String collectionName) {
Index index = Index
.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
}
// case-04
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCreateIndexWithNoVector(MilvusClient client, String collectionName) {
Index index =
Index.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
}
// case-05
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testCreateIndexTableNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = Utils.genUniqueStr(collectionName);
Index index = Index
.create(collectionNameNew, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
}
// case-05
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testCreateIndexTableNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = Utils.genUniqueStr(collectionName);
Index index =
Index.create(collectionNameNew, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
}
// case-06
@Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
public void testCreateIndexWithoutConnect(MilvusClient client, String collectionName) {
Index index = Index
.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
}
// case-06
@Test(
dataProvider = "DisConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ClientSideMilvusException.class)
public void testCreateIndexWithoutConnect(MilvusClient client, String collectionName) {
Index index =
Index.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
}
// case-07
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testCreateIndexInvalidNList(MilvusClient client, String collectionName) {
int n_list = 0;
Index index = Index
.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", n_list).build());
client.createIndex(index);
}
// case-07
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testCreateIndexInvalidNList(MilvusClient client, String collectionName) {
int n_list = 0;
Index index =
Index.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(IndexType.IVF_SQ8)
.setMetricType(MetricType.L2)
.setParamsInJson(new JsonBuilder().param("nlist", n_list).build());
client.createIndex(index);
}
// #3407
// case-08
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testCreateIndexInvalidMetricTypeBinary(MilvusClient client, String collectionName) {
MetricType metric_type = MetricType.L2;
List<Long> ids = Utils.initBinaryData(client, collectionName);
Index index = Index
.create(collectionName, Constants.binaryVectorFieldName)
.setIndexType(IndexType.BIN_IVF_FLAT)
.setMetricType(metric_type)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
}
// #3407
// case-08
@Test(
dataProvider = "BinaryCollection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testCreateIndexInvalidMetricTypeBinary(MilvusClient client, String collectionName) {
MetricType metric_type = MetricType.L2;
List<Long> ids = Utils.initBinaryData(client, collectionName);
Index index =
Index.create(collectionName, Constants.binaryVectorFieldName)
.setIndexType(IndexType.BIN_IVF_FLAT)
.setMetricType(metric_type)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
}
// #3408
// case-09
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDropIndex(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
Index index = Index
.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(Constants.indexType)
.setMetricType(Constants.defaultMetricType)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
client.dropIndex(collectionName, Constants.floatVectorFieldName);
String stats = client.getCollectionStats(collectionName);
JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files");
for (Object item : filesJsonArray) {
JSONObject file = (JSONObject) item;
Assert.assertFalse(file.containsKey("index_type"));
}
// #3408
// case-09
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDropIndex(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initData(client, collectionName);
Index index =
Index.create(collectionName, Constants.floatVectorFieldName)
.setIndexType(Constants.indexType)
.setMetricType(Constants.defaultMetricType)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
client.dropIndex(collectionName, Constants.floatVectorFieldName);
String stats = client.getCollectionStats(collectionName);
JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files");
for (Object item : filesJsonArray) {
JSONObject file = (JSONObject) item;
Assert.assertFalse(file.containsKey("index_type"));
}
}
// case-10
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testDropIndexBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
Index index = Index
.create(collectionName, Constants.binaryVectorFieldName)
.setIndexType(Constants.defaultBinaryIndexType)
.setMetricType(Constants.defaultBinaryMetricType)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
client.dropIndex(collectionName, Constants.binaryVectorFieldName);
String stats = client.getCollectionStats(collectionName);
JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files");
for (Object item : filesJsonArray) {
JSONObject file = (JSONObject) item;
Assert.assertFalse(file.containsKey("index_type"));
}
// case-10
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testDropIndexBinary(MilvusClient client, String collectionName) {
List<Long> ids = Utils.initBinaryData(client, collectionName);
Index index =
Index.create(collectionName, Constants.binaryVectorFieldName)
.setIndexType(Constants.defaultBinaryIndexType)
.setMetricType(Constants.defaultBinaryMetricType)
.setParamsInJson(new JsonBuilder().param("nlist", Constants.n_list).build());
client.createIndex(index);
client.dropIndex(collectionName, Constants.binaryVectorFieldName);
String stats = client.getCollectionStats(collectionName);
JSONArray filesJsonArray = Utils.parseJsonArray(stats, "files");
for (Object item : filesJsonArray) {
JSONObject file = (JSONObject) item;
Assert.assertFalse(file.containsKey("index_type"));
}
}
// case-11
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testDropIndexCollectionNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = Utils.genUniqueStr(collectionName);
client.dropIndex(collectionNameNew, Constants.floatVectorFieldName);
}
// case-11
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testDropIndexCollectionNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = Utils.genUniqueStr(collectionName);
client.dropIndex(collectionNameNew, Constants.floatVectorFieldName);
}
// case-12
@Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
public void testDropIndexWithoutConnect(MilvusClient client, String collectionName) {
client.dropIndex(collectionName, Constants.floatVectorFieldName);
}
//
// // case-13
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void testAsyncIndex(MilvusClient client, String collectionName) {
// Index index = new Index.Builder(collectionName, Constants.floatFieldName).withParamsInJson(Constants.indexParam).build();
// ListenableFuture<Response> createIndexResFuture = client.createIndexAsync(index);
// Futures.addCallback(
// createIndexResFuture, new FutureCallback<Response>() {
// @Override
// public void onSuccess(Response createIndexResponse) {
// Assert.assertNotNull(createIndexResponse);
// Assert.assertTrue(createIndexResponse.ok());
// Response statsResponse = client.getCollectionStats(collectionName);
// if(statsResponse.ok()) {
// JSONArray filesJsonArray = Utils.parseJsonArray(statsResponse.getMessage(), "files");
// filesJsonArray.stream().map(item-> (JSONObject)item).filter(item->item.containsKey("index_type")).forEach(file->
// Assert.assertEquals(file.get("index_type"), Constants.indexType));
// }
// }
// @Override
// public void onFailure(Throwable t) {
// System.out.println(t.getMessage());
// }
// }, MoreExecutors.directExecutor()
// );
// }
// case-12
@Test(
dataProvider = "DisConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ClientSideMilvusException.class)
public void testDropIndexWithoutConnect(MilvusClient client, String collectionName) {
client.dropIndex(collectionName, Constants.floatVectorFieldName);
}
//
// // case-13
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void testAsyncIndex(MilvusClient client, String collectionName) {
// Index index = new Index.Builder(collectionName,
// Constants.floatFieldName).withParamsInJson(Constants.indexParam).build();
// ListenableFuture<Response> createIndexResFuture = client.createIndexAsync(index);
// Futures.addCallback(
// createIndexResFuture, new FutureCallback<Response>() {
// @Override
// public void onSuccess(Response createIndexResponse) {
// Assert.assertNotNull(createIndexResponse);
// Assert.assertTrue(createIndexResponse.ok());
// Response statsResponse = client.getCollectionStats(collectionName);
// if(statsResponse.ok()) {
// JSONArray filesJsonArray =
// Utils.parseJsonArray(statsResponse.getMessage(), "files");
// filesJsonArray.stream().map(item->
// (JSONObject)item).filter(item->item.containsKey("index_type")).forEach(file->
// Assert.assertEquals(file.get("index_type"),
// Constants.indexType));
// }
// }
// @Override
// public void onFailure(Throwable t) {
// System.out.println(t.getMessage());
// }
// }, MoreExecutors.directExecutor()
// );
// }
}

568
tests/milvus-java-test/src/main/java/com/TestInsertEntities.java
View File

@ -2,265 +2,341 @@ package com;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import io.milvus.client.*;
import io.milvus.client.DataType;
import io.milvus.client.InsertParam;
import io.milvus.client.MilvusClient;
import io.milvus.client.exception.ClientSideMilvusException;
import io.milvus.client.exception.ServerSideMilvusException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.LongStream;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.nio.ByteBuffer;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.LongStream;
public class TestInsertEntities {
int dimension = Constants.dimension;
String tag = "tag";
int nb = Constants.nb;
Map<String, List> entities = Constants.defaultEntities;
Map<String, List> binaryEntities = Constants.defaultBinaryEntities;
int dimension = Constants.dimension;
String tag = "tag";
int nb = Constants.nb;
Map<String, List> entities = Constants.defaultEntities;
Map<String, List> binaryEntities = Constants.defaultBinaryEntities;
// case-01
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntitiesCollectionNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = collectionName + "_";
InsertParam insertParam = Utils.genInsertParam(collectionNameNew);
client.insert(insertParam);
// case-01
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntitiesCollectionNotExisted(MilvusClient client, String collectionName) {
String collectionNameNew = collectionName + "_";
InsertParam insertParam = Utils.genInsertParam(collectionNameNew);
client.insert(insertParam);
}
// case-02
@Test(
dataProvider = "DisConnectInstance",
dataProviderClass = MainClass.class,
expectedExceptions = ClientSideMilvusException.class)
public void testInsertEntitiesWithoutConnect(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
client.insert(insertParam);
}
// case-03
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testInsertEntities(MilvusClient client, String collectionName) {
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(
Constants.floatVectorFieldName,
DataType.VECTOR_FLOAT,
entities.get(Constants.floatVectorFieldName));
List<Long> vectorIds = client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(vectorIds.size(), nb);
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-04
@Test(dataProvider = "IdCollection", dataProviderClass = MainClass.class)
public void testInsertEntityWithIds(MilvusClient client, String collectionName) {
// Add vectors with ids
List<Long> entityIds = LongStream.range(0, nb).boxed().collect(Collectors.toList());
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(
Constants.floatVectorFieldName,
DataType.VECTOR_FLOAT,
entities.get(Constants.floatVectorFieldName))
.setEntityIds(entityIds);
List<Long> vectorIds = client.insert(insertParam);
client.flush(collectionName);
// Assert ids and collection row count
Assert.assertEquals(vectorIds, entityIds);
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-05
@Test(
dataProvider = "IdCollection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntityWithInvalidIds(MilvusClient client, String collectionName) {
// Add vectors with ids
List<Long> entityIds = LongStream.range(0, nb + 1).boxed().collect(Collectors.toList());
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(
Constants.floatVectorFieldName,
DataType.VECTOR_FLOAT,
entities.get(Constants.floatVectorFieldName))
.setEntityIds(entityIds);
client.insert(insertParam);
}
// case-06
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntityWithInvalidDimension(MilvusClient client, String collectionName) {
List<List<Float>> vectors = Utils.genVectors(nb, dimension + 1, true);
Map<String, List> entities = Utils.genDefaultEntities(nb, vectors);
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(
Constants.floatVectorFieldName,
DataType.VECTOR_FLOAT,
entities.get(Constants.floatVectorFieldName));
client.insert(insertParam);
}
// case-07
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntityWithInvalidVectors(MilvusClient client, String collectionName) {
Map<String, List> entities = Utils.genDefaultEntities(nb, new ArrayList<>());
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(
Constants.floatVectorFieldName,
DataType.VECTOR_FLOAT,
entities.get(Constants.floatVectorFieldName));
client.insert(insertParam);
}
// ----------------------------- partition cases in Insert ---------------------------------
// case-08: Add vectors into collection with given tag
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testInsertEntityPartition(MilvusClient client, String collectionName) {
client.createPartition(collectionName, tag);
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(
Constants.floatVectorFieldName,
DataType.VECTOR_FLOAT,
entities.get(Constants.floatVectorFieldName))
.setPartitionTag(tag);
client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
String stats = client.getCollectionStats(collectionName);
JSONArray partitionsJsonArray = Utils.parseJsonArray(stats, "partitions");
partitionsJsonArray.stream()
.map(item -> (JSONObject) item)
.filter(item -> item.containsValue(tag))
.forEach(
obj -> {
Assert.assertEquals(obj.get("row_count"), nb);
Assert.assertEquals(obj.get("tag"), tag);
});
}
// case-09: Add vectors into collection, which tag not existed
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntityPartitionTagNotExisted(MilvusClient client, String collectionName) {
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(
Constants.floatVectorFieldName,
DataType.VECTOR_FLOAT,
entities.get(Constants.floatVectorFieldName))
.setPartitionTag(tag);
client.insert(insertParam);
}
// case-10: Binary tests
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testInsertEntityPartitionABinary(MilvusClient client, String collectionName) {
client.createPartition(collectionName, tag);
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
List<ByteBuffer> vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors)
.setPartitionTag(tag);
client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
String stats = client.getCollectionStats(collectionName);
JSONArray partitionsJsonArray = Utils.parseJsonArray(stats, "partitions");
partitionsJsonArray.stream()
.map(item -> (JSONObject) item)
.filter(item -> item.containsValue(tag))
.forEach(
obj -> {
Assert.assertEquals(obj.get("tag"), tag);
Assert.assertEquals(obj.get("row_count"), nb);
});
}
// case-02
@Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class, expectedExceptions = ClientSideMilvusException.class)
public void testInsertEntitiesWithoutConnect(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
client.insert(insertParam);
// case-11
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testInsertEntityBinary(MilvusClient client, String collectionName) {
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
List<ByteBuffer> vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors);
List<Long> vectorIds = client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(vectorIds.size(), nb);
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-03
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testInsertEntities(MilvusClient client, String collectionName) {
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName));
List<Long> vectorIds = client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(vectorIds.size(), nb);
Assert.assertEquals(client.countEntities(collectionName), nb);
// case-12
@Test(dataProvider = "BinaryIdCollection", dataProviderClass = MainClass.class)
public void testInsertBinaryEntityWithIds(MilvusClient client, String collectionName) {
// Add vectors with ids
List<Long> entityIds = LongStream.range(0, nb).boxed().collect(Collectors.toList());
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
List<ByteBuffer> vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors)
.setEntityIds(entityIds);
List<Long> vectorIds = client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(entityIds, vectorIds);
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-04
@Test(dataProvider = "IdCollection", dataProviderClass = MainClass.class)
public void testInsertEntityWithIds(MilvusClient client, String collectionName) {
// Add vectors with ids
List<Long> entityIds = LongStream.range(0, nb).boxed().collect(Collectors.toList());
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName))
.setEntityIds(entityIds);
List<Long> vectorIds = client.insert(insertParam);
client.flush(collectionName);
// Assert ids and collection row count
Assert.assertEquals(vectorIds, entityIds);
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-13
@Test(
dataProvider = "BinaryCollection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testInsertBinaryEntityWithInvalidIds(MilvusClient client, String collectionName) {
// Add vectors with ids
List<Long> invalidEntityIds = LongStream.range(0, nb + 1).boxed().collect(Collectors.toList());
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(
Constants.intFieldName, DataType.INT64, binaryEntities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName,
DataType.FLOAT,
binaryEntities.get(Constants.floatFieldName))
.addVectorField(
Constants.binaryVectorFieldName,
DataType.VECTOR_BINARY,
binaryEntities.get(Constants.binaryVectorFieldName))
.setEntityIds(invalidEntityIds);
client.insert(insertParam);
}
// case-05
@Test(dataProvider = "IdCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntityWithInvalidIds(MilvusClient client, String collectionName) {
// Add vectors with ids
List<Long> entityIds = LongStream.range(0, nb+1).boxed().collect(Collectors.toList());
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName))
.setEntityIds(entityIds);
client.insert(insertParam);
}
// case-14
@Test(
dataProvider = "BinaryCollection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testInsertBinaryEntityWithInvalidDimension(
MilvusClient client, String collectionName) {
List<ByteBuffer> vectors = Utils.genBinaryVectors(nb, dimension - 1);
Map<String, List> entities = Utils.genDefaultBinaryEntities(nb, vectors);
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(
Constants.binaryVectorFieldName,
DataType.VECTOR_BINARY,
entities.get(Constants.binaryVectorFieldName));
client.insert(insertParam);
}
// case-06
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntityWithInvalidDimension(MilvusClient client, String collectionName) {
List<List<Float>> vectors = Utils.genVectors(nb, dimension+1, true);
Map<String, List> entities = Utils.genDefaultEntities(nb,vectors);
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName));
client.insert(insertParam);
}
// case-07
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntityWithInvalidVectors(MilvusClient client, String collectionName) {
Map<String, List> entities = Utils.genDefaultEntities(nb,new ArrayList<>());
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName));
client.insert(insertParam);
}
// ----------------------------- partition cases in Insert ---------------------------------
// case-08: Add vectors into collection with given tag
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testInsertEntityPartition(MilvusClient client, String collectionName) {
client.createPartition(collectionName, tag);
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName))
.setPartitionTag(tag);
client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
String stats = client.getCollectionStats(collectionName);
JSONArray partitionsJsonArray = Utils.parseJsonArray(stats, "partitions");
partitionsJsonArray.stream().map(item -> (JSONObject) item).filter(item->item.containsValue(tag)).forEach(obj -> {
Assert.assertEquals(obj.get("row_count"), nb);
Assert.assertEquals(obj.get("tag"), tag);
});
}
// case-09: Add vectors into collection, which tag not existed
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testInsertEntityPartitionTagNotExisted(MilvusClient client, String collectionName) {
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName))
.setPartitionTag(tag);
client.insert(insertParam);
}
// case-10: Binary tests
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testInsertEntityPartitionABinary(MilvusClient client, String collectionName) {
client.createPartition(collectionName, tag);
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
List<ByteBuffer> vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors)
.setPartitionTag(tag);
client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
String stats = client.getCollectionStats(collectionName);
JSONArray partitionsJsonArray = Utils.parseJsonArray(stats, "partitions");
partitionsJsonArray.stream().map(item -> (JSONObject) item).filter(item->item.containsValue(tag)).forEach(obj -> {
Assert.assertEquals(obj.get("tag"), tag);
Assert.assertEquals(obj.get("row_count"), nb);
});
}
// case-11
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
public void testInsertEntityBinary(MilvusClient client, String collectionName) {
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
List<ByteBuffer> vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors);
List<Long> vectorIds = client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(vectorIds.size(), nb);
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-12
@Test(dataProvider = "BinaryIdCollection", dataProviderClass = MainClass.class)
public void testInsertBinaryEntityWithIds(MilvusClient client, String collectionName) {
// Add vectors with ids
List<Long> entityIds = LongStream.range(0, nb).boxed().collect(Collectors.toList());
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
List<ByteBuffer> vectors = Utils.genBinaryVectors(Constants.nb, Constants.dimension);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, vectors)
.setEntityIds(entityIds);
List<Long> vectorIds = client.insert(insertParam);
client.flush(collectionName);
// Assert collection row count
Assert.assertEquals(entityIds, vectorIds);
Assert.assertEquals(client.countEntities(collectionName), nb);
}
// case-13
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testInsertBinaryEntityWithInvalidIds(MilvusClient client, String collectionName) {
// Add vectors with ids
List<Long> invalidEntityIds = LongStream.range(0, nb+1).boxed().collect(Collectors.toList());
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, binaryEntities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, binaryEntities.get(Constants.floatFieldName))
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, binaryEntities.get(Constants.binaryVectorFieldName))
.setEntityIds(invalidEntityIds);
client.insert(insertParam);
}
// case-14
@Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testInsertBinaryEntityWithInvalidDimension(MilvusClient client, String collectionName) {
List<ByteBuffer> vectors = Utils.genBinaryVectors(nb, dimension-1);
Map<String, List> entities = Utils.genDefaultBinaryEntities(nb,vectors);
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, entities.get(Constants.binaryVectorFieldName));
client.insert(insertParam);
}
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void testAsyncInsert(MilvusClient client, String collectionName) {
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFields(Constants.defaultEntities).build();
// ListenableFuture<InsertResponse> insertResFuture = client.insertAsync(insertParam);
// Futures.addCallback(
// insertResFuture, new FutureCallback<InsertResponse>() {
// @Override
// public void onSuccess(InsertResponse insertResponse) {
// Assert.assertNotNull(insertResponse);
// Assert.assertTrue(insertResponse.ok());
// Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), nb);
// }
// @Override
// public void onFailure(Throwable t) {
// System.out.println(t.getMessage());
// }
// }, MoreExecutors.directExecutor()
// );
// }
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void testAsyncInsert(MilvusClient client, String collectionName) {
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFields(Constants.defaultEntities).build();
// ListenableFuture<InsertResponse> insertResFuture = client.insertAsync(insertParam);
// Futures.addCallback(
// insertResFuture, new FutureCallback<InsertResponse>() {
// @Override
// public void onSuccess(InsertResponse insertResponse) {
// Assert.assertNotNull(insertResponse);
// Assert.assertTrue(insertResponse.ok());
//
// Assert.assertEquals(client.countEntities(collectionName).getCollectionEntityCount(), nb);
// }
// @Override
// public void onFailure(Throwable t) {
// System.out.println(t.getMessage());
// }
// }, MoreExecutors.directExecutor()
// );
// }
}

68
tests/milvus-java-test/src/main/java/com/TestMix.java
View File

@ -1,18 +1,18 @@
package com;//package com;
package com; // package com;
//
//import io.milvus.client.*;
//import org.apache.commons.lang3.RandomStringUtils;
//import org.testng.Assert;
//import org.testng.annotations.Test;
// import io.milvus.client.*;
// import org.apache.commons.lang3.RandomStringUtils;
// import org.testng.Assert;
// import org.testng.annotations.Test;
//
//import java.util.ArrayList;
//import java.util.List;
//import java.util.Random;
//import java.util.concurrent.ForkJoinPool;
//import java.util.concurrent.TimeUnit;
//import java.util.stream.Collectors;
// import java.util.ArrayList;
// import java.util.List;
// import java.util.Random;
// import java.util.concurrent.ForkJoinPool;
// import java.util.concurrent.TimeUnit;
// import java.util.stream.Collectors;
//
//public class TestMix {
// public class TestMix {
// private int dimension = 128;
// private int nb = 100000;
// int nq = 10;
@ -27,10 +27,12 @@ package com;//package com;
// List<List<Float>> queryVectors = vectors.subList(0,nq);
//
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void test_search_vectors_threads(MilvusClient client, String collectionName) throws InterruptedException {
// public void test_search_vectors_threads(MilvusClient client, String collectionName) throws
// InterruptedException {
// int thread_num = 10;
// int nq = 5;
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// client.insert(insertParam);
// Index index = new Index.Builder(collectionName, IndexType.IVF_SQ8)
// .withParamsInJson(indexParam)
@ -83,9 +85,11 @@ package com;//package com;
// }
//
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void test_add_vectors_threads(MilvusClient client, String collectionName) throws InterruptedException {
// public void test_add_vectors_threads(MilvusClient client, String collectionName) throws
// InterruptedException {
// int thread_num = 10;
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// ForkJoinPool executor = new ForkJoinPool();
// for (int i = 0; i < thread_num; i++) {
// executor.execute(
@ -103,11 +107,13 @@ package com;//package com;
// }
//
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void test_add_vectors_partition_threads(MilvusClient client, String collectionName) throws InterruptedException {
// public void test_add_vectors_partition_threads(MilvusClient client, String collectionName)
// throws InterruptedException {
// int thread_num = 10;
// String tag = RandomStringUtils.randomAlphabetic(10);
// client.createPartition(collectionName, tag);
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build();
// ForkJoinPool executor = new ForkJoinPool();
// for (int i = 0; i < thread_num; i++) {
// executor.execute(
@ -125,9 +131,11 @@ package com;//package com;
// }
//
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void test_add_index_vectors_threads(MilvusClient client, String collectionName) throws InterruptedException {
// public void test_add_index_vectors_threads(MilvusClient client, String collectionName) throws
// InterruptedException {
// int thread_num = 50;
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// ForkJoinPool executor = new ForkJoinPool();
// for (int i = 0; i < thread_num; i++) {
// executor.execute(
@ -148,11 +156,13 @@ package com;//package com;
// }
//
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void test_add_search_vectors_threads(MilvusClient client, String collectionName) throws InterruptedException {
// public void test_add_search_vectors_threads(MilvusClient client, String collectionName) throws
// InterruptedException {
// int thread_num = 50;
// int nq = 5;
// List<List<Float>> queryVectors = vectors.subList(0,nq);
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// ForkJoinPool executor = new ForkJoinPool();
// for (int i = 0; i < thread_num; i++) {
// executor.execute(
@ -170,7 +180,8 @@ package com;//package com;
// .withTopK(top_k).build();
// SearchResponse res_search = client.search(searchParam);
// assert (res_search.getResponse().ok());
// List<List<SearchResponse.QueryResult>> res = client.search(searchParam).getQueryResultsList();
// List<List<SearchResponse.QueryResult>> res =
// client.search(searchParam).getQueryResultsList();
// double distance = res.get(0).get(0).getDistance();
// if (collectionName.startsWith("L2")) {
// Assert.assertEquals(distance, 0.0, epsilon);
@ -205,12 +216,15 @@ package com;//package com;
// }
// assert(client.isConnected());
// String collectionName = RandomStringUtils.randomAlphabetic(10);
// CollectionMapping tableSchema = new CollectionMapping.Builder(collectionName, dimension)
// .withIndexFileSize(index_file_size)
// CollectionMapping tableSchema = new
// CollectionMapping.Builder(collectionName, dimension)
//
// .withIndexFileSize(index_file_size)
// .withMetricType(MetricType.IP)
// .build();
// client.createCollection(tableSchema);
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// client.insert(insertParam);
// Response response = client.dropCollection(collectionName);
// Assert.assertTrue(response.ok());
@ -225,4 +239,4 @@ package com;//package com;
// executor.shutdown();
// }
//
//}
// }

26
tests/milvus-java-test/src/main/java/com/TestPS.java
View File

@ -1,15 +1,15 @@
package com;//package com;
package com; // package com;
//
//import io.milvus.client.*;
//import org.apache.commons.cli.*;
// import io.milvus.client.*;
// import org.apache.commons.cli.*;
//
//import java.util.List;
//import java.util.concurrent.ForkJoinPool;
//import java.util.concurrent.TimeUnit;
//import java.util.stream.Collectors;
//import java.util.stream.Stream;
// import java.util.List;
// import java.util.concurrent.ForkJoinPool;
// import java.util.concurrent.TimeUnit;
// import java.util.stream.Collectors;
// import java.util.stream.Stream;
//
//public class TestPS {
// public class TestPS {
// private static int dimension = 128;
// private static String host = "127.0.0.1";
// private static String port = "19530";
@ -73,7 +73,8 @@ package com;//package com;
// vectorIds = Stream.iterate(0L, n -> n)
// .limit(nb)
// .collect(Collectors.toList());
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).withVectorIds(vectorIds).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).withVectorIds(vectorIds).build();
// ForkJoinPool executor_search = new ForkJoinPool();
// for (int i = 0; i < loops; i++) {
// executor_search.execute(
@ -81,7 +82,8 @@ package com;//package com;
// InsertResponse res_insert = client.insert(insertParam);
// assert (res_insert.getResponse().ok());
// System.out.println("In insert");
// SearchParam searchParam = new SearchParam.Builder(collectionName).withFloatVectors(queryVectors).withTopK(top_k).build();
// SearchParam searchParam = new
// SearchParam.Builder(collectionName).withFloatVectors(queryVectors).withTopK(top_k).build();
// SearchResponse res_search = client.search(searchParam);
// assert (res_search.getResponse().ok());
// });
@ -91,4 +93,4 @@ package com;//package com;
// CountEntitiesResponse getTableRowCountResponse = client.countEntities(collectionName);
// System.out.println(getTableRowCountResponse.getCollectionEntityCount());
// }
//}
// }

217
tests/milvus-java-test/src/main/java/com/TestPartition.java
View File

@ -1,124 +1,139 @@
package com;
import io.milvus.client.*;
import io.milvus.client.MilvusClient;
import io.milvus.client.exception.ServerSideMilvusException;
import java.util.List;
import org.apache.commons.lang3.RandomStringUtils;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.util.List;
public class TestPartition {
// ----------------------------- create partition cases in ---------------------------------
// ----------------------------- create partition cases in ---------------------------------
// create partition
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCreatePartition(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
Assert.assertEquals(client.hasPartition(collectionName, tag), true);
// show partitions
List<String> partitions = client.listPartitions(collectionName);
Assert.assertTrue(partitions.contains(tag));
}
// create partition
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testCreatePartition(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
Assert.assertEquals(client.hasPartition(collectionName, tag), true);
// show partitions
List<String> partitions = client.listPartitions(collectionName);
Assert.assertTrue(partitions.contains(tag));
}
// create partition, tag name existed
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testCreatePartitionTagNameExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
client.createPartition(collectionName, tag);
}
// create partition, tag name existed
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testCreatePartitionTagNameExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
client.createPartition(collectionName, tag);
}
// ----------------------------- has partition cases in ---------------------------------
// has partition, tag name not existed
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testHasPartitionTagNameNotExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
String tagNew = RandomStringUtils.randomAlphabetic(10);
Assert.assertFalse(client.hasPartition(collectionName, tagNew));
}
// ----------------------------- has partition cases in ---------------------------------
// has partition, tag name not existed
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testHasPartitionTagNameNotExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
String tagNew = RandomStringUtils.randomAlphabetic(10);
Assert.assertFalse(client.hasPartition(collectionName, tagNew));
}
// has partition, tag name existed
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testHasPartitionTagNameExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
Assert.assertTrue(client.hasPartition(collectionName, tag));
}
// has partition, tag name existed
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testHasPartitionTagNameExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
Assert.assertTrue(client.hasPartition(collectionName, tag));
}
// ----------------------------- drop partition cases in ---------------------------------
// ----------------------------- drop partition cases in ---------------------------------
// drop a partition created before, drop by partition name
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDropPartition(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
client.dropPartition(collectionName, tag);
// show partitions
System.out.println(client.listPartitions(collectionName));
int length = client.listPartitions(collectionName).size();
// _default
Assert.assertEquals(length, 1);
}
// drop a partition created before, drop by partition name
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testDropPartition(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
client.dropPartition(collectionName, tag);
// show partitions
System.out.println(client.listPartitions(collectionName));
int length = client.listPartitions(collectionName).size();
// _default
Assert.assertEquals(length, 1);
}
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testDropPartitionDefault(MilvusClient client, String collectionName) {
String tag = "_default";
client.createPartition(collectionName, tag);
}
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testDropPartitionDefault(MilvusClient client, String collectionName) {
String tag = "_default";
client.createPartition(collectionName, tag);
}
// drop a partition repeat created before, drop by partition name
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testDropPartitionRepeat(MilvusClient client, String collectionName) throws InterruptedException {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
client.dropPartition(collectionName, tag);
Thread.sleep(2000);
client.dropPartition(collectionName, tag);
}
// drop a partition repeat created before, drop by partition name
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testDropPartitionRepeat(MilvusClient client, String collectionName)
throws InterruptedException {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
client.dropPartition(collectionName, tag);
Thread.sleep(2000);
client.dropPartition(collectionName, tag);
}
// drop a partition not created before
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testDropPartitionNotExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
String tagNew = RandomStringUtils.randomAlphabetic(10);
client.dropPartition(collectionName, tagNew);
}
// drop a partition not created before
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testDropPartitionNotExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
String tagNew = RandomStringUtils.randomAlphabetic(10);
client.dropPartition(collectionName, tagNew);
}
// drop a partition not created before
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class, expectedExceptions = ServerSideMilvusException.class)
public void testDropPartitionTagNotExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
String newTag = RandomStringUtils.randomAlphabetic(10);
client.dropPartition(collectionName, newTag);
}
// drop a partition not created before
@Test(
dataProvider = "Collection",
dataProviderClass = MainClass.class,
expectedExceptions = ServerSideMilvusException.class)
public void testDropPartitionTagNotExisted(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
String newTag = RandomStringUtils.randomAlphabetic(10);
client.dropPartition(collectionName, newTag);
}
// ----------------------------- show partitions cases in ---------------------------------
// ----------------------------- show partitions cases in ---------------------------------
// create partition, then show partitions
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testShowPartitions(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
List<String> partitions = client.listPartitions(collectionName);
Assert.assertTrue(partitions.contains(tag));
}
// create multi partition, then show partitions
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testShowPartitionsMulti(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
String tagNew = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tagNew);
List<String> partitions = client.listPartitions(collectionName);
System.out.println(partitions);
Assert.assertTrue(partitions.contains(tag));
Assert.assertTrue(partitions.contains(tagNew));
}
// create partition, then show partitions
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testShowPartitions(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
List<String> partitions = client.listPartitions(collectionName);
Assert.assertTrue(partitions.contains(tag));
}
// create multi partition, then show partitions
@Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
public void testShowPartitionsMulti(MilvusClient client, String collectionName) {
String tag = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tag);
String tagNew = RandomStringUtils.randomAlphabetic(10);
client.createPartition(collectionName, tagNew);
List<String> partitions = client.listPartitions(collectionName);
System.out.println(partitions);
Assert.assertTrue(partitions.contains(tag));
Assert.assertTrue(partitions.contains(tagNew));
}
}

13
tests/milvus-java-test/src/main/java/com/TestPing.java
View File

@ -1,9 +1,9 @@
//package com1;
// package com1;
//
//import io.milvus.client.*;
//import org.testng.annotations.Test;
// import io.milvus.client.*;
// import org.testng.annotations.Test;
//
//public class TestPing {
// public class TestPing {
// @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
// public void testServerStatus(String host, int port) throws ConnectFailedException {
// System.out.println("Host: "+host+", Port: "+port);
@ -18,8 +18,9 @@
// }
//
// @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
// public void testServerStatusWithoutConnected(MilvusClient client, String collectionName) throws ConnectFailedException {
// public void testServerStatusWithoutConnected(MilvusClient client, String collectionName)
// throws ConnectFailedException {
// Response res = client.getServerStatus();
// assert (!res.ok());
// }
//}
// }

80
tests/milvus-java-test/src/main/java/com/TestSearchByIds.java
View File

@ -1,15 +1,15 @@
package com;//package com;
package com; // package com;
//
//import io.milvus.client.*;
//import org.apache.commons.lang3.RandomStringUtils;
//import org.testng.Assert;
//import org.testng.annotations.Test;
// import io.milvus.client.*;
// import org.apache.commons.lang3.RandomStringUtils;
// import org.testng.Assert;
// import org.testng.annotations.Test;
//
//import java.nio.ByteBuffer;
//import java.util.ArrayList;
//import java.util.List;
// import java.nio.ByteBuffer;
// import java.util.ArrayList;
// import java.util.List;
//
//public class TestSearchByIds {
// public class TestSearchByIds {
// int dimension = 128;
// int n_list = 1024;
// int default_n_list = 16384;
@ -53,7 +53,8 @@ package com;//package com;
//
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void test_search_no_result(MilvusClient client, String collectionName) {
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// client.insert(insertParam);
// client.flush(collectionName);
// SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName)
@ -61,7 +62,8 @@ package com;//package com;
// .withTopK(top_k)
// .withIDs(default_ids)
// .build();
// List<List<SearchResponse.QueryResult>> res_search = client.searchByIds(searchParam).getQueryResultsList();
// List<List<SearchResponse.QueryResult>> res_search =
// client.searchByIds(searchParam).getQueryResultsList();
// assert (client.searchByIds(searchParam).getResponse().ok());
// Assert.assertEquals(res_search.get(0).size(), 0);
// }
@ -69,7 +71,8 @@ package com;//package com;
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void test_search_count_lt_top_k(MilvusClient client, String collectionName) {
// int top_k = 100;
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(small_vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(small_vectors).build();
// InsertResponse res_insert = client.insert(insertParam);
// client.flush(collectionName);
// SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName)
@ -77,8 +80,10 @@ package com;//package com;
// .withTopK(top_k)
// .withIDs(Utils.toListIds(res_insert.getVectorIds().get(0)))
// .build();
// List<List<SearchResponse.QueryResult>> res_search = client.searchByIds(searchParam).getQueryResultsList();
// // reason: "Failed to query by id in collection L2_FmVKbqSZaN, result doesn\'t match id count"
// List<List<SearchResponse.QueryResult>> res_search =
// client.searchByIds(searchParam).getQueryResultsList();
// // reason: "Failed to query by id in collection L2_FmVKbqSZaN, result doesn\'t match id
// count"
// assert (!client.searchByIds(searchParam).getResponse().ok());
//// Assert.assertEquals(res_search.size(), default_ids.size());
//// Assert.assertEquals(res_search.get(0).get(0).getVectorId(), -1);
@ -87,17 +92,20 @@ package com;//package com;
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void test_search_index_IVFLAT(MilvusClient client, String collectionName) {
// IndexType indexType = IndexType.IVFLAT;
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertResponse res_insert = client.insert(insertParam);
// client.flush(collectionName);
// Index index = new Index.Builder(collectionName, indexType).withParamsInJson(indexParam).build();
// Index index = new Index.Builder(collectionName,
// indexType).withParamsInJson(indexParam).build();
// client.createIndex(index);
// SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName)
// .withParamsInJson(searchParamStr)
// .withTopK(top_k)
// .withIDs(res_insert.getVectorIds())
// .build();
// List<List<SearchResponse.QueryResult>> res_search = client.searchByIds(searchParam).getQueryResultsList();
// List<List<SearchResponse.QueryResult>> res_search =
// client.searchByIds(searchParam).getQueryResultsList();
// for (int i=0; i<vectors.size(); ++i) {
// Assert.assertEquals(res_search.get(i).size(), top_k);
// long vectorId = res_search.get(i).get(0).getVectorId();
@ -117,10 +125,12 @@ package com;//package com;
// IndexType indexType = IndexType.IVFLAT;
// String tag = RandomStringUtils.randomAlphabetic(10);
// client.createPartition(collectionName, tag);
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build();
// InsertResponse res_insert = client.insert(insertParam);
// client.flush(collectionName);
// Index index = new Index.Builder(collectionName, indexType).withParamsInJson(indexParam).build();
// Index index = new Index.Builder(collectionName,
// indexType).withParamsInJson(indexParam).build();
// client.createIndex(index);
// List<String> queryTags = new ArrayList<>();
// queryTags.add(tag);
@ -130,7 +140,8 @@ package com;//package com;
// .withIDs(Utils.toListIds(res_insert.getVectorIds().get(0)))
// .withPartitionTags(queryTags)
// .build();
// List<List<SearchResponse.QueryResult>> res_search = client.searchByIds(searchParam).getQueryResultsList();
// List<List<SearchResponse.QueryResult>> res_search =
// client.searchByIds(searchParam).getQueryResultsList();
// double distance = res_search.get(0).get(0).getDistance();
// if (collectionName.startsWith("L2")) {
// Assert.assertEquals(distance, 0.0, epsilon);
@ -143,7 +154,8 @@ package com;//package com;
// public void test_search_partition_not_exited(MilvusClient client, String collectionName) {
// String tag = RandomStringUtils.randomAlphabetic(10);
// client.createPartition(collectionName, tag);
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build();
// client.insert(insertParam);
// client.flush(collectionName);
// String tagNew = RandomStringUtils.randomAlphabetic(10);
@ -164,7 +176,8 @@ package com;//package com;
// public void test_search_partition_empty(MilvusClient client, String collectionName) {
// String tag = RandomStringUtils.randomAlphabetic(10);
// client.createPartition(collectionName, tag);
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).withPartitionTag(tag).build();
// client.insert(insertParam);
// client.flush(collectionName);
// List<String> queryTags = new ArrayList<>();
@ -184,7 +197,8 @@ package com;//package com;
// public void test_search_invalid_n_probe(MilvusClient client, String collectionName) {
// int n_probe_new = 0;
// String searchParamStrNew = Utils.setSearchParam(n_probe_new);
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// client.insert(insertParam);
// SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName)
// .withParamsInJson(searchParamStrNew)
@ -198,7 +212,8 @@ package com;//package com;
// @Test(dataProvider = "Collection", dataProviderClass = MainClass.class)
// public void test_search_invalid_top_k(MilvusClient client, String collectionName) {
// int top_k_new = 0;
// InsertParam insertParam = new InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withFloatVectors(vectors).build();
// client.insert(insertParam);
// SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName)
// .withParamsInJson(searchParamStr)
@ -211,7 +226,8 @@ package com;//package com;
//
// // Binary tests
// @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
// public void test_search_collection_not_existed_binary(MilvusClient client, String collectionName) {
// public void test_search_collection_not_existed_binary(MilvusClient client, String
// collectionName) {
// String collectionNameNew = collectionName + "_";
// SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionNameNew)
// .withParamsInJson(searchParamStr)
@ -224,7 +240,8 @@ package com;//package com;
//
// @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
// public void test_search_ids_binary(MilvusClient client, String collectionName) {
// InsertParam insertParam = new InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build();
// InsertResponse res_insert = client.insert(insertParam);
// client.flush(collectionName);
// SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName)
@ -232,7 +249,8 @@ package com;//package com;
// .withTopK(top_k)
// .withIDs(res_insert.getVectorIds())
// .build();
// List<List<SearchResponse.QueryResult>> res_search = client.searchByIds(searchParam).getQueryResultsList();
// List<List<SearchResponse.QueryResult>> res_search =
// client.searchByIds(searchParam).getQueryResultsList();
// for (int i = 0; i < top_k; i++) {
// long insert_id = res_insert.getVectorIds().get(i);
// long get_id = res_search.get(i).get(0).getVectorId();
@ -245,7 +263,8 @@ package com;//package com;
// public void test_search_invalid_n_probe_binary(MilvusClient client, String collectionName) {
// int n_probe_new = 0;
// String searchParamStrNew = Utils.setSearchParam(n_probe_new);
// InsertParam insertParam = new InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build();
// client.insert(insertParam);
// SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName)
// .withParamsInJson(searchParamStrNew)
@ -259,7 +278,8 @@ package com;//package com;
// @Test(dataProvider = "BinaryCollection", dataProviderClass = MainClass.class)
// public void test_search_invalid_top_k_binary(MilvusClient client, String collectionName) {
// int top_k_new = 0;
// InsertParam insertParam = new InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build();
// InsertParam insertParam = new
// InsertParam.Builder(collectionName).withBinaryVectors(vectorsBinary).build();
// client.insert(insertParam);
// SearchByIdsParam searchParam = new SearchByIdsParam.Builder(collectionName)
// .withParamsInJson(searchParamStr)
@ -270,4 +290,4 @@ package com;//package com;
// assert (!res_search.getResponse().ok());
// }
//
//}
// }

1007
tests/milvus-java-test/src/main/java/com/TestSearchEntities.java
View File

File diff suppressed because it is too large Load Diff

909
tests/milvus-java-test/src/main/java/com/Utils.java
View File

@ -1,472 +1,513 @@
package com;
import com.alibaba.fastjson.JSONArray;
import io.milvus.client.*;
import com.alibaba.fastjson.JSONObject;
import io.milvus.client.CollectionMapping;
import io.milvus.client.DataType;
import io.milvus.client.InsertParam;
import io.milvus.client.JsonBuilder;
import io.milvus.client.MetricType;
import io.milvus.client.MilvusClient;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Random;
import java.util.stream.Collectors;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.RandomStringUtils;
import java.nio.ByteBuffer;
import java.util.*;
import java.util.stream.Collectors;
import org.testng.Assert;
public class Utils {
public static List<Float> normalize(List<Float> w2v){
float squareSum = w2v.stream().map(x -> x * x).reduce((float) 0, Float::sum);
final float norm = (float) Math.sqrt(squareSum);
w2v = w2v.stream().map(x -> x / norm).collect(Collectors.toList());
return w2v;
public static List<Float> normalize(List<Float> w2v) {
float squareSum = w2v.stream().map(x -> x * x).reduce((float) 0, Float::sum);
final float norm = (float) Math.sqrt(squareSum);
w2v = w2v.stream().map(x -> x / norm).collect(Collectors.toList());
return w2v;
}
public static String genUniqueStr(String str_value) {
String prefix = "_" + RandomStringUtils.randomAlphabetic(10);
String str = str_value == null || str_value.trim().isEmpty() ? "test" : str_value;
return str.trim() + prefix;
}
public static List<List<Float>> genVectors(int vectorCount, int dimension, boolean norm) {
Random random = new Random();
List<List<Float>> vectors = new ArrayList<>();
for (int i = 0; i < vectorCount; ++i) {
List<Float> vector = new ArrayList<>();
for (int j = 0; j < dimension; ++j) {
vector.add(random.nextFloat());
}
if (norm) {
vector = normalize(vector);
}
vectors.add(vector);
}
return vectors;
}
public static String genUniqueStr(String str_value){
String prefix = "_"+RandomStringUtils.randomAlphabetic(10);
String str = str_value == null || str_value.trim().isEmpty() ? "test" : str_value;
return str.trim()+prefix;
static List<ByteBuffer> genBinaryVectors(int vectorCount, int dimension) {
Random random = new Random();
List<ByteBuffer> vectors = new ArrayList<>(vectorCount);
final int dimensionInByte = dimension / 8;
for (int i = 0; i < vectorCount; ++i) {
ByteBuffer byteBuffer = ByteBuffer.allocate(dimensionInByte);
random.nextBytes(byteBuffer.array());
vectors.add(byteBuffer);
}
return vectors;
}
public static List<List<Float>> genVectors(int vectorCount, int dimension, boolean norm) {
Random random = new Random();
List<List<Float>> vectors = new ArrayList<>();
for (int i = 0; i < vectorCount; ++i) {
List<Float> vector = new ArrayList<>();
for (int j = 0; j < dimension; ++j) {
vector.add(random.nextFloat());
}
if (norm) {
vector = normalize(vector);
}
vectors.add(vector);
}
return vectors;
private static List<Map<String, Object>> genBaseFieldsWithoutVector() {
List<Map<String, Object>> fieldsList = new ArrayList<>();
Map<String, Object> intFields = new HashMap<>();
intFields.put(Constants.fieldNameKey, Constants.intFieldName);
intFields.put("type", DataType.INT64);
Map<String, Object> floatField = new HashMap<>();
floatField.put(Constants.fieldNameKey, Constants.floatFieldName);
floatField.put("type", DataType.FLOAT);
fieldsList.add(intFields);
fieldsList.add(floatField);
return fieldsList;
}
public static List<Map<String, Object>> genDefaultFields(int dimension, boolean isBinary) {
List<Map<String, Object>> defaultFieldList = genBaseFieldsWithoutVector();
Map<String, Object> vectorField = new HashMap<>();
if (isBinary) {
vectorField.put(Constants.fieldNameKey, Constants.binaryVectorFieldName);
vectorField.put("type", DataType.VECTOR_BINARY);
} else {
vectorField.put(Constants.fieldNameKey, Constants.floatVectorFieldName);
vectorField.put("type", DataType.VECTOR_FLOAT);
}
JSONObject jsonObject = new JSONObject();
jsonObject.put("dim", dimension);
vectorField.put("params", jsonObject.toString());
static List<ByteBuffer> genBinaryVectors(int vectorCount, int dimension) {
Random random = new Random();
List<ByteBuffer> vectors = new ArrayList<>(vectorCount);
final int dimensionInByte = dimension / 8;
for (int i = 0; i < vectorCount; ++i) {
ByteBuffer byteBuffer = ByteBuffer.allocate(dimensionInByte);
random.nextBytes(byteBuffer.array());
vectors.add(byteBuffer);
}
return vectors;
defaultFieldList.add(vectorField);
return defaultFieldList;
}
public static Map<String, List> genDefaultEntities(int vectorCount, List<List<Float>> vectors) {
// Map<String,Object> fieldsMap = genDefaultFields(dimension, false);
Map<String, List> fieldsMap = new HashMap<>();
List<Long> intValues = new ArrayList<>(vectorCount);
List<Float> floatValues = new ArrayList<>(vectorCount);
for (int i = 0; i < vectorCount; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
fieldsMap.put(Constants.intFieldName, intValues);
fieldsMap.put(Constants.floatFieldName, floatValues);
fieldsMap.put(Constants.floatVectorFieldName, vectors);
return fieldsMap;
}
private static List<Map<String, Object>> genBaseFieldsWithoutVector(){
List<Map<String,Object>> fieldsList = new ArrayList<>();
Map<String, Object> intFields = new HashMap<>();
intFields.put(Constants.fieldNameKey,Constants.intFieldName);
intFields.put("type",DataType.INT64);
Map<String, Object> floatField = new HashMap<>();
floatField.put(Constants.fieldNameKey,Constants.floatFieldName);
floatField.put("type",DataType.FLOAT);
fieldsList.add(intFields);
fieldsList.add(floatField);
return fieldsList;
public static Map<String, List> genDefaultBinaryEntities(
int vectorCount, List<ByteBuffer> vectorsBinary) {
// List<Map<String,Object>> binaryFieldsMap = genDefaultFields(dimension, true);
Map<String, List> binaryFieldsMap = new HashMap<>();
List<Long> intValues = new ArrayList<>(vectorCount);
List<Float> floatValues = new ArrayList<>(vectorCount);
for (int i = 0; i < vectorCount; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
public static List<Map<String, Object>> genDefaultFields(int dimension, boolean isBinary){
List<Map<String, Object>> defaultFieldList = genBaseFieldsWithoutVector();
Map<String, Object> vectorField = new HashMap<>();
if (isBinary){
vectorField.put(Constants.fieldNameKey, Constants.binaryVectorFieldName);
vectorField.put("type",DataType.VECTOR_BINARY);
}else {
vectorField.put(Constants.fieldNameKey, Constants.floatVectorFieldName);
vectorField.put("type",DataType.VECTOR_FLOAT);
}
JSONObject jsonObject = new JSONObject();
jsonObject.put("dim", dimension);
vectorField.put("params", jsonObject.toString());
binaryFieldsMap.put(Constants.intFieldName, intValues);
binaryFieldsMap.put(Constants.floatFieldName, floatValues);
binaryFieldsMap.put(Constants.binaryVectorFieldName, vectorsBinary);
return binaryFieldsMap;
}
defaultFieldList.add(vectorField);
return defaultFieldList;
public static String setIndexParam(String indexType, String metricType, int nlist) {
// ("{\"index_type\": \"IVF_SQ8\", \"metric_type\": \"L2\", \"\"params\": {\"nlist\":
// 2048}}")
// JSONObject indexParam = new JSONObject();
// indexParam.put("nlist", nlist);
// return JSONObject.toJSONString(indexParam);
String indexParams =
String.format(
"{\"index_type\": %s, \"metric_type\": %s, \"params\": {\"nlist\": %s}}",
indexType, metricType, nlist);
return indexParams;
}
static JSONObject genVectorParam(
MetricType metricType, List<List<Float>> queryVectors, int topk, int nprobe) {
JSONObject searchParam = new JSONObject();
JSONObject fieldParam = new JSONObject();
fieldParam.put("topk", topk);
fieldParam.put("metric_type", metricType);
fieldParam.put("query", queryVectors);
fieldParam.put("type", Constants.vectorType);
JSONObject tmpSearchParam = new JSONObject();
tmpSearchParam.put("nprobe", nprobe);
fieldParam.put("params", tmpSearchParam);
JSONObject vectorParams = new JSONObject();
vectorParams.put(Constants.floatVectorFieldName, fieldParam);
searchParam.put("vector", vectorParams);
return searchParam;
}
static JSONObject genBinaryVectorParam(
MetricType metricType, List<ByteBuffer> queryVectors, int topk, int nprobe) {
JSONObject searchParam = new JSONObject();
JSONObject fieldParam = new JSONObject();
fieldParam.put("topk", topk);
fieldParam.put("metric_type", metricType);
List<List<Byte>> vectorsToSearch = new ArrayList<>();
for (ByteBuffer byteBuffer : queryVectors) {
byte[] b = new byte[byteBuffer.remaining()];
byteBuffer.get(b);
vectorsToSearch.add(Arrays.asList(ArrayUtils.toObject(b)));
}
fieldParam.put("query", vectorsToSearch);
fieldParam.put("type", Constants.binaryVectorType);
JSONObject tmpSearchParam = new JSONObject();
tmpSearchParam.put("nprobe", nprobe);
fieldParam.put("params", tmpSearchParam);
JSONObject vectorParams = new JSONObject();
vectorParams.put(Constants.binaryVectorFieldName, fieldParam);
searchParam.put("vector", vectorParams);
return searchParam;
}
public static Map<String, List> genDefaultEntities(int vectorCount, List<List<Float>> vectors){
// Map<String,Object> fieldsMap = genDefaultFields(dimension, false);
Map<String, List> fieldsMap =new HashMap<>();
List<Long> intValues = new ArrayList<>(vectorCount);
List<Float> floatValues = new ArrayList<>(vectorCount);
for (int i = 0; i < vectorCount; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
fieldsMap.put(Constants.intFieldName,intValues);
fieldsMap.put(Constants.floatFieldName,floatValues);
fieldsMap.put(Constants.floatVectorFieldName,vectors);
return fieldsMap;
}
public static String setSearchParam(
MetricType metricType, List<List<Float>> queryVectors, int topk, int nprobe) {
JSONObject searchParam = genVectorParam(metricType, queryVectors, topk, nprobe);
JSONObject boolParam = new JSONObject();
JSONObject mustParam = new JSONObject();
JSONArray tmp = new JSONArray();
tmp.add(searchParam);
mustParam.put("must", tmp);
boolParam.put("bool", mustParam);
return JSONObject.toJSONString(boolParam);
}
public static Map<String, List> genDefaultBinaryEntities(int vectorCount, List<ByteBuffer> vectorsBinary){
// List<Map<String,Object>> binaryFieldsMap = genDefaultFields(dimension, true);
Map<String, List> binaryFieldsMap =new HashMap<>();
List<Long> intValues = new ArrayList<>(vectorCount);
List<Float> floatValues = new ArrayList<>(vectorCount);
for (int i = 0; i < vectorCount; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
binaryFieldsMap.put(Constants.intFieldName,intValues);
binaryFieldsMap.put(Constants.floatFieldName,floatValues);
binaryFieldsMap.put(Constants.binaryVectorFieldName,vectorsBinary);
return binaryFieldsMap;
}
public static String setBinarySearchParam(
MetricType metricType, List<ByteBuffer> queryVectors, int topk, int nprobe) {
JSONObject searchParam = genBinaryVectorParam(metricType, queryVectors, topk, nprobe);
JSONObject boolParam = new JSONObject();
JSONObject mustParam = new JSONObject();
JSONArray tmp = new JSONArray();
tmp.add(searchParam);
mustParam.put("must", tmp);
boolParam.put("bool", mustParam);
return JSONObject.toJSONString(boolParam);
}
public static String setIndexParam(String indexType, String metricType, int nlist) {
// ("{\"index_type\": \"IVF_SQ8\", \"metric_type\": \"L2\", \"\"params\": {\"nlist\": 2048}}")
// JSONObject indexParam = new JSONObject();
// indexParam.put("nlist", nlist);
// return JSONObject.toJSONString(indexParam);
String indexParams = String.format("{\"index_type\": %s, \"metric_type\": %s, \"params\": {\"nlist\": %s}}", indexType, metricType, nlist);
return indexParams;
}
public static int getIndexParamValue(String indexParam, String key) {
return JSONObject.parseObject(indexParam).getIntValue(key);
}
static JSONObject genVectorParam(MetricType metricType, List<List<Float>> queryVectors, int topk, int nprobe) {
JSONObject searchParam = new JSONObject();
JSONObject fieldParam = new JSONObject();
fieldParam.put("topk", topk);
fieldParam.put("metric_type", metricType);
fieldParam.put("query", queryVectors);
fieldParam.put("type", Constants.vectorType);
JSONObject tmpSearchParam = new JSONObject();
tmpSearchParam.put("nprobe", nprobe);
fieldParam.put("params", tmpSearchParam);
JSONObject vectorParams = new JSONObject();
vectorParams.put(Constants.floatVectorFieldName, fieldParam);
searchParam.put("vector", vectorParams);
return searchParam;
}
public static JSONObject getCollectionInfo(String collectionInfo) {
return JSONObject.parseObject(collectionInfo);
}
static JSONObject genBinaryVectorParam(MetricType metricType, List<ByteBuffer> queryVectors, int topk, int nprobe) {
JSONObject searchParam = new JSONObject();
JSONObject fieldParam = new JSONObject();
fieldParam.put("topk", topk);
fieldParam.put("metric_type", metricType);
List<List<Byte>> vectorsToSearch = new ArrayList<>();
for (ByteBuffer byteBuffer : queryVectors) {
byte[] b = new byte[byteBuffer.remaining()];
byteBuffer.get(b);
vectorsToSearch.add(Arrays.asList(ArrayUtils.toObject(b)));
}
fieldParam.put("query", vectorsToSearch);
fieldParam.put("type", Constants.binaryVectorType);
JSONObject tmpSearchParam = new JSONObject();
tmpSearchParam.put("nprobe", nprobe);
fieldParam.put("params", tmpSearchParam);
JSONObject vectorParams = new JSONObject();
vectorParams.put(Constants.binaryVectorFieldName, fieldParam);
searchParam.put("vector", vectorParams);
return searchParam;
}
public static List<Long> toListIds(int id) {
List<Long> ids = new ArrayList<>();
ids.add((long) id);
return ids;
}
public static String setSearchParam(MetricType metricType, List<List<Float>> queryVectors, int topk, int nprobe) {
JSONObject searchParam = genVectorParam(metricType, queryVectors, topk, nprobe);
JSONObject boolParam = new JSONObject();
JSONObject mustParam = new JSONObject();
JSONArray tmp = new JSONArray();
tmp.add(searchParam);
mustParam.put("must", tmp);
boolParam.put("bool", mustParam);
return JSONObject.toJSONString(boolParam);
}
public static List<Long> toListIds(long id) {
List<Long> ids = new ArrayList<>();
ids.add(id);
return ids;
}
public static String setBinarySearchParam(MetricType metricType, List<ByteBuffer> queryVectors, int topk, int nprobe) {
JSONObject searchParam = genBinaryVectorParam(metricType, queryVectors, topk, nprobe);
JSONObject boolParam = new JSONObject();
JSONObject mustParam = new JSONObject();
JSONArray tmp = new JSONArray();
tmp.add(searchParam);
mustParam.put("must", tmp);
boolParam.put("bool", mustParam);
return JSONObject.toJSONString(boolParam);
}
public static int getParam(String params, String key) {
JSONObject jsonObject = JSONObject.parseObject(params);
System.out.println(jsonObject.toString());
Integer value = jsonObject.getInteger(key);
return value;
}
public static int getIndexParamValue(String indexParam, String key) {
return JSONObject.parseObject(indexParam).getIntValue(key);
}
public static JSONObject getCollectionInfo(String collectionInfo) {
return JSONObject.parseObject(collectionInfo);
}
public static List<Long> toListIds(int id) {
List<Long> ids = new ArrayList<>();
ids.add((long)id);
return ids;
}
public static List<Long> toListIds(long id) {
List<Long> ids = new ArrayList<>();
ids.add(id);
return ids;
}
public static int getParam(String params, String key){
JSONObject jsonObject = JSONObject.parseObject(params);
System.out.println(jsonObject.toString());
Integer value = jsonObject.getInteger(key);
return value;
}
public static List<Float> getVector(List<Map<String,Object>> entities, int i){
List<Float> vector = new ArrayList<>();
entities.forEach(entity -> {
if(Constants.floatVectorFieldName.equals(entity.get("field")) && Objects.nonNull(entity.get("values"))){
vector.add(((List<Float>)entity.get("values")).get(i));
}
public static List<Float> getVector(List<Map<String, Object>> entities, int i) {
List<Float> vector = new ArrayList<>();
entities.forEach(
entity -> {
if (Constants.floatVectorFieldName.equals(entity.get("field"))
&& Objects.nonNull(entity.get("values"))) {
vector.add(((List<Float>) entity.get("values")).get(i));
}
});
return vector;
return vector;
}
public static JSONArray parseJsonArray(String message, String type) {
JSONObject jsonObject = JSONObject.parseObject(message);
JSONArray partitionsJsonArray = jsonObject.getJSONArray("partitions");
if ("partitions".equals(type)) return partitionsJsonArray;
JSONArray segmentsJsonArray =
((JSONObject) partitionsJsonArray.get(0)).getJSONArray("segments");
if ("segments".equals(type)) return segmentsJsonArray;
JSONArray filesJsonArray = ((JSONObject) segmentsJsonArray.get(0)).getJSONArray("files");
if ("files".equals(type)) return filesJsonArray;
throw new RuntimeException("unsupported type");
}
public static InsertParam genInsertParam(String collectionName) {
Map<String, List> entities = Constants.defaultEntities;
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(
Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(
Constants.floatVectorFieldName,
DataType.VECTOR_FLOAT,
entities.get(Constants.floatVectorFieldName));
return insertParam;
}
public static InsertParam genBinaryInsertParam(String collectionName) {
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam =
InsertParam.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(
Constants.binaryVectorFieldName,
DataType.VECTOR_BINARY,
Utils.genBinaryVectors(Constants.nb, Constants.dimension));
return insertParam;
}
public static JSONArray parseJsonArray(String message, String type) {
JSONObject jsonObject = JSONObject.parseObject(message);
JSONArray partitionsJsonArray = jsonObject.getJSONArray("partitions");
if ("partitions".equals(type))
return partitionsJsonArray;
JSONArray segmentsJsonArray = ((JSONObject)partitionsJsonArray.get(0)).getJSONArray("segments");
if ("segments".equals(type))
return segmentsJsonArray;
JSONArray filesJsonArray = ((JSONObject)segmentsJsonArray.get(0)).getJSONArray("files");
if ("files".equals(type))
return filesJsonArray;
throw new RuntimeException("unsupported type");
public static CollectionMapping genCreateCollectionMapping(
String collectionName, Boolean autoId, Boolean isBinary) {
CollectionMapping cm =
CollectionMapping.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64)
.addField(Constants.floatFieldName, DataType.FLOAT)
.setParamsInJson(
new JsonBuilder()
.param("segment_row_limit", Constants.segmentRowLimit)
.param("auto_id", autoId)
.build());
if (isBinary) {
cm.addVectorField(
Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, Constants.dimension);
} else {
cm.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, Constants.dimension);
}
return cm;
}
public static InsertParam genInsertParam(String collectionName) {
Map<String, List> entities = Constants.defaultEntities;
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, entities.get(Constants.intFieldName))
.addField(Constants.floatFieldName, DataType.FLOAT, entities.get(Constants.floatFieldName))
.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, entities.get(Constants.floatVectorFieldName));
return insertParam;
}
public static List<Long> initData(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), Constants.nb);
return ids;
}
public static InsertParam genBinaryInsertParam(String collectionName) {
List<Long> intValues = new ArrayList<>(Constants.nb);
List<Float> floatValues = new ArrayList<>(Constants.nb);
for (int i = 0; i < Constants.nb; ++i) {
intValues.add((long) i);
floatValues.add((float) i);
}
InsertParam insertParam = InsertParam
.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64, intValues)
.addField(Constants.floatFieldName, DataType.FLOAT, floatValues)
.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, Utils.genBinaryVectors(Constants.nb, Constants.dimension));
return insertParam;
}
public static List<Long> initBinaryData(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genBinaryInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), Constants.nb);
return ids;
}
public static CollectionMapping genCreateCollectionMapping(String collectionName, Boolean autoId, Boolean isBinary) {
CollectionMapping cm = CollectionMapping.create(collectionName)
.addField(Constants.intFieldName, DataType.INT64)
.addField(Constants.floatFieldName, DataType.FLOAT)
.setParamsInJson(new JsonBuilder()
.param("segment_row_limit", Constants.segmentRowLimit)
.param("auto_id", autoId)
.build());
if (isBinary) {
cm.addVectorField(Constants.binaryVectorFieldName, DataType.VECTOR_BINARY, Constants.dimension);
} else {
cm.addVectorField(Constants.floatVectorFieldName, DataType.VECTOR_FLOAT, Constants.dimension);
}
return cm;
}
////////////////////////////////////////////////////////////////////////
public static List<Long> initData(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), Constants.nb);
return ids;
}
public static List<Long> initBinaryData(MilvusClient client, String collectionName) {
InsertParam insertParam = Utils.genBinaryInsertParam(collectionName);
List<Long> ids = client.insert(insertParam);
client.flush(collectionName);
Assert.assertEquals(client.countEntities(collectionName), Constants.nb);
return ids;
}
////////////////////////////////////////////////////////////////////////
// public static CollectionMapping genDefaultCollectionMapping(String collectionName, int dimension,
// int segmentRowCount, boolean isBinary) {
// Map<String, Object> vectorFieldMap;
// if (isBinary) {
// vectorFieldMap = new FieldBuilder("binary_vector", DataType.VECTOR_BINARY)
// .param("dim", dimension)
// .build();
// } else {
// vectorFieldMap = new FieldBuilder("float_vector", DataType.VECTOR_FLOAT)
// .param("dim", dimension)
// .build();
// }
//
// return new CollectionMapping.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64).build())
// .field(new FieldBuilder("float", DataType.FLOAT).build())
// .field(vectorFieldMap)
// .withParamsInJson(new JsonBuilder()
// .param("segment_row_count", segmentRowCount)
// .build())
// .build();
// }
//
// public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int vectorCount,
// List<List<Float>> vectors) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT)
// .values(vectors)
// .param("dim", dimension)
// .build())
// .build();
// }
//
// public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int vectorCount,
// List<List<Float>> vectors, List<Long> entityIds) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT)
// .values(vectors)
// .param("dim", dimension)
// .build())
// .withEntityIds(entityIds)
// .build();
// }
//
// public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int vectorCount,
// List<List<Float>> vectors, String tag) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT)
// .values(vectors)
// .param("dim", dimension)
// .build())
// .withPartitionTag(tag)
// .build();
// }
//
// public static InsertParam genDefaultBinaryInsertParam(String collectionName, int dimension, int vectorCount,
// List<List<Byte>> vectorsBinary) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY)
// .values(vectorsBinary)
// .param("dim", dimension)
// .build())
// .build();
// }
//
// public static InsertParam genDefaultBinaryInsertParam(String collectionName, int dimension, int vectorCount,
// List<List<Byte>> vectorsBinary, List<Long> entityIds) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY)
// .values(vectorsBinary)
// .param("dim", dimension)
// .build())
// .withEntityIds(entityIds)
// .build();
// }
//
// public static InsertParam genDefaultBinaryInsertParam(String collectionName, int dimension, int vectorCount,
// List<List<Byte>> vectorsBinary, String tag) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY)
// .values(vectorsBinary)
// .param("dim", dimension)
// .build())
// .withPartitionTag(tag)
// .build();
// }
//
// public static Index genDefaultIndex(String collectionName, String fieldName, String indexType, String metricType, int nlist) {
// return new Index.Builder(collectionName, fieldName)
// .withParamsInJson(new JsonBuilder()
// .param("index_type", indexType)
// .param("metric_type", metricType)
// .indexParam("nlist", nlist)
// .build())
// .build();
// }
// public static CollectionMapping genDefaultCollectionMapping(String collectionName, int
// dimension,
// int segmentRowCount, boolean
// isBinary) {
// Map<String, Object> vectorFieldMap;
// if (isBinary) {
// vectorFieldMap = new FieldBuilder("binary_vector", DataType.VECTOR_BINARY)
// .param("dim", dimension)
// .build();
// } else {
// vectorFieldMap = new FieldBuilder("float_vector", DataType.VECTOR_FLOAT)
// .param("dim", dimension)
// .build();
// }
//
// return new CollectionMapping.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64).build())
// .field(new FieldBuilder("float", DataType.FLOAT).build())
// .field(vectorFieldMap)
// .withParamsInJson(new JsonBuilder()
// .param("segment_row_count", segmentRowCount)
// .build())
// .build();
// }
//
// public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int
// vectorCount,
// List<List<Float>> vectors) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT)
// .values(vectors)
// .param("dim", dimension)
// .build())
// .build();
// }
//
// public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int
// vectorCount,
// List<List<Float>> vectors, List<Long>
// entityIds) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT)
// .values(vectors)
// .param("dim", dimension)
// .build())
// .withEntityIds(entityIds)
// .build();
// }
//
// public static InsertParam genDefaultInsertParam(String collectionName, int dimension, int
// vectorCount,
// List<List<Float>> vectors, String tag) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("float_vector", DataType.VECTOR_FLOAT)
// .values(vectors)
// .param("dim", dimension)
// .build())
// .withPartitionTag(tag)
// .build();
// }
//
// public static InsertParam genDefaultBinaryInsertParam(String collectionName, int
// dimension, int vectorCount,
// List<List<Byte>> vectorsBinary) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY)
// .values(vectorsBinary)
// .param("dim", dimension)
// .build())
// .build();
// }
//
// public static InsertParam genDefaultBinaryInsertParam(String collectionName, int
// dimension, int vectorCount,
// List<List<Byte>> vectorsBinary,
// List<Long> entityIds) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY)
// .values(vectorsBinary)
// .param("dim", dimension)
// .build())
// .withEntityIds(entityIds)
// .build();
// }
//
// public static InsertParam genDefaultBinaryInsertParam(String collectionName, int
// dimension, int vectorCount,
// List<List<Byte>> vectorsBinary,
// String tag) {
// List<Long> intValues = new ArrayList<>(vectorCount);
// List<Float> floatValues = new ArrayList<>(vectorCount);
// for (int i = 0; i < vectorCount; ++i) {
// intValues.add((long) i);
// floatValues.add((float) i);
// }
//
// return new InsertParam.Builder(collectionName)
// .field(new FieldBuilder("int64", DataType.INT64)
// .values(intValues)
// .build())
// .field(new FieldBuilder("float", DataType.FLOAT)
// .values(floatValues)
// .build())
// .field(new FieldBuilder("binary_vector", DataType.VECTOR_BINARY)
// .values(vectorsBinary)
// .param("dim", dimension)
// .build())
// .withPartitionTag(tag)
// .build();
// }
//
// public static Index genDefaultIndex(String collectionName, String fieldName, String
// indexType, String metricType, int nlist) {
// return new Index.Builder(collectionName, fieldName)
// .withParamsInJson(new JsonBuilder()
// .param("index_type", indexType)
// .param("metric_type", metricType)
// .indexParam("nlist", nlist)
// .build())
// .build();
// }
}