IntenseFinance/nosqlbench
3
0
Fork 0
mirror of https://github.com/nosqlbench/nosqlbench.git synced 2025-02-25 18:55:28 -06:00
Code Issues Packages Projects Releases Wiki Activity

Jshook/verification (#2107)

Browse Source 
* docs update

* typos

* disable noisy prom exposition dump

* fix refkey bug

* move specs into non-test namespace

* remove unimplemented rainbow ops

* docs updates

* give credit to maintainers

* update milvus module to build clean on new APIs

* remove var keyword

* API remapping

* enable new op behaviors
This commit is contained in:
Jonathan Shook 2024-12-10 15:41:05 -06:00 committed by GitHub
parent 5fcc3b27fd
commit ca38a710c3
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
184 changed files with 4052 additions and 2209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
mvn-defaults/pom.xml
View File

@ -835,6 +835,22 @@
<organization>nosqlbench.io</organization> <organization>nosqlbench.io</organization>
<organizationUrl>https://nosqlbench.io/</organizationUrl> <organizationUrl>https://nosqlbench.io/</organizationUrl>
</developer> </developer>
<developer>
<name>Madhavan Sridharan</name>
<organization>nosqlbench.io</organization>
<organizationUrl>https://nosqlbench.io/</organizationUrl>
</developer>
<developer>
<name>Dave Fisher</name>
<organization>nosqlbench.io</organization>
<organizationUrl>https://nosqlbench.io/</organizationUrl>
</developer>
<developer>
<name>Mark Wolters</name>
<organization>nosqlbench.io</organization>
<organizationUrl>https://nosqlbench.io/</organizationUrl>
</developer>
</developers> </developers>
<distributionManagement> <distributionManagement>

2
nb-adapters/adapter-amqp/src/main/java/io/nosqlbench/adapter/amqp/AmqpOpMapper.java
View File

@ -43,7 +43,7 @@ public class AmqpOpMapper implements OpMapper<AmqpTimeTrackOp,AmqpSpace> {
} }
@Override @Override
public OpDispenser<AmqpTimeTrackOp> apply(NBComponent adapterC, ParsedOp op, LongFunction spaceInitF) { public OpDispenser<AmqpTimeTrackOp> apply(NBComponent adapterC, ParsedOp op, LongFunction spaceF) {
//public OpDispenser<AmqpTimeTrackOp> apply(ParsedOp op, LongFunction<AmqpTimeTrackOp> spaceInitF) { //public OpDispenser<AmqpTimeTrackOp> apply(ParsedOp op, LongFunction<AmqpTimeTrackOp> spaceInitF) {
int spaceName = op.getStaticConfigOr("space", 0); int spaceName = op.getStaticConfigOr("space", 0);

4
nb-adapters/adapter-azure-aisearch/src/main/java/io/nosqlbench/adapter/azureaisearch/AzureAISearchOpMapper.java
View File

@ -57,12 +57,12 @@ public class AzureAISearchOpMapper implements OpMapper<AzureAISearchBaseOp<?,?>,
* @param adapterC * @param adapterC
* @param op * @param op
* The {@link ParsedOp} to be evaluated * The {@link ParsedOp} to be evaluated
* @param spaceInitF * @param spaceF
* @return The correct {@link AzureAISearchBaseOpDispenser} subclass based on * @return The correct {@link AzureAISearchBaseOpDispenser} subclass based on
* the op type * the op type
*/ */
@Override @Override
public OpDispenser<AzureAISearchBaseOp<?,?>> apply(NBComponent adapterC, ParsedOp op, LongFunction<AzureAISearchSpace> spaceInitF) { public OpDispenser<AzureAISearchBaseOp<?,?>> apply(NBComponent adapterC, ParsedOp op, LongFunction<AzureAISearchSpace> spaceF) {
TypeAndTarget<AzureAISearchOpType, String> typeAndTarget = op.getTypeAndTarget(AzureAISearchOpType.class, TypeAndTarget<AzureAISearchOpType, String> typeAndTarget = op.getTypeAndTarget(AzureAISearchOpType.class,
String.class, "type", "target"); String.class, "type", "target");

24
nb-adapters/adapter-azure-aisearch/src/main/java/io/nosqlbench/adapter/azureaisearch/AzureAISearchSpace.java
View File

@ -79,21 +79,23 @@ public class AzureAISearchSpace extends BaseSpace<AzureAISearchSpace> {
private SearchIndexClient createSearchClients() { private SearchIndexClient createSearchClients() {
String uri = cfg.get("endpoint"); String uri = cfg.get("endpoint");
var requiredToken = cfg.getOptional("token_file").map(Paths::get).map(tokenFilePath -> { String requiredToken = cfg.getOptional("token_file").map(Paths::get).map(tokenFilePath -> {
try { try {
return Files.readAllLines(tokenFilePath).getFirst(); return Files.readAllLines(tokenFilePath).getFirst();
} catch (IOException e) { } catch (IOException e) {
String error = "Error while reading token from file:" + tokenFilePath; String error = "Error while reading token from file:" + tokenFilePath;
logger.error(error, e); logger.error(error, e);
throw new RuntimeException(e); throw new RuntimeException(e);
} }
}).orElseGet(() -> cfg.getOptional("token").orElseThrow(() -> new RuntimeException( }).orElseGet(() -> cfg.getOptional("token").orElse(null));
"You must provide either a 'token_file' or a 'token' to configure a Azure AI Search client"))); // .orElseThrow(() -> new RuntimeException(
// "You must provide either a 'token_file' or a 'token' to configure a Azure AI Search client")));
logger.info(() -> "Creating new Azure AI Search Client with (masked) token/key [" logger.info(() -> "Creating new Azure AI Search Client with (masked) token/key ["
+ AzureAISearchAdapterUtils.maskDigits(requiredToken) + "], uri/endpoint [" + uri + "]"); + AzureAISearchAdapterUtils.maskDigits(requiredToken) + "], uri/endpoint [" + uri + "]");
var searchIndexClientBuilder = new SearchIndexClientBuilder().endpoint(uri); SearchIndexClientBuilder searchIndexClientBuilder = new SearchIndexClientBuilder().endpoint(
uri);
if (!requiredToken.isBlank()) { if (!requiredToken.isBlank()) {
searchIndexClientBuilder = searchIndexClientBuilder.credential(new AzureKeyCredential(requiredToken)); searchIndexClientBuilder = searchIndexClientBuilder.credential(new AzureKeyCredential(requiredToken));
} else { } else {

2
nb-adapters/adapter-azure-aisearch/src/main/java/io/nosqlbench/adapter/azureaisearch/opsdispenser/AzureAISearchUploadDocumentsOpDispenser.java
View File

@ -66,7 +66,7 @@ public class AzureAISearchUploadDocumentsOpDispenser extends AzureAISearchBaseOp
private LongFunction<SearchDocument> buildFieldsStruct(LongFunction<Map> fieldsFunction) { private LongFunction<SearchDocument> buildFieldsStruct(LongFunction<Map> fieldsFunction) {
return l -> { return l -> {
Map<String, Object> fields = fieldsFunction.apply(l); Map<String, Object> fields = fieldsFunction.apply(l);
var doc = new SearchDocument(); SearchDocument doc = new SearchDocument();
fields.forEach((key, val) -> { fields.forEach((key, val) -> {
doc.put(key, val); doc.put(key, val);
}); });

8
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/Cqld4DriverAdapter.java
View File

@ -18,6 +18,9 @@ package io.nosqlbench.adapter.cqld4;
import io.nosqlbench.adapter.cqld4.opmappers.Cqld4CoreOpMapper; import io.nosqlbench.adapter.cqld4.opmappers.Cqld4CoreOpMapper;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp; import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
import io.nosqlbench.adapter.cqld4.validators.Cqld4SingleRowValidator;
import io.nosqlbench.adapters.api.activityimpl.uniform.Validator;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.nosqlbench.nb.api.config.standard.NBConfigModel; import io.nosqlbench.nb.api.config.standard.NBConfigModel;
import io.nosqlbench.nb.api.config.standard.NBConfiguration; import io.nosqlbench.nb.api.config.standard.NBConfiguration;
import io.nosqlbench.adapters.api.activityimpl.OpMapper; import io.nosqlbench.adapters.api.activityimpl.OpMapper;
@ -29,10 +32,7 @@ import io.nosqlbench.nb.annotations.Service;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import java.util.ArrayList; import java.util.*;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function; import java.util.function.Function;
import java.util.function.LongFunction; import java.util.function.LongFunction;

4
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4BatchStmtMapper.java
View File

@ -41,10 +41,10 @@ public class CqlD4BatchStmtMapper<RESULT extends List<? extends Row>> extends Cq
} }
@Override @Override
public OpDispenser<Cqld4CqlBatchStatement> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceInitF) { public OpDispenser<Cqld4CqlBatchStatement> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceF) {
ParsedOp subop = op.getAsSubOp("op_template", ParsedOp.SubOpNaming.ParentAndSubKey); ParsedOp subop = op.getAsSubOp("op_template", ParsedOp.SubOpNaming.ParentAndSubKey);
int repeat = op.getStaticValue("repeat"); int repeat = op.getStaticValue("repeat");
OpDispenser<Cqld4CqlOp> od = new Cqld4CqlOpMapper(adapter).apply(adapterC, op, spaceInitF); OpDispenser<Cqld4CqlOp> od = new Cqld4CqlOpMapper(adapter).apply(adapterC, op, spaceF);
return new CqlD4BatchStmtDispenser(adapter, op, repeat, subop, od); return new CqlD4BatchStmtDispenser(adapter, op, repeat, subop, od);
} }

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4CqlSimpleStmtMapper.java
View File

@ -36,7 +36,7 @@ public class CqlD4CqlSimpleStmtMapper extends Cqld4CqlBaseOpMapper<Cqld4CqlSimpl
} }
@Override @Override
public OpDispenser<Cqld4CqlSimpleStatement> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceInitF) { public OpDispenser<Cqld4CqlSimpleStatement> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceF) {
return new Cqld4SimpleCqlStmtDispenser(adapter, targetFunction, op); return new Cqld4SimpleCqlStmtDispenser(adapter, targetFunction, op);
} }

70
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4OpType.java
View File

@ -18,65 +18,61 @@ package io.nosqlbench.adapter.cqld4.opmappers;
public enum CqlD4OpType { public enum CqlD4OpType {
/** // uses [[com.datastax.oss.driver.api.core.cql.SimpleStatement]]
* uses {@link com.datastax.oss.driver.api.core.cql.SimpleStatement} // **does not** parameterize values via the SimpleStatement API.
* <em>does not</em> parameterize values via the SimpleStatement API. // Pre-renderes the statement string with values included. This is not
* Pre-renderes the statement string with values included. This is not // efficient nor recommended for production use, although it is useful
* efficient nor recommended for production use, although it is useful // for certain testing scenarios in which you need to create a lot
* for certain testing scenarios in which you need to create a lot // of DDL or other statements which require non-parameterizable fields
* of DDL or other statements which require non-parameterizable fields // to be present in binding values.
* to be present in binding values.
*/
raw, raw,
/** // uses [[com.datastax.oss.driver.api.core.cql.SimpleStatement]]
* uses {@link com.datastax.oss.driver.api.core.cql.SimpleStatement} // This parameterizes values and applies them as positional fields,
* This parameterizes values and applies them as positional fields, // where the binding points are aligned by binding name.
* where the binding points are aligned by binding name. //
*/
simple, simple,
/** // uses [[com.datastax.oss.driver.api.core.cql.PreparedStatement]]
* uses {@link com.datastax.oss.driver.api.core.cql.SimpleStatement} // This type does everything that the {@link #simple} mode does, and
* This type does everything that the {@link #simple} mode does, and // additionally uses prepared statements.
* additionally uses prepared statements.
*/
prepared, prepared,
/** // uses [[com.datastax.oss.driver.api.core.cql.BatchStatement]]
* Allows for a statement template to be used to create a batch statement. // Allows for a statement template to be used to create a batch statement.
* The fields 'op_template', and 'repeat' are required, and all fields below // The fields 'op_template', and 'repeat' are required, and all fields below
* the op_template field are a nested version of the other op types here, but // the op_template field are a nested version of the other op types here, but
* supports only the simple and prepared forms for historic compatibility reasons. // supports only the simple and prepared forms for historic compatibility reasons.
*/
batch, batch,
/** // This reads rows of data and verifies data and structure according to what
* uses {@link com.datastax.dse.driver.api.core.graph.ScriptGraphStatement} // would have been written according to the original bindings.
* This is the "raw" mode of using gremlin. It is not as efficient, and thus verify,
* is only recommended for testing or legacy apps.
*/ // uses [[com.datastax.dse.driver.api.core.graph.ScriptGraphStatement]]
// This is the "raw" mode of using gremlin. It is not as efficient, and thus
// is only recommended for testing or legacy apps.
gremlin, gremlin,
/** /**
* uses {@link com.datastax.dse.driver.api.core.graph.FluentGraphStatement} * uses [[com.datastax.dse.driver.api.core.graph.FluentGraphStatement]]
* This mode is the recommended mode for gremlin execution. It uses the fluent * This mode is the recommended mode for gremlin execution. It uses the fluent
* API on the client side. The fluent syntax is compiled and cached as bytecode * API on the client side. The fluent syntax is compiled and cached as bytecode
* within a per-thread execution environment (for each op template). For each * within a per-thread execution environment (for each op template). For each
* cycle, the bindings are rendered, injected into that execution environment, * cycle, the bindings are rendered, injected into that execution environment,
* and then the bytecode is executed to render the current operation, which is * and then the bytecode is executed to render the current operation, which is
* then sent to the server. Although this is arguably more involved, the result * then sent to the server. Although this is arguably more involved, the result
* is quite efficient and provides the closes idiomatic experience <em>AND</em> * is quite efficient and provides the closes idiomatic experience **AND**
* the best performance. * the best performance.
* *
* <p>This is the mode that is recommended for all graph usage.</p> * This is the mode that is recommended for all graph usage.
*/ */
fluent, fluent,
/** // /**
* reserved for future use // * reserved for future use
*/ // */
rainbow, // rainbow,
// /** // /**
// * reserved for future use // * reserved for future use
// */ // */

4
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4PreparedStmtMapper.java
View File

@ -47,7 +47,7 @@ public class CqlD4PreparedStmtMapper extends Cqld4CqlBaseOpMapper<Cqld4CqlPrepar
public OpDispenser<Cqld4CqlPreparedStatement> apply( public OpDispenser<Cqld4CqlPreparedStatement> apply(
NBComponent adapterC, NBComponent adapterC,
ParsedOp op, ParsedOp op,
LongFunction<Cqld4Space> spaceInitF LongFunction<Cqld4Space> spaceF
) { ) {
ParsedTemplateString stmtTpl = op.getAsTemplate(target.field).orElseThrow(() -> new BasicError( ParsedTemplateString stmtTpl = op.getAsTemplate(target.field).orElseThrow(() -> new BasicError(
"No statement was found in the op template:" + op "No statement was found in the op template:" + op
@ -68,7 +68,7 @@ public class CqlD4PreparedStmtMapper extends Cqld4CqlBaseOpMapper<Cqld4CqlPrepar
}); });
}); });
return new Cqld4PreparedStmtDispenser(adapter, op, stmtTpl, processors, spaceInitF); return new Cqld4PreparedStmtDispenser(adapter, op, stmtTpl, processors, spaceF);
} }
} }

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RainbowTableMapper.java
View File

@ -41,7 +41,7 @@ public class CqlD4RainbowTableMapper<CO extends Cqld4RainbowTableOp> extends Cql
} }
@Override @Override
public OpDispenser<Cqld4RainbowTableOp> apply(NBComponent adapterC, ParsedOp op, LongFunction spaceInitF) { public OpDispenser<Cqld4RainbowTableOp> apply(NBComponent adapterC, ParsedOp op, LongFunction spaceF) {
return null; return null;
// return new CqlD4RainbowTableDispenser(adapter, sessionFunc,targetFunction, op); // return new CqlD4RainbowTableDispenser(adapter, sessionFunc,targetFunction, op);
} }

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RawStmtMapper.java
View File

@ -35,7 +35,7 @@ public class CqlD4RawStmtMapper extends Cqld4CqlBaseOpMapper<Cqld4CqlSimpleState
} }
@Override @Override
public OpDispenser<Cqld4CqlSimpleStatement> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceInitF) { public OpDispenser<Cqld4CqlSimpleStatement> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceF) {
return new Cqld4RawStmtDispenser(adapter, targetFunction,op); return new Cqld4RawStmtDispenser(adapter, targetFunction,op);
} }

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4BaseOpMapper.java
View File

@ -38,5 +38,5 @@ public abstract class Cqld4BaseOpMapper<T extends Cqld4BaseOp<?>> implements OpM
} }
@Override @Override
public abstract OpDispenser<T> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceInitF); public abstract OpDispenser<T> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceF);
} }

4
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CoreOpMapper.java
View File

@ -61,8 +61,8 @@ public class Cqld4CoreOpMapper extends Cqld4BaseOpMapper<Cqld4BaseOp<?>> {
case raw, simple, prepared, batch -> new Cqld4CqlOpMapper(adapter).apply(adapterC, op, spaceF); case raw, simple, prepared, batch -> new Cqld4CqlOpMapper(adapter).apply(adapterC, op, spaceF);
case gremlin -> new Cqld4GremlinOpMapper(adapter, target.targetFunction).apply(adapterC, op, spaceF); case gremlin -> new Cqld4GremlinOpMapper(adapter, target.targetFunction).apply(adapterC, op, spaceF);
case fluent -> new Cqld4FluentGraphOpMapper(adapter, target).apply(adapterC, op, spaceF); case fluent -> new Cqld4FluentGraphOpMapper(adapter, target).apply(adapterC, op, spaceF);
case rainbow -> // case rainbow ->
new CqlD4RainbowTableMapper(adapter, spaceF, target.targetFunction).apply(adapterC, op, spaceF); // new CqlD4RainbowTableMapper(adapter, spaceF, target.targetFunction).apply(adapterC, op, spaceF);
default -> throw new OpConfigError("Unsupported op type " + opType); default -> throw new OpConfigError("Unsupported op type " + opType);
// case sst -> new Cqld4SsTableMapper(adapter, sessionFunc, target.targetFunction).apply(op); // case sst -> new Cqld4SsTableMapper(adapter, sessionFunc, target.targetFunction).apply(op);
}; };

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CqlBaseOpMapper.java
View File

@ -34,6 +34,6 @@ public abstract class Cqld4CqlBaseOpMapper<T extends Cqld4CqlOp> extends Cqld4Ba
} }
@Override @Override
public abstract OpDispenser<T> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceInitF); public abstract OpDispenser<T> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceF);
} }

10
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CqlOpMapper.java
View File

@ -39,7 +39,7 @@ public class Cqld4CqlOpMapper extends Cqld4CqlBaseOpMapper<Cqld4CqlOp> {
} }
@Override @Override
public OpDispenser<Cqld4CqlOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceInitF) { public OpDispenser<Cqld4CqlOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceF) {
CqlD4OpType opType = CqlD4OpType.prepared; CqlD4OpType opType = CqlD4OpType.prepared;
TypeAndTarget<CqlD4OpType, String> target = op.getTypeAndTarget(CqlD4OpType.class, String.class, "type", "stmt"); TypeAndTarget<CqlD4OpType, String> target = op.getTypeAndTarget(CqlD4OpType.class, String.class, "type", "stmt");
logger.info(() -> "Using " + target.enumId + " statement form for '" + op.getName() + "'"); logger.info(() -> "Using " + target.enumId + " statement form for '" + op.getName() + "'");
@ -47,13 +47,13 @@ public class Cqld4CqlOpMapper extends Cqld4CqlBaseOpMapper<Cqld4CqlOp> {
return (OpDispenser<Cqld4CqlOp>) switch (target.enumId) { return (OpDispenser<Cqld4CqlOp>) switch (target.enumId) {
case raw -> { case raw -> {
CqlD4RawStmtMapper cqlD4RawStmtMapper = new CqlD4RawStmtMapper(adapter, target.targetFunction); CqlD4RawStmtMapper cqlD4RawStmtMapper = new CqlD4RawStmtMapper(adapter, target.targetFunction);
OpDispenser<Cqld4CqlSimpleStatement> apply = cqlD4RawStmtMapper.apply(adapterC, op, spaceInitF); OpDispenser<Cqld4CqlSimpleStatement> apply = cqlD4RawStmtMapper.apply(adapterC, op, spaceF);
yield apply; yield apply;
} }
case simple -> new CqlD4CqlSimpleStmtMapper(adapter, target.targetFunction).apply(adapterC, op, spaceInitF); case simple -> new CqlD4CqlSimpleStmtMapper(adapter, target.targetFunction).apply(adapterC, op, spaceF);
case prepared -> new CqlD4PreparedStmtMapper(adapter, target).apply(adapterC, op, spaceInitF); case prepared -> new CqlD4PreparedStmtMapper(adapter, target).apply(adapterC, op, spaceF);
case batch -> new CqlD4BatchStmtMapper(adapter, target).apply(adapterC, op, spaceInitF); case batch -> new CqlD4BatchStmtMapper(adapter, target).apply(adapterC, op, spaceF);
default -> default ->
throw new OpConfigError("Unsupported op type for CQL category of statement forms:" + target.enumId); throw new OpConfigError("Unsupported op type for CQL category of statement forms:" + target.enumId);
}; };

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4FluentGraphOpMapper.java
View File

@ -59,7 +59,7 @@ public class Cqld4FluentGraphOpMapper extends Cqld4BaseOpMapper<Cqld4FluentGraph
} }
@Override @Override
public OpDispenser<Cqld4FluentGraphOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> cqld4SpaceLongFunction) { public OpDispenser<Cqld4FluentGraphOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<Cqld4Space> spaceF) {
GraphTraversalSource g = DseGraph.g; GraphTraversalSource g = DseGraph.g;
ParsedTemplateString fluent = op.getAsTemplate(target.field).orElseThrow(); ParsedTemplateString fluent = op.getAsTemplate(target.field).orElseThrow();

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4GremlinOpMapper.java
View File

@ -33,7 +33,7 @@ public class Cqld4GremlinOpMapper<CO extends Cqld4ScriptGraphOp> extends Cqld4Ba
} }
@Override @Override
public Cqld4GremlinOpDispenser apply(NBComponent adapterC, ParsedOp op, LongFunction spaceInitF) { public Cqld4GremlinOpDispenser apply(NBComponent adapterC, ParsedOp op, LongFunction spaceF) {
return new Cqld4GremlinOpDispenser( return new Cqld4GremlinOpDispenser(
adapter, adapter,
l -> adapter.getSpaceFunc(op).apply(l).getSession(), targetFunction, op); l -> adapter.getSpaceFunc(op).apply(l).getSession(), targetFunction, op);

36
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4CqlOp.java
View File

@ -16,6 +16,7 @@
package io.nosqlbench.adapter.cqld4.optypes; package io.nosqlbench.adapter.cqld4.optypes;
import com.datastax.oss.driver.api.core.CqlIdentifier;
import com.datastax.oss.driver.api.core.CqlSession; import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.*; import com.datastax.oss.driver.api.core.cql.*;
import io.nosqlbench.adapter.cqld4.Cqld4CqlReboundStatement; import io.nosqlbench.adapter.cqld4.Cqld4CqlReboundStatement;
@ -26,14 +27,16 @@ import io.nosqlbench.adapter.cqld4.exceptions.ExceededRetryReplaceException;
import io.nosqlbench.adapter.cqld4.exceptions.UnexpectedPagingException; import io.nosqlbench.adapter.cqld4.exceptions.UnexpectedPagingException;
import io.nosqlbench.adapter.cqld4.instruments.CqlOpMetrics; import io.nosqlbench.adapter.cqld4.instruments.CqlOpMetrics;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.*; import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.*;
import org.apache.commons.lang3.NotImplementedException; import io.nosqlbench.virtdata.core.templates.*;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.concurrent.*; import java.util.concurrent.*;
import java.util.function.Function;
// TODO: add statement filtering // TODO: add statement filtering
@ -47,7 +50,7 @@ import java.util.concurrent.*;
public abstract class Cqld4CqlOp public abstract class Cqld4CqlOp
implements Cqld4BaseOp<List<Row>>, VariableCapture, OpGenerator, OpResultSize { implements Cqld4BaseOp<List<Row>>, UniformVariableCapture<List<Row>>, OpGenerator, OpResultSize {
private final static Logger logger = LogManager.getLogger(Cqld4CqlOp.class); private final static Logger logger = LogManager.getLogger(Cqld4CqlOp.class);
@ -165,8 +168,33 @@ public abstract class Cqld4CqlOp
return next; return next;
} }
public Map<String, ?> capture() { @Override
throw new NotImplementedException("Not implemented for Cqld4CqlOp"); public Function<List<Row>, Map<String, ?>> initCaptureF(CapturePoints<List<Row>> points) {
Function<List<Row>,Map<String,?>> f = (List<Row> result) -> {
if (result.size()!=1) {
throw new CapturePointException("result contained " + result.size() + " rows, required exactly 1");
}
Row row = result.get(0);
ColumnDefinitions coldefs = row.getColumnDefinitions();
Map<String,Object> values = new HashMap<>(coldefs.size());
if (points.isGlob()) {
for (ColumnDefinition coldef : coldefs) {
String colname = coldef.getName().toString();
values.put(colname,row.getObject(colname));
}
} else {
for (CapturePoint<List<Row>> point : points) {
String sourceName = point.getSourceName();
Object value = row.getObject(point.getSourceName());
Object recast = point.getAsCast().cast(value);
values.put(point.getAsName(), recast);
}
}
return values;
};
return f;
} }
public abstract Statement<?> getStmt(); public abstract Statement<?> getStmt();

10
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4RainbowTableOp.java
View File

@ -19,11 +19,8 @@ package io.nosqlbench.adapter.cqld4.optypes;
import com.datastax.oss.driver.api.core.cql.ResultSet; import com.datastax.oss.driver.api.core.cql.ResultSet;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.*; import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.*;
import java.util.Map;
// Need to create RainbowTableStatement // Need to create RainbowTableStatement
public class Cqld4RainbowTableOp public class Cqld4RainbowTableOp implements Cqld4BaseOp<ResultSet>, OpGenerator, OpResultSize {
implements Cqld4BaseOp<ResultSet>, VariableCapture, OpGenerator, OpResultSize {
// private final CqlSession session; // private final CqlSession session;
// private final RainbowTableStatement stmt; // private final RainbowTableStatement stmt;
@ -39,9 +36,4 @@ public class Cqld4RainbowTableOp
throw new RuntimeException("implement me"); throw new RuntimeException("implement me");
} }
@Override
public Map<String, ?> capture() {
throw new RuntimeException("implement me");
}
} }

35
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/validators/Cqld4SingleRowValidator.java Normal file
View File

@ -0,0 +1,35 @@
package io.nosqlbench.adapter.cqld4.validators;
/*
* Copyright (c) nosqlbench
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import com.datastax.oss.driver.api.core.cql.Row;
import io.nosqlbench.adapters.api.activityimpl.uniform.Validator;
import java.util.List;
public class Cqld4SingleRowValidator implements Validator<List<Row>> {
public Cqld4SingleRowValidator() {
}
@Override
public void validate(List<Row> rows) {
System.out.println("validating rows...");
}
}

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/cqlgen/core/CGWorkloadExporter.java
View File

@ -536,7 +536,7 @@ public class CGWorkloadExporter implements BundledApp {
pkeys.pop(); pkeys.pop();
} }
} }
var lastcount = keycount; int lastcount = keycount;
keycount = Math.max(table.getPartitionKeys().size(), keycount); keycount = Math.max(table.getPartitionKeys().size(), keycount);
if (keycount != lastcount) { if (keycount != lastcount) {
logger.debug("minimum keycount for " + table.getFullName() + " adjusted from " + lastcount + " to " + keycount); logger.debug("minimum keycount for " + table.getFullName() + " adjusted from " + lastcount + " to " + keycount);

162
nb-adapters/adapter-cqld4/src/main/resources/cqlverify.md Normal file
View File

@ -0,0 +1,162 @@
# CQL Verify
The cqld4 adapter has the capability to verify data in a database by reading each row and comparing
it with reference data. The reference data is simply the same data which you might use to generate
data for upsert, modeled with standard bindings. Thus, you can assert the correctness of any (whole
or part of) data within a database for which you have data bindings. For the most common case --
writing and then verifying data, the same bindings are used for both phases.
It allows you to read values from a database and compare them to the generated values that were
expected to be written, row-by-row, producing a comparative result between the two.
If you specify `verify` as the op type with the cqld4 adapter, then it will do the following:
1. Presume that the op structure is effectively a read operation, meaning it will produce a result
that can be used for comparison. The operation must have a single row in the result set. If there
is no row, then the row fails validation. The same happens if there is more than one row.
2. Using the provided bindings, re-generate the data separately which was expected to be in the
database. This is called _reference data_ herein.
3. Verify that the values returned from the database are the same as the reference data, and throw a
ResultVerificationError for each mis-matching row.
Alternately, you can add the verify and compare options to any regular CQL statement (Simple, Raw,
Prepared) in order to enable this verification logic.
## Verification Options
These options may be attached to an op template directly as op fields, or they may be passed as
activity parameters. NOTE: passing them as activity parameters will only work if all of the active
operations are compatible with the verify options.
- **verify** - an optional modifier of fields to verify for a statement. If this parameter is not
provided, then it is presumed to be `*` by default. This is a string which consists of
comma-separate values. This parameter is useful if you have a set of default bindings and want to
specify which subset of them will be used just for this statement. Each form modifies the list of
fields to verify incrementally, and multiple options are allowed:
- `*` : If the value is `*`, then all the bindings that are visible for the statement will be used
as expected values.
- `-`, `-field2` : If it is a word that starts with `-`, like `-field2`, then the name after the
dash is removed from the list of fields to verify.
- `+`, `+field3` : If it is a word that starts with a `+`, like `+field3`, or a simple word, then
the field is added to the list of fields to verify.
- `f->b` : If any of the added fields is in the form `f->b`, then it is taken as a mapping from the
field name `f` in the schema to a binding `b`.
For example,
```yaml
# example op template
ops:
op1:
readit: "select ....TBD"
bindings:
a: ..
b: ..
c: ..
verify: "*,-b"
```
means _verify all fields from the bindings except `b`_, using the default validation method.
- **compare** - what to verify, naming structure, values, etc. each of these is additive, and
multiple can be specified.
- all (the default) - A synonym for fields AND values
- fields - A synonym for rowfields AND reffields (full set equivalence)
- rowfields - Verify that the result field names include every reference field name.
- reffields - Verify that the reference field names include every result field name.
- values - Verify that all the pair-wise fields have equal values, according to the
type-specific `.equals(...)` method for the data type identified in the row metadata by field
name.
For example,
```yaml
# example op template
ops:
op1:
readit: "select ....TBD"
bindings:
a: ..
b: ..
c: ..
verify: "*,-b"
compare: reffields
```
means _ensure reference fields are present in result fields by name but do not throw an error if
there are more result fields present, and do not compare values of same-named fields_.
## Verification Results
### Errors
The data bindings are used to generate the expected values that would be used for an upsert. Each
row is verified according to these values, and any discrepancy is treated as an error that can be
counted, logged, etc. If you want to simply count the occurences instead of fast-failing an activity
when a row is unverified, then you simply need to modify the error handler for that activity: '
errors=unverified=count'.
The default error handling behavior will cause an exception to be thrown and NoSQLBench
will exit by default. If you wish for something less dramatic, then
wire the unverified category to something else:
errors=...,unverified->count
or
errors=...,unverified->warn
### Metrics
The cqlverify activity type adds some verification-specific metrics:
- alias.verified_results - A counter for how many results were verified
- alias.unverified_results - A counter for how many results were not verified
- alias.verified_values - A counter for how many field values were verified
- alias.unverified_values - A counter for how many field values were unverified
## Advanced Usage
The verify capability does not retain logged data for verification. Still, it is able to compare
data as if it had a separate physical data set to compare to. This is possible only because
virtdata (the data generation layer of NoSQLBench) can provide realistic views of virtual datasets
on the fly.
### Avoid Random data
That means, however, that you must avoid using the non-stable data mapping functions when writing
data. The rule of thumb is to avoid using any data mapping functions containing the word "Random".
Binding functions with `random` in their name behave differently from others in that they will not
produce stable results. Their initialization vector is external to the function definition, such as
when using the system _random_ functions.
> Some will bristle at this misuse of the terms, but connotatively they work well for most
> other users. Actually, all of the algorithms used by
> virtdata are __NOT__ truly random, and are deterministic in some way. However, some rely on
> an initialization vector which is not self-contained within the function definition. As such,
> these functions are not pure functions in practice and thus may not be relied upon to return the
> same result from session to session. The word _random_ in virtdata binding functions indicates
> that a function is non-determinstic in some cases. As long as you avoid these functions,
> you can rely on stable generated data from session to session.
### Single vs Multiple Results
TBD
### Paging vs Non-Paging verification
TBD
### Example activity definitions
Write 100K cycles of telemetry data
> TBD ... run driver=cql alias=writesome workload=cql-iot tags=group:write cycles=100000 host=...
Verify the the same 100K cycles of telemetry data
> TBD ... run driver=cqlverify alias=verify workload=cql-iot tags=group:verify cycles=100000
To see how these examples work, TBD

2
nb-adapters/adapter-cqld4/src/test/java/io/nosqlbench/converters/cql/cql/parser/CqlParserHarnessTest.java
View File

@ -52,7 +52,7 @@ public class CqlParserHarnessTest {
CGWorkloadExporter exporter = new CGWorkloadExporter(); CGWorkloadExporter exporter = new CGWorkloadExporter();
exporter.applyAsInt(new String[]{"src/test/resources/testschemas/cql_alltypes.cql","_alltypes.yaml"}); exporter.applyAsInt(new String[]{"src/test/resources/testschemas/cql_alltypes.cql","_alltypes.yaml"});
exporter.setNamingTemplate("[OPTYPE-][COLUMN-][TYPEDEF-][TABLE-]-[KEYSPACE]"); exporter.setNamingTemplate("[OPTYPE-][COLUMN-][TYPEDEF-][TABLE-]-[KEYSPACE]");
var data = exporter.getWorkloadAsYaml(); String data = exporter.getWorkloadAsYaml();
} }

2
nb-adapters/adapter-dataapi/src/main/java/io/nosqlbench/adapter/dataapi/DataApiOpMapper.java
View File

@ -38,7 +38,7 @@ public class DataApiOpMapper implements OpMapper<DataApiBaseOp,DataApiSpace> {
@Override @Override
public OpDispenser<DataApiBaseOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<DataApiSpace> spaceInitF) { public OpDispenser<DataApiBaseOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<DataApiSpace> spaceF) {
//public OpDispenser<DataApiBaseOp> apply(ParsedOp op, LongFunction<DataApiSpace> spaceInitF) { //public OpDispenser<DataApiBaseOp> apply(ParsedOp op, LongFunction<DataApiSpace> spaceInitF) {
TypeAndTarget<DataApiOpType, String> typeAndTarget = op.getTypeAndTarget( TypeAndTarget<DataApiOpType, String> typeAndTarget = op.getTypeAndTarget(
DataApiOpType.class, DataApiOpType.class,

2
nb-adapters/adapter-dynamodb/src/main/java/io/nosqlbench/adapter/dynamodb/DynamoDBOpMapper.java
View File

@ -40,7 +40,7 @@ public class DynamoDBOpMapper implements OpMapper<DynamoDBOp,DynamoDBSpace> {
} }
@Override @Override
public OpDispenser<DynamoDBOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<DynamoDBSpace> spaceInitF) { public OpDispenser<DynamoDBOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<DynamoDBSpace> spaceF) {
int space = op.getStaticConfigOr("space", 0); int space = op.getStaticConfigOr("space", 0);
LongFunction<DynamoDBSpace> spaceFunc = adapter.getSpaceFunc(op); LongFunction<DynamoDBSpace> spaceFunc = adapter.getSpaceFunc(op);
DynamoDB ddb = spaceFunc.apply(space).getDynamoDB(); DynamoDB ddb = spaceFunc.apply(space).getDynamoDB();

12
nb-adapters/adapter-example/src/main/java/io/nosqlbench/adapter/prototype/ExampleOpMapper.java
View File

@ -2,13 +2,13 @@ package io.nosqlbench.adapter.prototype;
/* /*
* Copyright (c) nosqlbench * Copyright (c) nosqlbench
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, * Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an * software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
@ -35,13 +35,13 @@ public class ExampleOpMapper implements OpMapper<ExampleOpType1, ExampleSpace> {
public OpDispenser<ExampleOpType1> apply( public OpDispenser<ExampleOpType1> apply(
NBComponent adapterC, NBComponent adapterC,
ParsedOp pop, ParsedOp pop,
LongFunction<ExampleSpace> spaceInitF LongFunction<ExampleSpace> spaceF
) { ) {
TypeAndTarget<ExampleOpTypes, String> typeAndTarget = pop.getTypeAndTarget(ExampleOpTypes.class, String.class); TypeAndTarget<ExampleOpTypes, String> typeAndTarget = pop.getTypeAndTarget(ExampleOpTypes.class, String.class);
return switch (typeAndTarget.enumId) { return switch (typeAndTarget.enumId) {
case type1 -> new ExampleOpDispenserType1(adapterC, pop, spaceInitF); case type1 -> new ExampleOpDispenserType1(adapterC, pop, spaceF);
case type2 -> new ExampleOpDispenserType1(adapterC, pop, spaceInitF); case type2 -> new ExampleOpDispenserType1(adapterC, pop, spaceF);
}; };
} }

9
nb-adapters/adapter-example/src/main/java/io/nosqlbench/adapter/prototype/ExampleSpace.java
View File

@ -2,13 +2,13 @@ package io.nosqlbench.adapter.prototype;
/* /*
* Copyright (c) nosqlbench * Copyright (c) nosqlbench
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, * Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an * software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
@ -21,6 +21,9 @@ package io.nosqlbench.adapter.prototype;
import io.nosqlbench.adapters.api.activityimpl.uniform.BaseSpace; import io.nosqlbench.adapters.api.activityimpl.uniform.BaseSpace;
import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter; import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
/**
* {@inheritDoc}
*/
public class ExampleSpace extends BaseSpace<ExampleSpace> { public class ExampleSpace extends BaseSpace<ExampleSpace> {
public ExampleSpace(DriverAdapter<?, ExampleSpace> adapter, long idx) { public ExampleSpace(DriverAdapter<?, ExampleSpace> adapter, long idx) {

4
nb-adapters/adapter-gcp-spanner/src/main/java/io/nosqlbench/adapter/gcpspanner/GCPSpannerOpMapper.java
View File

@ -51,12 +51,12 @@ public class GCPSpannerOpMapper implements OpMapper<GCPSpannerBaseOp<?,?>, GCPSp
* @param adapterC * @param adapterC
* @param op * @param op
* The {@link ParsedOp} to be evaluated * The {@link ParsedOp} to be evaluated
* @param spaceInitF * @param spaceF
* @return The correct {@link GCPSpannerBaseOpDispenser} subclass based on * @return The correct {@link GCPSpannerBaseOpDispenser} subclass based on
* the op type * the op type
*/ */
@Override @Override
public OpDispenser<GCPSpannerBaseOp<?,?>> apply(NBComponent adapterC, ParsedOp op, LongFunction<GCPSpannerSpace> spaceInitF) { public OpDispenser<GCPSpannerBaseOp<?,?>> apply(NBComponent adapterC, ParsedOp op, LongFunction<GCPSpannerSpace> spaceF) {
TypeAndTarget<GCPSpannerOpType, String> typeAndTarget = op.getTypeAndTarget(GCPSpannerOpType.class, TypeAndTarget<GCPSpannerOpType, String> typeAndTarget = op.getTypeAndTarget(GCPSpannerOpType.class,
String.class, "type", "target"); String.class, "type", "target");
logger.info(() -> "Using '" + typeAndTarget.enumId + "' op type for op template '" + op.getName() + "'"); logger.info(() -> "Using '" + typeAndTarget.enumId + "' op type for op template '" + op.getName() + "'");

4
nb-adapters/adapter-http/src/main/java/io/nosqlbench/adapter/http/core/HttpOpMapper.java
View File

@ -37,8 +37,8 @@ public class HttpOpMapper implements OpMapper<HttpOp,HttpSpace> {
} }
@Override @Override
public OpDispenser<HttpOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<HttpSpace> spaceInitF) { public OpDispenser<HttpOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<HttpSpace> spaceF) {
LongFunction<String> spaceNameF = op.getAsFunctionOr("space", "default"); LongFunction<String> spaceNameF = op.getAsFunctionOr("space", "default");
return new HttpOpDispenser(adapter, spaceInitF, op); return new HttpOpDispenser(adapter, spaceF, op);
} }
} }

2
nb-adapters/adapter-kafka/src/main/java/io/nosqlbench/adapter/kafka/KafkaOpMapper.java
View File

@ -42,7 +42,7 @@ public class KafkaOpMapper implements OpMapper<KafkaOp,KafkaSpace> {
} }
@Override @Override
public OpDispenser<KafkaOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<KafkaSpace> spaceInitF) { public OpDispenser<KafkaOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<KafkaSpace> spaceF) {
KafkaSpace kafkaSpace = adapter.getSpaceFunc(op).apply(op.getStaticConfigOr("space",0)); KafkaSpace kafkaSpace = adapter.getSpaceFunc(op).apply(op.getStaticConfigOr("space",0));
/* /*

12
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/MilvusDriverAdapter.java
View File

@ -27,6 +27,7 @@ import io.nosqlbench.nb.api.config.standard.NBConfiguration;
import io.nosqlbench.nb.api.labels.NBLabels; import io.nosqlbench.nb.api.labels.NBLabels;
import java.util.function.Function; import java.util.function.Function;
import java.util.function.LongFunction;
import static io.nosqlbench.adapter.milvus.MilvusAdapterUtils.MILVUS; import static io.nosqlbench.adapter.milvus.MilvusAdapterUtils.MILVUS;
@ -38,15 +39,20 @@ public class MilvusDriverAdapter extends BaseDriverAdapter<MilvusBaseOp<?>, Milv
} }
@Override @Override
public OpMapper<MilvusBaseOp<?>> getOpMapper() { public OpMapper<MilvusBaseOp<?>,MilvusSpace> getOpMapper() {
return new MilvusOpMapper(this); return new MilvusOpMapper(this);
} }
@Override @Override
public Function<String, ? extends MilvusSpace> getSpaceInitializer(NBConfiguration cfg) { public LongFunction<MilvusSpace> getSpaceInitializer(NBConfiguration cfg) {
return (s) -> new MilvusSpace(s, cfg); return (idx) -> new MilvusSpace(this, idx, cfg);
} }
// @Override
// public Function<String, ? extends MilvusSpace> getSpaceInitializer(NBConfiguration cfg) {
// return (s) -> new MilvusSpace(s, cfg);
// }
@Override @Override
public NBConfigModel getConfigModel() { public NBConfigModel getConfigModel() {
return super.getConfigModel().add(MilvusSpace.getConfigModel()); return super.getConfigModel().add(MilvusSpace.getConfigModel());

203
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/MilvusOpMapper.java
View File

@ -23,110 +23,157 @@ import io.nosqlbench.adapters.api.activityimpl.OpDispenser;
import io.nosqlbench.adapters.api.activityimpl.OpMapper; import io.nosqlbench.adapters.api.activityimpl.OpMapper;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.nosqlbench.engine.api.templating.TypeAndTarget; import io.nosqlbench.engine.api.templating.TypeAndTarget;
import io.nosqlbench.nb.api.components.core.NBComponent;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
public class MilvusOpMapper implements OpMapper<MilvusBaseOp<?>> { import java.util.function.LongFunction;
public class MilvusOpMapper implements OpMapper<MilvusBaseOp<?>, MilvusSpace> {
private static final Logger logger = LogManager.getLogger(MilvusOpMapper.class); private static final Logger logger = LogManager.getLogger(MilvusOpMapper.class);
private final MilvusDriverAdapter adapter; private final MilvusDriverAdapter adapter;
/** /**
* Create a new MilvusOpMapper implementing the {@link OpMapper} interface. Create a new MilvusOpMapper implementing the {@link OpMapper} interface.
* @param adapter
* @param adapter The associated {@link MilvusDriverAdapter} The associated {@link MilvusDriverAdapter}
*/ */
public MilvusOpMapper(MilvusDriverAdapter adapter) { public MilvusOpMapper(MilvusDriverAdapter adapter) {
this.adapter = adapter; this.adapter = adapter;
} }
/** /**
* Given an instance of a {@link ParsedOp} returns the appropriate {@link MilvusBaseOpDispenser} subclass Given an instance of a {@link ParsedOp} returns the appropriate {@link MilvusBaseOpDispenser}
* subclass
* @param op The {@link ParsedOp} to be evaluated @param op
* @return The correct {@link MilvusBaseOpDispenser} subclass based on the op type The {@link ParsedOp} to be evaluated
@return The correct {@link MilvusBaseOpDispenser} subclass based on the op type
*/ */
@Override @Override
public OpDispenser<? extends MilvusBaseOp<?>> apply(ParsedOp op) { public OpDispenser<? extends MilvusBaseOp<?>> apply(
NBComponent adapterC, ParsedOp op,
LongFunction<MilvusSpace> spaceF
) {
TypeAndTarget<MilvusOpType, String> typeAndTarget = op.getTypeAndTarget( TypeAndTarget<MilvusOpType, String> typeAndTarget = op.getTypeAndTarget(
MilvusOpType.class, MilvusOpType.class,
String.class, String.class,
"type", "type", "target"
"target"
); );
logger.info(() -> "Using '" + typeAndTarget.enumId + "' op type for op template '" + op.getName() + "'"); logger.info(
() -> "Using '" + typeAndTarget.enumId + "' op type for op template '" + op.getName() + "'");
return switch (typeAndTarget.enumId) { return switch (typeAndTarget.enumId) {
case drop_collection -> new MilvusDropCollectionOpDispenser(adapter, op, typeAndTarget.targetFunction); case drop_collection -> new MilvusDropCollectionOpDispenser(
case create_collection -> new MilvusCreateCollectionOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case create_index -> new MilvusCreateIndexOpDispenser(adapter, op, typeAndTarget.targetFunction); case create_collection -> new MilvusCreateCollectionOpDispenser(
case drop_index -> new MilvusDropIndexOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case create_index -> new MilvusCreateIndexOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case drop_index -> new MilvusDropIndexOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
// Uses the Collection-specific fields (columnar) insert mode // Uses the Collection-specific fields (columnar) insert mode
case insert_rows -> new MilvusInsertRowsOpDispenser(adapter, op, typeAndTarget.targetFunction); case insert_rows -> new MilvusInsertRowsOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
// Uses the High-Level row-by-row JSONObject (tabular) insert mode // Uses the High-Level row-by-row JSONObject (tabular) insert mode
case insert -> new MilvusInsertOpDispenser(adapter, op, typeAndTarget.targetFunction); case insert -> new MilvusInsertOpDispenser(
case delete -> new MilvusDeleteOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case search -> new MilvusSearchOpDispenser(adapter, op, typeAndTarget.targetFunction); case delete -> new MilvusDeleteOpDispenser(
case alter_alias -> new MilvusAlterAliasOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case alter_collection -> new MilvusAlterCollectionOpDispenser(adapter, op, typeAndTarget.targetFunction); case search -> new MilvusSearchOpDispenser(
case flush -> new MilvusFlushOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case bulk_insert -> new MilvusBulkInsertOpDispenser(adapter, op, typeAndTarget.targetFunction); case alter_alias -> new MilvusAlterAliasOpDispenser(
case create_alias -> new MilvusCreateAliasOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get -> new MilvusGetOpDispenser(adapter, op, typeAndTarget.targetFunction); case alter_collection -> new MilvusAlterCollectionOpDispenser(
case create_partition -> new MilvusCreatePartitionOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case create_credential -> new MilvusCreateCredentialOpDispenser(adapter, op, typeAndTarget.targetFunction); case flush -> new MilvusFlushOpDispenser(
case create_database -> new MilvusCreateDatabaseOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case query -> new MilvusQueryOpDispenser(adapter, op, typeAndTarget.targetFunction); case bulk_insert -> new MilvusBulkInsertOpDispenser(
case delete_credential -> new MilvusDeleteCredentialOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case describe_collection -> case create_alias -> new MilvusCreateAliasOpDispenser(
new MilvusDescribeCollectionOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case describe_index -> new MilvusDescribeIndexOpDispenser(adapter, op, typeAndTarget.targetFunction); case get -> new MilvusGetOpDispenser(adapter, op, typeAndTarget.targetFunction, spaceF);
case drop_alias -> new MilvusDropAliasOpDispenser(adapter, op, typeAndTarget.targetFunction); case create_partition -> new MilvusCreatePartitionOpDispenser(
case get_metrics -> new MilvusGetMetricsOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case drop_database -> new MilvusDropDatabaseOpDispenser(adapter, op, typeAndTarget.targetFunction); case create_credential -> new MilvusCreateCredentialOpDispenser(
case get_replicas -> new MilvusGetReplicasOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case load_balance -> new MilvusLoadBalanceOpDispenser(adapter, op, typeAndTarget.targetFunction); case create_database -> new MilvusCreateDatabaseOpDispenser(
case has_partition -> new MilvusHasPartitionOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case drop_partition -> new MilvusDropPartitionOpDispenser(adapter, op, typeAndTarget.targetFunction); case query -> new MilvusQueryOpDispenser(
case get_load_state -> new MilvusGetLoadStateOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case list_databases -> new MilvusListDatabasesOpDispenser(adapter, op, typeAndTarget.targetFunction); case delete_credential -> new MilvusDeleteCredentialOpDispenser(
case manual_compact -> new MilvusManualCompactOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_index_state -> new MilvusGetIndexStateOpDispenser(adapter, op, typeAndTarget.targetFunction); case describe_collection -> new MilvusDescribeCollectionOpDispenser(
case list_cred_users -> new MilvusListCredUsersOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case load_collection -> new MilvusLoadCollectionOpDispenser(adapter, op, typeAndTarget.targetFunction); case describe_index -> new MilvusDescribeIndexOpDispenser(
case show_partitions -> new MilvusShowPartitionsOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case load_partitions -> new MilvusLoadPartitionsOpDispenser(adapter, op, typeAndTarget.targetFunction); case drop_alias -> new MilvusDropAliasOpDispenser(
case list_collections -> new MilvusListCollectionsOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case show_collections -> new MilvusShowCollectionsOpDispenser(adapter, op, typeAndTarget.targetFunction); case get_metrics -> new MilvusGetMetricsOpDispenser(
case update_credential -> new MilvusUpdateCredentialOpDispenser(adapter, op, typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case release_collection -> new MilvusReleaseCollectionOpDispenser(adapter, op, case drop_database -> new MilvusDropDatabaseOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_bulk_insert_state -> new MilvusGetBulkInsertStateOpDispenser(adapter, op, case get_replicas -> new MilvusGetReplicasOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case release_partitions -> new MilvusReleasePartitionsOpDispenser(adapter, op, case load_balance -> new MilvusLoadBalanceOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_flush_all_state -> new MilvusGetFlushAllStateOpDispenser(adapter, op, case has_partition -> new MilvusHasPartitionOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_compaction_state -> new MilvusGetCompactionStateOpDispenser(adapter, op, case drop_partition -> new MilvusDropPartitionOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_loading_progress -> new MilvusGetLoadingProgressOpDispenser(adapter, op, case get_load_state -> new MilvusGetLoadStateOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_persistent_segment_info -> new MilvusGetPersistentSegmentInfoOpDispenser(adapter, op, case list_databases -> new MilvusListDatabasesOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_query_segment_info -> new MilvusGetQuerySegmentInfoOpDispenser(adapter, op, case manual_compact -> new MilvusManualCompactOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case list_bulk_insert_tasks -> new MilvusListBulkInsertTasksOpDispenser(adapter, op, case get_index_state -> new MilvusGetIndexStateOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_index_build_progress -> new MilvusGetIndexBuildProgressOpDispenser(adapter, op, case list_cred_users -> new MilvusListCredUsersOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_partition_statistics -> new MilvusGetPartitionStatisticsOpDispenser(adapter, op, case load_collection -> new MilvusLoadCollectionOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_collection_statistics -> new MilvusGetCollectionStatisticsOpDispenser(adapter, op, case show_partitions -> new MilvusShowPartitionsOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case get_compaction_state_with_plans -> new MilvusGetCompactionStateWithPlansOpDispenser(adapter, op, case load_partitions -> new MilvusLoadPartitionsOpDispenser(
typeAndTarget.targetFunction); adapter, op, typeAndTarget.targetFunction, spaceF);
case list_collections -> new MilvusListCollectionsOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case show_collections -> new MilvusShowCollectionsOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case update_credential -> new MilvusUpdateCredentialOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case release_collection -> new MilvusReleaseCollectionOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_bulk_insert_state -> new MilvusGetBulkInsertStateOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case release_partitions -> new MilvusReleasePartitionsOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_flush_all_state -> new MilvusGetFlushAllStateOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_compaction_state -> new MilvusGetCompactionStateOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_loading_progress -> new MilvusGetLoadingProgressOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_persistent_segment_info -> new MilvusGetPersistentSegmentInfoOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_query_segment_info -> new MilvusGetQuerySegmentInfoOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case list_bulk_insert_tasks -> new MilvusListBulkInsertTasksOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_index_build_progress -> new MilvusGetIndexBuildProgressOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_partition_statistics -> new MilvusGetPartitionStatisticsOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_collection_statistics -> new MilvusGetCollectionStatisticsOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
case get_compaction_state_with_plans ->
new MilvusGetCompactionStateWithPlansOpDispenser(
adapter, op, typeAndTarget.targetFunction, spaceF);
// default -> throw new RuntimeException("Unrecognized op type '" + typeAndTarget.enumId.name() + "' while " + // default -> throw new RuntimeException("Unrecognized op type '" + typeAndTarget.enumId.name() + "' while " +
// "mapping parsed op " + op); // "mapping parsed op " + op);
}; };
} }
} }

26
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/MilvusSpace.java
View File

@ -18,6 +18,8 @@ package io.nosqlbench.adapter.milvus;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.ConnectParam; import io.milvus.param.ConnectParam;
import io.nosqlbench.adapters.api.activityimpl.uniform.BaseSpace;
import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
import io.nosqlbench.nb.api.config.standard.ConfigModel; import io.nosqlbench.nb.api.config.standard.ConfigModel;
import io.nosqlbench.nb.api.config.standard.NBConfigModel; import io.nosqlbench.nb.api.config.standard.NBConfigModel;
import io.nosqlbench.nb.api.config.standard.NBConfiguration; import io.nosqlbench.nb.api.config.standard.NBConfiguration;
@ -39,26 +41,16 @@ import java.util.Optional;
* https://milvus.io/docs/install-java.md * https://milvus.io/docs/install-java.md
* https://docs.zilliz.com/docs/connect-to-cluster * https://docs.zilliz.com/docs/connect-to-cluster
*/ */
public class MilvusSpace implements AutoCloseable { public class MilvusSpace extends BaseSpace<MilvusSpace> {
private final static Logger logger = LogManager.getLogger(MilvusSpace.class); private final static Logger logger = LogManager.getLogger(MilvusSpace.class);
private final String name;
private final NBConfiguration cfg; private final NBConfiguration cfg;
protected MilvusServiceClient client; protected MilvusServiceClient client;
// private final Map<String, ConnectParam> connections = new HashMap<>(); public MilvusSpace(
DriverAdapter<?, MilvusSpace> adapter, long idx, NBConfiguration cfg
/** ) {
* Create a new MilvusSpace Object which stores all stateful contextual information needed to interact super(adapter, idx);
* with the Milvus/Zilliz database instance.
*
* @param name
* The name of this space
* @param cfg
* The configuration ({@link NBConfiguration}) for this nb run
*/
public MilvusSpace(String name, NBConfiguration cfg) {
this.name = name;
this.cfg = cfg; this.cfg = cfg;
} }
@ -70,7 +62,7 @@ public class MilvusSpace implements AutoCloseable {
} }
private MilvusServiceClient createClient() { private MilvusServiceClient createClient() {
var builder = ConnectParam.newBuilder(); ConnectParam.Builder builder = ConnectParam.newBuilder();
builder = builder.withUri(cfg.get("uri")); builder = builder.withUri(cfg.get("uri"));
cfg.getOptional("database_name").ifPresent(builder::withDatabaseName); cfg.getOptional("database_name").ifPresent(builder::withDatabaseName);
cfg.getOptional("database").ifPresent(builder::withDatabaseName); cfg.getOptional("database").ifPresent(builder::withDatabaseName);
@ -95,7 +87,7 @@ public class MilvusSpace implements AutoCloseable {
String tokenSummary = Optional.ofNullable(builder.getToken()) String tokenSummary = Optional.ofNullable(builder.getToken())
.map(MilvusAdapterUtils::maskDigits).orElse("[none]"); .map(MilvusAdapterUtils::maskDigits).orElse("[none]");
logger.info("{}: Creating new Milvus/Zilliz Client with (masked) token [{}], uri/endpoint [{}]", logger.info("{}: Creating new Milvus/Zilliz Client with (masked) token [{}], uri/endpoint [{}]",
this.name, tokenSummary, builder.getUri()); this.getName(), tokenSummary, builder.getUri());
return new MilvusServiceClient(connectParams); return new MilvusServiceClient(connectParams);
} }

15
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusAlterAliasOpDispenser.java
View File

@ -17,20 +17,15 @@
package io.nosqlbench.adapter.milvus.opdispensers; package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.common.clientenum.ConsistencyLevelEnum;
import io.milvus.param.alias.AlterAliasParam; import io.milvus.param.alias.AlterAliasParam;
import io.milvus.param.collection.CreateCollectionParam;
import io.milvus.param.collection.FieldType;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusAlterAliasOp; import io.nosqlbench.adapter.milvus.ops.MilvusAlterAliasOp;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusCreateCollectionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import java.util.List;
import java.util.Map;
import java.util.function.LongFunction; import java.util.function.LongFunction;
public class MilvusAlterAliasOpDispenser extends MilvusBaseOpDispenser<AlterAliasParam> { public class MilvusAlterAliasOpDispenser extends MilvusBaseOpDispenser<AlterAliasParam> {
@ -38,8 +33,10 @@ public class MilvusAlterAliasOpDispenser extends MilvusBaseOpDispenser<AlterAlia
public MilvusAlterAliasOpDispenser(MilvusDriverAdapter adapter, public MilvusAlterAliasOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
@ -53,7 +50,7 @@ public class MilvusAlterAliasOpDispenser extends MilvusBaseOpDispenser<AlterAlia
// Add enhancement functions here // Add enhancement functions here
ebF = op.enhanceFuncOptionally( ebF = op.enhanceFuncOptionally(
ebF,List.of("collection_name","collection"),String.class,AlterAliasParam.Builder::withCollectionName); ebF,"collection",String.class,AlterAliasParam.Builder::withCollectionName);
final LongFunction<AlterAliasParam.Builder> lastF = ebF; final LongFunction<AlterAliasParam.Builder> lastF = ebF;
final LongFunction<AlterAliasParam> collectionParamF = l -> lastF.apply(l).build(); final LongFunction<AlterAliasParam> collectionParamF = l -> lastF.apply(l).build();

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusAlterCollectionOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.AlterCollectionParam; import io.milvus.param.collection.AlterCollectionParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusAlterCollectionOp; import io.nosqlbench.adapter.milvus.ops.MilvusAlterCollectionOp;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusAlterCollectionOpDispenser extends MilvusBaseOpDispenser<Alte
public MilvusAlterCollectionOpDispenser(MilvusDriverAdapter adapter, public MilvusAlterCollectionOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusBaseOpDispenser.java
View File

@ -33,16 +33,15 @@ public abstract class MilvusBaseOpDispenser<T> extends BaseOpDispenser<MilvusBas
private final LongFunction<? extends MilvusBaseOp<T>> opF; private final LongFunction<? extends MilvusBaseOp<T>> opF;
private final LongFunction<T> paramF; private final LongFunction<T> paramF;
protected MilvusBaseOpDispenser(MilvusDriverAdapter adapter, ParsedOp op, LongFunction<String> targetF) { protected MilvusBaseOpDispenser(MilvusDriverAdapter adapter, ParsedOp op,
super((DriverAdapter)adapter, op); LongFunction<String> targetF,
LongFunction<MilvusSpace> spaceF) {
super(adapter,op,spaceF);
this.mzSpaceFunction = adapter.getSpaceFunc(op); this.mzSpaceFunction = adapter.getSpaceFunc(op);
this.clientFunction = (long l) -> this.mzSpaceFunction.apply(l).getClient(); this.clientFunction = (long l) -> this.mzSpaceFunction.apply(l).getClient();
this.paramF = getParamFunc(this.clientFunction,op,targetF); this.paramF = getParamFunc(this.clientFunction,op,targetF);
this.opF = createOpFunc(paramF, this.clientFunction, op, targetF); this.opF = createOpFunc(paramF, this.clientFunction, op, targetF);
} }
protected MilvusDriverAdapter getDriverAdapter() {
return (MilvusDriverAdapter) adapter;
}
public abstract LongFunction<T> getParamFunc( public abstract LongFunction<T> getParamFunc(
LongFunction<MilvusServiceClient> clientF, LongFunction<MilvusServiceClient> clientF,

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusBulkInsertOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.bulkinsert.BulkInsertParam; import io.milvus.param.bulkinsert.BulkInsertParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusBulkInsertOp; import io.nosqlbench.adapter.milvus.ops.MilvusBulkInsertOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -31,8 +32,10 @@ public class MilvusBulkInsertOpDispenser extends MilvusBaseOpDispenser<BulkInser
public MilvusBulkInsertOpDispenser(MilvusDriverAdapter adapter, public MilvusBulkInsertOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
@ -53,7 +56,7 @@ public class MilvusBulkInsertOpDispenser extends MilvusBaseOpDispenser<BulkInser
} }
); );
ebF = op.enhanceFuncOptionally(ebF, "files", List.class, BulkInsertParam.Builder::withFiles); ebF = op.enhanceFuncOptionally(ebF, "files", List.class, BulkInsertParam.Builder::withFiles);
ebF = op.enhanceFuncOptionally(ebF, List.of("partition_name", "partition"), String.class, ebF = op.enhanceFuncOptionally(ebF, "partition", String.class,
BulkInsertParam.Builder::withPartitionName); BulkInsertParam.Builder::withPartitionName);
LongFunction<BulkInsertParam.Builder> finalEbF = ebF; LongFunction<BulkInsertParam.Builder> finalEbF = ebF;
return l -> finalEbF.apply(l).build(); return l -> finalEbF.apply(l).build();

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusCreateAliasOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.alias.CreateAliasParam; import io.milvus.param.alias.CreateAliasParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusCreateAliasOp; import io.nosqlbench.adapter.milvus.ops.MilvusCreateAliasOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,10 @@ public class MilvusCreateAliasOpDispenser extends MilvusBaseOpDispenser<CreateAl
public MilvusCreateAliasOpDispenser(MilvusDriverAdapter adapter, public MilvusCreateAliasOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
@ -42,7 +45,7 @@ public class MilvusCreateAliasOpDispenser extends MilvusBaseOpDispenser<CreateAl
) { ) {
LongFunction<CreateAliasParam.Builder> ebF = LongFunction<CreateAliasParam.Builder> ebF =
l -> CreateAliasParam.newBuilder().withAlias(targetF.apply(l)); l -> CreateAliasParam.newBuilder().withAlias(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("collection_name","collection"),String.class, ebF = op.enhanceFuncOptionally(ebF, "collection",String.class,
CreateAliasParam.Builder::withCollectionName); CreateAliasParam.Builder::withCollectionName);

21
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusCreateCollectionOpDispenser.java
View File

@ -23,6 +23,7 @@ import io.milvus.param.collection.CollectionSchemaParam;
import io.milvus.param.collection.CreateCollectionParam; import io.milvus.param.collection.CreateCollectionParam;
import io.milvus.param.collection.FieldType; import io.milvus.param.collection.FieldType;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusCreateCollectionOp; import io.nosqlbench.adapter.milvus.ops.MilvusCreateCollectionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -38,16 +39,20 @@ public class MilvusCreateCollectionOpDispenser extends MilvusBaseOpDispenser<Cre
private static final Logger logger = LogManager.getLogger(MilvusCreateCollectionOpDispenser.class); private static final Logger logger = LogManager.getLogger(MilvusCreateCollectionOpDispenser.class);
/** /**
* Create a new MilvusCreateCollectionOpDispenser subclassed from {@link MilvusBaseOpDispenser}. Create a new MilvusCreateCollectionOpDispenser subclassed from {@link MilvusBaseOpDispenser}.
* @param adapter
* @param adapter The associated {@link MilvusDriverAdapter} The associated {@link MilvusDriverAdapter}
* @param op The {@link ParsedOp} encapsulating the activity for this cycle @param op
* @param targetFunction A LongFunction that returns the specified Milvus Index for this Op The {@link ParsedOp} encapsulating the activity for this cycle
@param targetFunction
A LongFunction that returns the specified Milvus Index for this Op
*/ */
public MilvusCreateCollectionOpDispenser(MilvusDriverAdapter adapter, public MilvusCreateCollectionOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
@ -111,7 +116,7 @@ public class MilvusCreateCollectionOpDispenser extends MilvusBaseOpDispenser<Cre
.ifPresent((Number n) -> builder.withMaxLength(n.intValue())); .ifPresent((Number n) -> builder.withMaxLength(n.intValue()));
fieldspec.getOptionalStaticConfig("max_capacity", Number.class) fieldspec.getOptionalStaticConfig("max_capacity", Number.class)
.ifPresent((Number n) -> builder.withMaxCapacity(n.intValue())); .ifPresent((Number n) -> builder.withMaxCapacity(n.intValue()));
fieldspec.getOptionalStaticValue(List.of("partition_key", "partition"), Boolean.class) fieldspec.getOptionalStaticValue("partition", Boolean.class)
.ifPresent(builder::withPartitionKey); .ifPresent(builder::withPartitionKey);
fieldspec.getOptionalStaticValue("dimension", Number.class) fieldspec.getOptionalStaticValue("dimension", Number.class)
.ifPresent((Number n) -> builder.withDimension(n.intValue())); .ifPresent((Number n) -> builder.withDimension(n.intValue()));

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusCreateCredentialOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.credential.CreateCredentialParam; import io.milvus.param.credential.CreateCredentialParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusCreateCredentialOp; import io.nosqlbench.adapter.milvus.ops.MilvusCreateCredentialOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusCreateCredentialOpDispenser extends MilvusBaseOpDispenser<Cre
public MilvusCreateCredentialOpDispenser(MilvusDriverAdapter adapter, public MilvusCreateCredentialOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusCreateDatabaseOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.CreateDatabaseParam; import io.milvus.param.collection.CreateDatabaseParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusCreateDatabaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusCreateDatabaseOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusCreateDatabaseOpDispenser extends MilvusBaseOpDispenser<Creat
public MilvusCreateDatabaseOpDispenser(MilvusDriverAdapter adapter, public MilvusCreateDatabaseOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

21
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusCreateIndexOpDispenser.java
View File

@ -21,6 +21,7 @@ import io.milvus.param.IndexType;
import io.milvus.param.MetricType; import io.milvus.param.MetricType;
import io.milvus.param.index.CreateIndexParam; import io.milvus.param.index.CreateIndexParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusCreateIndexOp; import io.nosqlbench.adapter.milvus.ops.MilvusCreateIndexOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -34,18 +35,20 @@ public class MilvusCreateIndexOpDispenser extends MilvusBaseOpDispenser<CreateIn
private static final Logger logger = LogManager.getLogger(MilvusCreateIndexOpDispenser.class); private static final Logger logger = LogManager.getLogger(MilvusCreateIndexOpDispenser.class);
/** /**
* Create a new MilvusCreateIndexOpDispenser subclassed from {@link MilvusBaseOpDispenser}. Create a new MilvusCreateIndexOpDispenser subclassed from {@link MilvusBaseOpDispenser}.
* @param adapter
* @param adapter The associated {@link MilvusDriverAdapter} The associated {@link MilvusDriverAdapter}
* @param op The {@link ParsedOp} encapsulating the activity for this cycle @param op
* @param targetFunction A LongFunction that returns the specified Milvus Index for this Op The {@link ParsedOp} encapsulating the activity for this cycle
@param targetFunction
A LongFunction that returns the specified Milvus Index for this Op
*/ */
public MilvusCreateIndexOpDispenser( public MilvusCreateIndexOpDispenser(
MilvusDriverAdapter adapter, MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction LongFunction<String> targetFunction, LongFunction<MilvusSpace> spaceF
) { ) {
super(adapter, op, targetFunction); super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
@ -53,7 +56,7 @@ public class MilvusCreateIndexOpDispenser extends MilvusBaseOpDispenser<CreateIn
LongFunction<CreateIndexParam.Builder> bF = LongFunction<CreateIndexParam.Builder> bF =
l -> CreateIndexParam.newBuilder().withIndexName(targetF.apply(l)); l -> CreateIndexParam.newBuilder().withIndexName(targetF.apply(l));
bF = op.enhanceFunc(bF, List.of("collection", "collection_name"), String.class, bF = op.enhanceFunc(bF, "collection", String.class,
CreateIndexParam.Builder::withCollectionName); CreateIndexParam.Builder::withCollectionName);
bF = op.enhanceFunc(bF, "field_name", String.class, CreateIndexParam.Builder::withFieldName); bF = op.enhanceFunc(bF, "field_name", String.class, CreateIndexParam.Builder::withFieldName);
bF = op.enhanceEnumOptionally(bF, "index_type", IndexType.class, CreateIndexParam.Builder::withIndexType); bF = op.enhanceEnumOptionally(bF, "index_type", IndexType.class, CreateIndexParam.Builder::withIndexType);
@ -64,7 +67,7 @@ public class MilvusCreateIndexOpDispenser extends MilvusBaseOpDispenser<CreateIn
(CreateIndexParam.Builder b, Number n) -> b.withSyncWaitingInterval(n.longValue())); (CreateIndexParam.Builder b, Number n) -> b.withSyncWaitingInterval(n.longValue()));
bF = op.enhanceFuncOptionally(bF, "sync_waiting_timeout", Number.class, bF = op.enhanceFuncOptionally(bF, "sync_waiting_timeout", Number.class,
(CreateIndexParam.Builder b, Number n) -> b.withSyncWaitingTimeout(n.longValue())); (CreateIndexParam.Builder b, Number n) -> b.withSyncWaitingTimeout(n.longValue()));
bF = op.enhanceFuncOptionally(bF, List.of("database", "database_name"), String.class, bF = op.enhanceFuncOptionally(bF, "database", String.class,
CreateIndexParam.Builder::withDatabaseName); CreateIndexParam.Builder::withDatabaseName);
LongFunction<CreateIndexParam.Builder> finalBF1 = bF; LongFunction<CreateIndexParam.Builder> finalBF1 = bF;
return l -> finalBF1.apply(l).build(); return l -> finalBF1.apply(l).build();

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusCreatePartitionOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.partition.CreatePartitionParam; import io.milvus.param.partition.CreatePartitionParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusCreatePartitionOp; import io.nosqlbench.adapter.milvus.ops.MilvusCreatePartitionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,10 @@ public class MilvusCreatePartitionOpDispenser extends MilvusBaseOpDispenser<Crea
public MilvusCreatePartitionOpDispenser(MilvusDriverAdapter adapter, public MilvusCreatePartitionOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -43,7 +46,7 @@ public class MilvusCreatePartitionOpDispenser extends MilvusBaseOpDispenser<Crea
LongFunction<CreatePartitionParam.Builder> ebF = LongFunction<CreatePartitionParam.Builder> ebF =
l -> CreatePartitionParam.newBuilder().withCollectionName(targetF.apply(l)); l -> CreatePartitionParam.newBuilder().withCollectionName(targetF.apply(l));
// Add enhancement functions here // Add enhancement functions here
ebF = op.enhanceFunc(ebF, List.of("collection","collection_name"),String.class, ebF = op.enhanceFunc(ebF, "collection",String.class,
CreatePartitionParam.Builder::withCollectionName); CreatePartitionParam.Builder::withCollectionName);
final LongFunction<CreatePartitionParam.Builder> lastF = ebF; final LongFunction<CreatePartitionParam.Builder> lastF = ebF;

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusDeleteCredentialOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.credential.DeleteCredentialParam; import io.milvus.param.credential.DeleteCredentialParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusDeleteCredentialOp; import io.nosqlbench.adapter.milvus.ops.MilvusDeleteCredentialOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusDeleteCredentialOpDispenser extends MilvusBaseOpDispenser<Del
public MilvusDeleteCredentialOpDispenser(MilvusDriverAdapter adapter, public MilvusDeleteCredentialOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusDeleteOpDispenser.java
View File

@ -21,6 +21,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.dml.DeleteParam; import io.milvus.param.dml.DeleteParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusDeleteParamOp; import io.nosqlbench.adapter.milvus.ops.MilvusDeleteParamOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -32,15 +33,17 @@ import java.util.function.LongFunction;
public class MilvusDeleteOpDispenser extends MilvusBaseOpDispenser<DeleteParam> { public class MilvusDeleteOpDispenser extends MilvusBaseOpDispenser<DeleteParam> {
public MilvusDeleteOpDispenser(MilvusDriverAdapter adapter, public MilvusDeleteOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
public LongFunction<DeleteParam> getParamFunc(LongFunction<MilvusServiceClient> clientF, ParsedOp op, LongFunction<String> targetF) { public LongFunction<DeleteParam> getParamFunc(LongFunction<MilvusServiceClient> clientF, ParsedOp op, LongFunction<String> targetF) {
LongFunction<DeleteParam.Builder> f = LongFunction<DeleteParam.Builder> f =
l -> DeleteParam.newBuilder().withCollectionName(targetF.apply(l)); l -> DeleteParam.newBuilder().withCollectionName(targetF.apply(l));
f = op.enhanceFuncOptionally(f, List.of("partition_name","partition"), String.class, f = op.enhanceFuncOptionally(f, "partition", String.class,
DeleteParam.Builder::withPartitionName); DeleteParam.Builder::withPartitionName);
f = op.enhanceFuncOptionally(f, "expression", String.class, DeleteParam.Builder::withExpr); f = op.enhanceFuncOptionally(f, "expression", String.class, DeleteParam.Builder::withExpr);
f = op.enhanceFuncOptionally(f, "expr", String.class, Builder::withExpr); f = op.enhanceFuncOptionally(f, "expr", String.class, Builder::withExpr);

10
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusDescribeCollectionOpDispenser.java
View File

@ -18,8 +18,8 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.DescribeCollectionParam; import io.milvus.param.collection.DescribeCollectionParam;
import io.milvus.param.partition.CreatePartitionParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusDescribeCollectionOp; import io.nosqlbench.adapter.milvus.ops.MilvusDescribeCollectionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -31,8 +31,10 @@ public class MilvusDescribeCollectionOpDispenser extends MilvusBaseOpDispenser<D
public MilvusDescribeCollectionOpDispenser(MilvusDriverAdapter adapter, public MilvusDescribeCollectionOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -44,7 +46,7 @@ public class MilvusDescribeCollectionOpDispenser extends MilvusBaseOpDispenser<D
LongFunction<DescribeCollectionParam.Builder> ebF = LongFunction<DescribeCollectionParam.Builder> ebF =
l -> DescribeCollectionParam.newBuilder().withCollectionName(targetF.apply(l)); l -> DescribeCollectionParam.newBuilder().withCollectionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("database","database_name"),String.class, ebF = op.enhanceFuncOptionally(ebF, "database",String.class,
DescribeCollectionParam.Builder::withDatabaseName); DescribeCollectionParam.Builder::withDatabaseName);
final LongFunction<DescribeCollectionParam.Builder> lastF = ebF; final LongFunction<DescribeCollectionParam.Builder> lastF = ebF;

11
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusDescribeIndexOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.index.DescribeIndexParam; import io.milvus.param.index.DescribeIndexParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusDescribeIndexOp; import io.nosqlbench.adapter.milvus.ops.MilvusDescribeIndexOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -35,8 +36,10 @@ public class MilvusDescribeIndexOpDispenser extends MilvusBaseOpDispenser<Descri
public MilvusDescribeIndexOpDispenser(MilvusDriverAdapter adapter, public MilvusDescribeIndexOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
op.getOptionalStaticValue("await_timeout", Number.class) op.getOptionalStaticValue("await_timeout", Number.class)
.map(Number::doubleValue) .map(Number::doubleValue)
@ -53,9 +56,9 @@ public class MilvusDescribeIndexOpDispenser extends MilvusBaseOpDispenser<Descri
) { ) {
LongFunction<DescribeIndexParam.Builder> ebF = LongFunction<DescribeIndexParam.Builder> ebF =
l -> DescribeIndexParam.newBuilder().withIndexName(targetF.apply(l)); l -> DescribeIndexParam.newBuilder().withIndexName(targetF.apply(l));
ebF = op.enhanceFunc(ebF, List.of("collection","collection_name"), String.class, ebF = op.enhanceFunc(ebF, "collection", String.class,
DescribeIndexParam.Builder::withCollectionName); DescribeIndexParam.Builder::withCollectionName);
ebF = op.enhanceFuncOptionally(ebF, List.of("database_name","database"), String.class, ebF = op.enhanceFuncOptionally(ebF, "database", String.class,
DescribeIndexParam.Builder::withDatabaseName); DescribeIndexParam.Builder::withDatabaseName);

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusDropAliasOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.alias.DropAliasParam; import io.milvus.param.alias.DropAliasParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusDropAliasOp; import io.nosqlbench.adapter.milvus.ops.MilvusDropAliasOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusDropAliasOpDispenser extends MilvusBaseOpDispenser<DropAliasP
public MilvusDropAliasOpDispenser(MilvusDriverAdapter adapter, public MilvusDropAliasOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

26
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusDropCollectionOpDispenser.java
View File

@ -21,6 +21,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.DropCollectionParam; import io.milvus.param.collection.DropCollectionParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusDropCollectionOp; import io.nosqlbench.adapter.milvus.ops.MilvusDropCollectionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -34,18 +35,23 @@ public class MilvusDropCollectionOpDispenser extends MilvusBaseOpDispenser<DropC
private static final Logger logger = LogManager.getLogger(MilvusDropCollectionOpDispenser.class); private static final Logger logger = LogManager.getLogger(MilvusDropCollectionOpDispenser.class);
/** /**
* <P>Create a new {@link MilvusDropCollectionOpDispenser} subclassed from {@link MilvusBaseOpDispenser}.</P> <P>Create a new {@link MilvusDropCollectionOpDispenser} subclassed from
* {@link MilvusBaseOpDispenser}.</P>
* <P>{@see <A HREF="https://milvus.io/docs/drop_collection.md">Drop Collection</A>}</P>
* <P>{@see <A HREF="https://milvus.io/docs/drop_collection.md">Drop Collection</A>}</P>
* @param adapter The associated {@link MilvusDriverAdapter} @param adapter
* @param op The {@link ParsedOp} encapsulating the activity for this cycle The associated {@link MilvusDriverAdapter}
* @param targetFunction A LongFunction that returns the specified Milvus Index for this Op @param op
The {@link ParsedOp} encapsulating the activity for this cycle
@param targetFunction
A LongFunction that returns the specified Milvus Index for this Op
*/ */
public MilvusDropCollectionOpDispenser(MilvusDriverAdapter adapter, public MilvusDropCollectionOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
@ -55,7 +61,7 @@ public class MilvusDropCollectionOpDispenser extends MilvusBaseOpDispenser<DropC
LongFunction<String> targetF) { LongFunction<String> targetF) {
LongFunction<DropCollectionParam.Builder> f = LongFunction<DropCollectionParam.Builder> f =
l -> DropCollectionParam.newBuilder().withCollectionName(targetF.apply(l)); l -> DropCollectionParam.newBuilder().withCollectionName(targetF.apply(l));
f = op.enhanceFuncOptionally(f, List.of("database","database_name"),String.class, f = op.enhanceFuncOptionally(f, "database",String.class,
DropCollectionParam.Builder::withDatabaseName); DropCollectionParam.Builder::withDatabaseName);
LongFunction<DropCollectionParam.Builder> finalF = f; LongFunction<DropCollectionParam.Builder> finalF = f;
return l -> finalF.apply(l).build(); return l -> finalF.apply(l).build();

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusDropDatabaseOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.DropDatabaseParam; import io.milvus.param.collection.DropDatabaseParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusDropDatabaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusDropDatabaseOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusDropDatabaseOpDispenser extends MilvusBaseOpDispenser<DropDat
public MilvusDropDatabaseOpDispenser(MilvusDriverAdapter adapter, public MilvusDropDatabaseOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

29
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusDropIndexOpDispenser.java
View File

@ -21,39 +21,38 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.index.DropIndexParam; import io.milvus.param.index.DropIndexParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusDropIndexOp; import io.nosqlbench.adapter.milvus.ops.MilvusDropIndexOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.List; import java.util.List;
import java.util.function.LongFunction; import java.util.function.LongFunction;
public class MilvusDropIndexOpDispenser extends MilvusBaseOpDispenser<DropIndexParam> { public class MilvusDropIndexOpDispenser extends MilvusBaseOpDispenser<DropIndexParam> {
/** /**
* <P>Create a new MilvusDeleteOpDispenser subclassed from {@link MilvusBaseOpDispenser}.</P> <P>Create a new MilvusDeleteOpDispenser subclassed from {@link MilvusBaseOpDispenser}.</P>
* <P>{@see <a href="https://milvus.io/docs/drop_collection.md">Drop Index</a>}</P> <P>{@see <a href="https://milvus.io/docs/drop_collection.md">Drop Index</a>}</P>
* @param adapter
* The associated {@link MilvusDriverAdapter}
* @param adapter @param op
* The associated {@link MilvusDriverAdapter} The {@link ParsedOp} encapsulating the activity for this cycle
* @param op @param targetFunction
* The {@link ParsedOp} encapsulating the activity for this cycle A LongFunction that returns the specified Milvus Index for this Op
* @param targetFunction
* A LongFunction that returns the specified Milvus Index for this Op
*/ */
public MilvusDropIndexOpDispenser(MilvusDriverAdapter adapter, public MilvusDropIndexOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
public LongFunction<DropIndexParam> getParamFunc(LongFunction<MilvusServiceClient> clientF, ParsedOp op, LongFunction<String> targetF) { public LongFunction<DropIndexParam> getParamFunc(LongFunction<MilvusServiceClient> clientF, ParsedOp op, LongFunction<String> targetF) {
LongFunction<DropIndexParam.Builder> f = LongFunction<DropIndexParam.Builder> f =
l -> DropIndexParam.newBuilder().withIndexName(targetF.apply(l)); l -> DropIndexParam.newBuilder().withIndexName(targetF.apply(l));
f = op.enhanceFunc(f, List.of("collection_name","collection"),String.class, f = op.enhanceFunc(f, "collection",String.class,
DropIndexParam.Builder::withCollectionName); DropIndexParam.Builder::withCollectionName);
LongFunction<DropIndexParam.Builder> finalF = f; LongFunction<DropIndexParam.Builder> finalF = f;
return l -> finalF.apply(1).build(); return l -> finalF.apply(1).build();

10
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusDropPartitionOpDispenser.java
View File

@ -17,9 +17,9 @@
package io.nosqlbench.adapter.milvus.opdispensers; package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.partition.CreatePartitionParam;
import io.milvus.param.partition.DropPartitionParam; import io.milvus.param.partition.DropPartitionParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusDropPartitionOp; import io.nosqlbench.adapter.milvus.ops.MilvusDropPartitionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -31,8 +31,10 @@ public class MilvusDropPartitionOpDispenser extends MilvusBaseOpDispenser<DropPa
public MilvusDropPartitionOpDispenser(MilvusDriverAdapter adapter, public MilvusDropPartitionOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -43,7 +45,7 @@ public class MilvusDropPartitionOpDispenser extends MilvusBaseOpDispenser<DropPa
) { ) {
LongFunction<DropPartitionParam.Builder> ebF = LongFunction<DropPartitionParam.Builder> ebF =
l -> DropPartitionParam.newBuilder().withPartitionName(targetF.apply(l)); l -> DropPartitionParam.newBuilder().withPartitionName(targetF.apply(l));
ebF = op.enhanceFunc(ebF, List.of("collection_name","collection"),String.class, ebF = op.enhanceFunc(ebF, "collection",String.class,
DropPartitionParam.Builder::withCollectionName); DropPartitionParam.Builder::withCollectionName);
final LongFunction<DropPartitionParam.Builder> lastF = ebF; final LongFunction<DropPartitionParam.Builder> lastF = ebF;

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusFlushOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.FlushParam; import io.milvus.param.collection.FlushParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusFlushOp; import io.nosqlbench.adapter.milvus.ops.MilvusFlushOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -31,8 +32,10 @@ public class MilvusFlushOpDispenser extends MilvusBaseOpDispenser<FlushParam> {
public MilvusFlushOpDispenser(MilvusDriverAdapter adapter, public MilvusFlushOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
@ -51,7 +54,7 @@ public class MilvusFlushOpDispenser extends MilvusBaseOpDispenser<FlushParam> {
}; };
LongFunction<FlushParam.Builder> finalEbF = ebF; LongFunction<FlushParam.Builder> finalEbF = ebF;
ebF = l -> finalEbF.apply(l).withCollectionNames(cnames.apply(l)); ebF = l -> finalEbF.apply(l).withCollectionNames(cnames.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("database_name", "database"), String.class, ebF = op.enhanceFuncOptionally(ebF, "database", String.class,
FlushParam.Builder::withDatabaseName); FlushParam.Builder::withDatabaseName);
ebF = op.enhanceFuncOptionally(ebF, "sync_flush_waiting_interval", Number.class, ebF = op.enhanceFuncOptionally(ebF, "sync_flush_waiting_interval", Number.class,
(FlushParam.Builder b, Number n) -> b.withSyncFlushWaitingInterval(n.longValue())); (FlushParam.Builder b, Number n) -> b.withSyncFlushWaitingInterval(n.longValue()));

8
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetBulkInsertStateOpDispenser.java
View File

@ -19,9 +19,9 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.bulkinsert.GetBulkInsertStateParam; import io.milvus.param.bulkinsert.GetBulkInsertStateParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetBulkInsertStateOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetBulkInsertStateOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetCollectionStatisticsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
import java.util.function.LongFunction; import java.util.function.LongFunction;
@ -30,8 +30,10 @@ public class MilvusGetBulkInsertStateOpDispenser extends MilvusBaseOpDispenser<G
public MilvusGetBulkInsertStateOpDispenser(MilvusDriverAdapter adapter, public MilvusGetBulkInsertStateOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetCollectionStatisticsOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.GetCollectionStatisticsParam; import io.milvus.param.collection.GetCollectionStatisticsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetCollectionStatisticsOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetCollectionStatisticsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,10 @@ public class MilvusGetCollectionStatisticsOpDispenser extends MilvusBaseOpDispen
public MilvusGetCollectionStatisticsOpDispenser(MilvusDriverAdapter adapter, public MilvusGetCollectionStatisticsOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -43,7 +46,7 @@ public class MilvusGetCollectionStatisticsOpDispenser extends MilvusBaseOpDispen
LongFunction<GetCollectionStatisticsParam.Builder> ebF = LongFunction<GetCollectionStatisticsParam.Builder> ebF =
l -> GetCollectionStatisticsParam.newBuilder().withCollectionName(targetF.apply(l)); l -> GetCollectionStatisticsParam.newBuilder().withCollectionName(targetF.apply(l));
// Add enhancement functions here // Add enhancement functions here
ebF = op.enhanceFuncOptionally(ebF, List.of("database_name","database"), String.class, ebF = op.enhanceFuncOptionally(ebF, "database", String.class,
GetCollectionStatisticsParam.Builder::withDatabaseName); GetCollectionStatisticsParam.Builder::withDatabaseName);
ebF = op.enhanceFuncOptionally(ebF,"flush",Boolean.class,GetCollectionStatisticsParam.Builder::withFlush); ebF = op.enhanceFuncOptionally(ebF,"flush",Boolean.class,GetCollectionStatisticsParam.Builder::withFlush);

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetCompactionStateOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.control.GetCompactionStateParam; import io.milvus.param.control.GetCompactionStateParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetCompactionStateOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetCompactionStateOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusGetCompactionStateOpDispenser extends MilvusBaseOpDispenser<G
public MilvusGetCompactionStateOpDispenser(MilvusDriverAdapter adapter, public MilvusGetCompactionStateOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

8
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetCompactionStateWithPlansOpDispenser.java
View File

@ -18,8 +18,8 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.control.GetCompactionPlansParam; import io.milvus.param.control.GetCompactionPlansParam;
import io.milvus.param.control.GetCompactionPlansParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetCompactionStateWithPlansOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetCompactionStateWithPlansOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +30,10 @@ public class MilvusGetCompactionStateWithPlansOpDispenser extends MilvusBaseOpDi
public MilvusGetCompactionStateWithPlansOpDispenser(MilvusDriverAdapter adapter, public MilvusGetCompactionStateWithPlansOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetFlushAllStateOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.control.GetFlushAllStateParam; import io.milvus.param.control.GetFlushAllStateParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetFlushAllStateOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetFlushAllStateOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusGetFlushAllStateOpDispenser extends MilvusBaseOpDispenser<Get
public MilvusGetFlushAllStateOpDispenser(MilvusDriverAdapter adapter, public MilvusGetFlushAllStateOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

8
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetFlushStateOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.control.GetFlushStateParam; import io.milvus.param.control.GetFlushStateParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetFlushStateOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetFlushStateOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -31,8 +32,9 @@ public class MilvusGetFlushStateOpDispenser extends MilvusBaseOpDispenser<GetFlu
public MilvusGetFlushStateOpDispenser(MilvusDriverAdapter adapter, public MilvusGetFlushStateOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -52,7 +54,7 @@ public class MilvusGetFlushStateOpDispenser extends MilvusBaseOpDispenser<GetFlu
}; };
LongFunction<GetFlushStateParam.Builder> finalEbF = ebF; LongFunction<GetFlushStateParam.Builder> finalEbF = ebF;
ebF = l -> finalEbF.apply(l).withSegmentIDs(idsF.apply(l)); ebF = l -> finalEbF.apply(l).withSegmentIDs(idsF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("collection", "collection_name"), String.class, ebF = op.enhanceFuncOptionally(ebF, "collection", String.class,
GetFlushStateParam.Builder::withCollectionName); GetFlushStateParam.Builder::withCollectionName);
ebF = op.enhanceFuncOptionally(ebF, "flush_ts", Number.class, ebF = op.enhanceFuncOptionally(ebF, "flush_ts", Number.class,
(GetFlushStateParam.Builder b, Number n) -> b.withFlushTs(n.longValue())); (GetFlushStateParam.Builder b, Number n) -> b.withFlushTs(n.longValue()));

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetIndexBuildProgressOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.index.GetIndexBuildProgressParam; import io.milvus.param.index.GetIndexBuildProgressParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetIndexBuildProgressOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetIndexBuildProgressOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,10 @@ public class MilvusGetIndexBuildProgressOpDispenser extends MilvusBaseOpDispense
public MilvusGetIndexBuildProgressOpDispenser(MilvusDriverAdapter adapter, public MilvusGetIndexBuildProgressOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -42,7 +45,7 @@ public class MilvusGetIndexBuildProgressOpDispenser extends MilvusBaseOpDispense
) { ) {
LongFunction<GetIndexBuildProgressParam.Builder> ebF = LongFunction<GetIndexBuildProgressParam.Builder> ebF =
l -> GetIndexBuildProgressParam.newBuilder().withIndexName(targetF.apply(l)); l -> GetIndexBuildProgressParam.newBuilder().withIndexName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("collection_name","collection"),String.class, ebF = op.enhanceFuncOptionally(ebF, "collection",String.class,
GetIndexBuildProgressParam.Builder::withCollectionName); GetIndexBuildProgressParam.Builder::withCollectionName);
final LongFunction<GetIndexBuildProgressParam.Builder> lastF = ebF; final LongFunction<GetIndexBuildProgressParam.Builder> lastF = ebF;

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetIndexStateOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.index.GetIndexStateParam; import io.milvus.param.index.GetIndexStateParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetIndexStateOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetIndexStateOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,10 @@ public class MilvusGetIndexStateOpDispenser extends MilvusBaseOpDispenser<GetInd
public MilvusGetIndexStateOpDispenser(MilvusDriverAdapter adapter, public MilvusGetIndexStateOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -42,7 +45,7 @@ public class MilvusGetIndexStateOpDispenser extends MilvusBaseOpDispenser<GetInd
) { ) {
LongFunction<GetIndexStateParam.Builder> ebF = LongFunction<GetIndexStateParam.Builder> ebF =
l -> GetIndexStateParam.newBuilder().withIndexName(targetF.apply(l)); l -> GetIndexStateParam.newBuilder().withIndexName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("collection_name","collection"),String.class, ebF = op.enhanceFuncOptionally(ebF, "collection",String.class,
GetIndexStateParam.Builder::withCollectionName); GetIndexStateParam.Builder::withCollectionName);
final LongFunction<GetIndexStateParam.Builder> lastF = ebF; final LongFunction<GetIndexStateParam.Builder> lastF = ebF;
final LongFunction<GetIndexStateParam> collectionParamF = l -> lastF.apply(l).build(); final LongFunction<GetIndexStateParam> collectionParamF = l -> lastF.apply(l).build();

11
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetLoadStateOpDispenser.java
View File

@ -21,6 +21,7 @@ import io.milvus.grpc.LoadState;
import io.milvus.param.collection.GetLoadStateParam; import io.milvus.param.collection.GetLoadStateParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusAdapterUtils; import io.nosqlbench.adapter.milvus.MilvusAdapterUtils;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetLoadStateOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetLoadStateOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -40,15 +41,17 @@ public class MilvusGetLoadStateOpDispenser extends MilvusBaseOpDispenser<GetLoad
public MilvusGetLoadStateOpDispenser(MilvusDriverAdapter adapter, public MilvusGetLoadStateOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
op.getOptionalStaticValue("await_timeout", Number.class) op.getOptionalStaticValue("await_timeout", Number.class)
.map(Number::doubleValue) .map(Number::doubleValue)
.ifPresent(v->this.awaitTimeout=Duration.of((long)(v*1000),ChronoUnit.MILLIS)); .ifPresent(v->this.awaitTimeout=Duration.of((long)(v*1000),ChronoUnit.MILLIS));
op.getOptionalStaticValue("await_interval", Number.class) op.getOptionalStaticValue("await_interval", Number.class)
.map(Number::doubleValue).ifPresent(v->this.awaitInterval=Duration.of((long)(v*1000),ChronoUnit.MILLIS)); .map(Number::doubleValue).ifPresent(v->this.awaitInterval=Duration.of((long)(v*1000),ChronoUnit.MILLIS));
op.getOptionalStaticValue("await_state", String.class).ifPresent(s -> { op.getOptionalStaticValue("await_state", String.class).ifPresent(s -> {
var spec = s.toLowerCase(); String spec = s.toLowerCase();
for (LoadState value : LoadState.values()) { for (LoadState value : LoadState.values()) {
if (value.name().toLowerCase().equals(spec) || value.name().toLowerCase().equals("loadstate" + spec)) { if (value.name().toLowerCase().equals(spec) || value.name().toLowerCase().equals("loadstate" + spec)) {
this.awaitState = value; this.awaitState = value;
@ -70,7 +73,7 @@ public class MilvusGetLoadStateOpDispenser extends MilvusBaseOpDispenser<GetLoad
) { ) {
LongFunction<GetLoadStateParam.Builder> ebF = LongFunction<GetLoadStateParam.Builder> ebF =
l -> GetLoadStateParam.newBuilder().withCollectionName(targetF.apply(l)); l -> GetLoadStateParam.newBuilder().withCollectionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("database_name", "database"), String.class, ebF = op.enhanceFuncOptionally(ebF, "database", String.class,
GetLoadStateParam.Builder::withDatabaseName); GetLoadStateParam.Builder::withDatabaseName);
Optional<LongFunction<String>> partitionsF = op.getAsOptionalFunction("partition_name", String.class); Optional<LongFunction<String>> partitionsF = op.getAsOptionalFunction("partition_name", String.class);

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetLoadingProgressOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.GetLoadingProgressParam; import io.milvus.param.collection.GetLoadingProgressParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetLoadingProgressOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetLoadingProgressOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,10 @@ public class MilvusGetLoadingProgressOpDispenser extends MilvusBaseOpDispenser<G
public MilvusGetLoadingProgressOpDispenser(MilvusDriverAdapter adapter, public MilvusGetLoadingProgressOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -42,7 +45,7 @@ public class MilvusGetLoadingProgressOpDispenser extends MilvusBaseOpDispenser<G
) { ) {
LongFunction<GetLoadingProgressParam.Builder> ebF = LongFunction<GetLoadingProgressParam.Builder> ebF =
l -> GetLoadingProgressParam.newBuilder().withCollectionName(targetF.apply(l)); l -> GetLoadingProgressParam.newBuilder().withCollectionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("partition_names","partitions"), List.class, ebF = op.enhanceFuncOptionally(ebF, "partitions", List.class,
GetLoadingProgressParam.Builder::withPartitionNames); GetLoadingProgressParam.Builder::withPartitionNames);
final LongFunction<GetLoadingProgressParam.Builder> lastF = ebF; final LongFunction<GetLoadingProgressParam.Builder> lastF = ebF;
return l -> lastF.apply(l).build(); return l -> lastF.apply(l).build();

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetMetricsOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.control.GetMetricsParam; import io.milvus.param.control.GetMetricsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetMetricsOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetMetricsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusGetMetricsOpDispenser extends MilvusBaseOpDispenser<GetMetric
public MilvusGetMetricsOpDispenser(MilvusDriverAdapter adapter, public MilvusGetMetricsOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetOpDispenser.java
View File

@ -21,6 +21,7 @@ import io.milvus.common.clientenum.ConsistencyLevelEnum;
import io.milvus.param.highlevel.dml.GetIdsParam; import io.milvus.param.highlevel.dml.GetIdsParam;
import io.nosqlbench.adapter.milvus.MilvusAdapterUtils; import io.nosqlbench.adapter.milvus.MilvusAdapterUtils;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -46,8 +47,10 @@ public class MilvusGetOpDispenser extends MilvusBaseOpDispenser<GetIdsParam> {
public MilvusGetOpDispenser(MilvusDriverAdapter adapter, public MilvusGetOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -75,7 +78,7 @@ public class MilvusGetOpDispenser extends MilvusBaseOpDispenser<GetIdsParam> {
LongFunction<GetIdsParam.Builder> finalEbF2 = ebF; LongFunction<GetIdsParam.Builder> finalEbF2 = ebF;
ebF = l -> finalEbF2.apply(l).withPrimaryIds(pidsF.apply(l)); ebF = l -> finalEbF2.apply(l).withPrimaryIds(pidsF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("collection_name", "collection"), String.class, ebF = op.enhanceFuncOptionally(ebF, "collection", String.class,
GetIdsParam.Builder::withCollectionName); GetIdsParam.Builder::withCollectionName);
ebF = op.enhanceEnumOptionally(ebF, "consistency_level", ConsistencyLevelEnum.class, ebF = op.enhanceEnumOptionally(ebF, "consistency_level", ConsistencyLevelEnum.class,
GetIdsParam.Builder::withConsistencyLevel); GetIdsParam.Builder::withConsistencyLevel);

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetPartitionStatisticsOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.partition.GetPartitionStatisticsParam; import io.milvus.param.partition.GetPartitionStatisticsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetPartitionStatisticsOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetPartitionStatisticsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,10 @@ public class MilvusGetPartitionStatisticsOpDispenser extends MilvusBaseOpDispens
public MilvusGetPartitionStatisticsOpDispenser(MilvusDriverAdapter adapter, public MilvusGetPartitionStatisticsOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -42,7 +45,7 @@ public class MilvusGetPartitionStatisticsOpDispenser extends MilvusBaseOpDispens
) { ) {
LongFunction<GetPartitionStatisticsParam.Builder> ebF = LongFunction<GetPartitionStatisticsParam.Builder> ebF =
l -> GetPartitionStatisticsParam.newBuilder().withPartitionName(targetF.apply(l)); l -> GetPartitionStatisticsParam.newBuilder().withPartitionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("collection_name","collection"),String.class, ebF = op.enhanceFuncOptionally(ebF, "collection",String.class,
GetPartitionStatisticsParam.Builder::withCollectionName); GetPartitionStatisticsParam.Builder::withCollectionName);
ebF = op.enhanceFuncOptionally(ebF, "flush",Boolean.class, GetPartitionStatisticsParam.Builder::withFlush); ebF = op.enhanceFuncOptionally(ebF, "flush",Boolean.class, GetPartitionStatisticsParam.Builder::withFlush);

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetPersistentSegmentInfoOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.partition.GetPartitionStatisticsParam; import io.milvus.param.partition.GetPartitionStatisticsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetPartitionStatisticsOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetPartitionStatisticsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,10 @@ public class MilvusGetPersistentSegmentInfoOpDispenser extends MilvusBaseOpDispe
public MilvusGetPersistentSegmentInfoOpDispenser(MilvusDriverAdapter adapter, public MilvusGetPersistentSegmentInfoOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -44,7 +47,7 @@ public class MilvusGetPersistentSegmentInfoOpDispenser extends MilvusBaseOpDispe
l -> GetPartitionStatisticsParam.newBuilder().withPartitionName(targetF.apply(l)); l -> GetPartitionStatisticsParam.newBuilder().withPartitionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF,"flush",Boolean.class,GetPartitionStatisticsParam.Builder::withFlush); ebF = op.enhanceFuncOptionally(ebF,"flush",Boolean.class,GetPartitionStatisticsParam.Builder::withFlush);
ebF = op.enhanceFuncOptionally(ebF, List.of("collection_name","collection"),String.class, ebF = op.enhanceFuncOptionally(ebF, "collection",String.class,
GetPartitionStatisticsParam.Builder::withCollectionName); GetPartitionStatisticsParam.Builder::withCollectionName);
final LongFunction<GetPartitionStatisticsParam.Builder> lastF = ebF; final LongFunction<GetPartitionStatisticsParam.Builder> lastF = ebF;

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetQuerySegmentInfoOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.control.GetQuerySegmentInfoParam; import io.milvus.param.control.GetQuerySegmentInfoParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetQuerySegmentInfoOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetQuerySegmentInfoOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusGetQuerySegmentInfoOpDispenser extends MilvusBaseOpDispenser<
public MilvusGetQuerySegmentInfoOpDispenser(MilvusDriverAdapter adapter, public MilvusGetQuerySegmentInfoOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusGetReplicasOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.control.GetReplicasParam; import io.milvus.param.control.GetReplicasParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetReplicasOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetReplicasOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusGetReplicasOpDispenser extends MilvusBaseOpDispenser<GetRepli
public MilvusGetReplicasOpDispenser(MilvusDriverAdapter adapter, public MilvusGetReplicasOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

8
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusHasPartitionOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.partition.HasPartitionParam; import io.milvus.param.partition.HasPartitionParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusHasPartitionOp; import io.nosqlbench.adapter.milvus.ops.MilvusHasPartitionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,9 @@ public class MilvusHasPartitionOpDispenser extends MilvusBaseOpDispenser<HasPart
public MilvusHasPartitionOpDispenser(MilvusDriverAdapter adapter, public MilvusHasPartitionOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -42,7 +44,7 @@ public class MilvusHasPartitionOpDispenser extends MilvusBaseOpDispenser<HasPart
) { ) {
LongFunction<HasPartitionParam.Builder> ebF = LongFunction<HasPartitionParam.Builder> ebF =
l -> HasPartitionParam.newBuilder().withPartitionName(targetF.apply(l)); l -> HasPartitionParam.newBuilder().withPartitionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("collection_name","collection"),String.class, ebF = op.enhanceFuncOptionally(ebF, "collection",String.class,
HasPartitionParam.Builder::withCollectionName); HasPartitionParam.Builder::withCollectionName);
final LongFunction<HasPartitionParam.Builder> lastF = ebF; final LongFunction<HasPartitionParam.Builder> lastF = ebF;

29
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusInsertOpDispenser.java
View File

@ -22,6 +22,7 @@ import com.alibaba.fastjson.JSONObject;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.dml.InsertParam; import io.milvus.param.dml.InsertParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusInsertOp; import io.nosqlbench.adapter.milvus.ops.MilvusInsertOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,9 +30,7 @@ import io.nosqlbench.nb.api.errors.OpConfigError;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Optional; import java.util.Optional;
import java.util.function.LongFunction; import java.util.function.LongFunction;
@ -39,16 +38,20 @@ public class MilvusInsertOpDispenser extends MilvusBaseOpDispenser<InsertParam>
private static final Logger logger = LogManager.getLogger(MilvusInsertOpDispenser.class); private static final Logger logger = LogManager.getLogger(MilvusInsertOpDispenser.class);
/** /**
* Create a new MilvusDeleteOpDispenser subclassed from {@link MilvusBaseOpDispenser}. Create a new MilvusDeleteOpDispenser subclassed from {@link MilvusBaseOpDispenser}.
* @param adapter
* @param adapter The associated {@link MilvusDriverAdapter} The associated {@link MilvusDriverAdapter}
* @param op The {@link ParsedOp} encapsulating the activity for this cycle @param op
* @param targetFunction A LongFunction that returns the specified Milvus Index for this Op The {@link ParsedOp} encapsulating the activity for this cycle
@param targetFunction
A LongFunction that returns the specified Milvus Index for this Op
*/ */
public MilvusInsertOpDispenser(MilvusDriverAdapter adapter, public MilvusInsertOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override
@ -57,11 +60,11 @@ public class MilvusInsertOpDispenser extends MilvusBaseOpDispenser<InsertParam>
l -> InsertParam.newBuilder().withCollectionName(targetF.apply(l)); l -> InsertParam.newBuilder().withCollectionName(targetF.apply(l));
f = op.enhanceFuncOptionally( f = op.enhanceFuncOptionally(
f, List.of("partition_name","partition"), String.class, f, "partition", String.class,
InsertParam.Builder::withPartitionName InsertParam.Builder::withPartitionName
); );
f = op.enhanceFuncOptionally( f = op.enhanceFuncOptionally(
f, List.of("database_name","database"), String.class, f, "database", String.class,
InsertParam.Builder::withDatabaseName InsertParam.Builder::withDatabaseName
); );
@ -76,13 +79,13 @@ public class MilvusInsertOpDispenser extends MilvusBaseOpDispenser<InsertParam>
} }
if (optionalRowsF.isPresent()) { if (optionalRowsF.isPresent()) {
var rf = optionalRowsF.get(); LongFunction<List<JSONObject>> rf = optionalRowsF.get();
LongFunction<InsertParam.Builder> finalF2 = f; LongFunction<InsertParam.Builder> finalF2 = f;
f = l -> finalF2.apply(l).withRows(rf.apply(l)); f = l -> finalF2.apply(l).withRows(rf.apply(l));
} }
if (optionalFieldsF.isPresent()) { if (optionalFieldsF.isPresent()) {
var ff = optionalFieldsF.get(); LongFunction<List<InsertParam.Field>> ff = optionalFieldsF.get();
LongFunction<InsertParam.Builder> finalF3 = f; LongFunction<InsertParam.Builder> finalF3 = f;
f = l -> finalF3.apply(l).withFields(ff.apply(l)); f = l -> finalF3.apply(l).withFields(ff.apply(l));
} }

29
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusInsertRowsOpDispenser.java
View File

@ -18,43 +18,38 @@ package io.nosqlbench.adapter.milvus.opdispensers;
*/ */
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.dml.InsertParam;
import io.milvus.param.highlevel.dml.InsertRowsParam; import io.milvus.param.highlevel.dml.InsertRowsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusInsertOp;
import io.nosqlbench.adapter.milvus.ops.MilvusInsertRowsOp; import io.nosqlbench.adapter.milvus.ops.MilvusInsertRowsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.nosqlbench.nb.api.errors.OpConfigError;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.LongFunction; import java.util.function.LongFunction;
public class MilvusInsertRowsOpDispenser extends MilvusBaseOpDispenser<InsertRowsParam> { public class MilvusInsertRowsOpDispenser extends MilvusBaseOpDispenser<InsertRowsParam> {
private static final Logger logger = LogManager.getLogger(MilvusInsertRowsOpDispenser.class); private static final Logger logger = LogManager.getLogger(MilvusInsertRowsOpDispenser.class);
/** /**
* Create a new MilvusDeleteOpDispenser subclassed from {@link MilvusBaseOpDispenser}. Create a new MilvusDeleteOpDispenser subclassed from {@link MilvusBaseOpDispenser}.
* @param adapter
* @param adapter The associated {@link MilvusDriverAdapter}
* The associated {@link MilvusDriverAdapter} @param op
* @param op The {@link ParsedOp} encapsulating the activity for this cycle
* The {@link ParsedOp} encapsulating the activity for this cycle @param targetFunction
* @param targetFunction A LongFunction that returns the specified Milvus Index for this Op
* A LongFunction that returns the specified Milvus Index for this Op
*/ */
public MilvusInsertRowsOpDispenser(MilvusDriverAdapter adapter, public MilvusInsertRowsOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction,spaceF);
} }
@Override @Override

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusListBulkInsertTasksOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.bulkinsert.ListBulkInsertTasksParam; import io.milvus.param.bulkinsert.ListBulkInsertTasksParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusListBulkInsertTasksOp; import io.nosqlbench.adapter.milvus.ops.MilvusListBulkInsertTasksOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusListBulkInsertTasksOpDispenser extends MilvusBaseOpDispenser<
public MilvusListBulkInsertTasksOpDispenser(MilvusDriverAdapter adapter, public MilvusListBulkInsertTasksOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusListCollectionsOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.highlevel.collection.ListCollectionsParam; import io.milvus.param.highlevel.collection.ListCollectionsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusListCollectionsOp; import io.nosqlbench.adapter.milvus.ops.MilvusListCollectionsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusListCollectionsOpDispenser extends MilvusBaseOpDispenser<List
public MilvusListCollectionsOpDispenser(MilvusDriverAdapter adapter, public MilvusListCollectionsOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusListCredUsersOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.credential.ListCredUsersParam; import io.milvus.param.credential.ListCredUsersParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusListCredUsersOp; import io.nosqlbench.adapter.milvus.ops.MilvusListCredUsersOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusListCredUsersOpDispenser extends MilvusBaseOpDispenser<ListCr
public MilvusListCredUsersOpDispenser(MilvusDriverAdapter adapter, public MilvusListCredUsersOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusListDatabasesOpDispenser.java
View File

@ -18,6 +18,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusListDatabasesOp; import io.nosqlbench.adapter.milvus.ops.MilvusListDatabasesOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -28,8 +29,10 @@ public class MilvusListDatabasesOpDispenser extends MilvusBaseOpDispenser<Object
public MilvusListDatabasesOpDispenser(MilvusDriverAdapter adapter, public MilvusListDatabasesOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusLoadBalanceOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.control.LoadBalanceParam; import io.milvus.param.control.LoadBalanceParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusLoadBalanceOp; import io.nosqlbench.adapter.milvus.ops.MilvusLoadBalanceOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusLoadBalanceOpDispenser extends MilvusBaseOpDispenser<LoadBala
public MilvusLoadBalanceOpDispenser(MilvusDriverAdapter adapter, public MilvusLoadBalanceOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusLoadCollectionOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.LoadCollectionParam; import io.milvus.param.collection.LoadCollectionParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusLoadCollectionOp; import io.nosqlbench.adapter.milvus.ops.MilvusLoadCollectionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -30,8 +31,10 @@ public class MilvusLoadCollectionOpDispenser extends MilvusBaseOpDispenser<LoadC
public MilvusLoadCollectionOpDispenser(MilvusDriverAdapter adapter, public MilvusLoadCollectionOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -43,7 +46,7 @@ public class MilvusLoadCollectionOpDispenser extends MilvusBaseOpDispenser<LoadC
LongFunction<LoadCollectionParam.Builder> ebF = LongFunction<LoadCollectionParam.Builder> ebF =
l -> LoadCollectionParam.newBuilder().withCollectionName(targetF.apply(l)); l -> LoadCollectionParam.newBuilder().withCollectionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("database_name", "database"), String.class, ebF = op.enhanceFuncOptionally(ebF, "database", String.class,
LoadCollectionParam.Builder::withDatabaseName); LoadCollectionParam.Builder::withDatabaseName);
ebF = op.enhanceFuncOptionally(ebF, "refresh", Boolean.class, LoadCollectionParam.Builder::withRefresh); ebF = op.enhanceFuncOptionally(ebF, "refresh", Boolean.class, LoadCollectionParam.Builder::withRefresh);

18
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusLoadPartitionsOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.partition.LoadPartitionsParam; import io.milvus.param.partition.LoadPartitionsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusLoadPartitionsOp; import io.nosqlbench.adapter.milvus.ops.MilvusLoadPartitionsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,16 +30,15 @@ import java.util.function.LongFunction;
public class MilvusLoadPartitionsOpDispenser extends MilvusBaseOpDispenser<LoadPartitionsParam> { public class MilvusLoadPartitionsOpDispenser extends MilvusBaseOpDispenser<LoadPartitionsParam> {
/** /**
* TODO: Refactor this class after API refinements for more type and target variation TODO: Refactor this class after API refinements for more type and target variation
* @param adapter
* @param adapter
* @param op
* @param targetFunction
*/ */
public MilvusLoadPartitionsOpDispenser(MilvusDriverAdapter adapter, public MilvusLoadPartitionsOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -50,14 +50,14 @@ public class MilvusLoadPartitionsOpDispenser extends MilvusBaseOpDispenser<LoadP
LongFunction<LoadPartitionsParam.Builder> ebF = LongFunction<LoadPartitionsParam.Builder> ebF =
l -> LoadPartitionsParam.newBuilder().withCollectionName(targetF.apply(l)); l -> LoadPartitionsParam.newBuilder().withCollectionName(targetF.apply(l));
ebF = op.enhanceFunc(ebF, List.of("partition_names", "partitions"), List.class, ebF = op.enhanceFunc(ebF, "partitions", List.class,
LoadPartitionsParam.Builder::withPartitionNames); LoadPartitionsParam.Builder::withPartitionNames);
ebF = op.enhanceFuncOptionally( ebF = op.enhanceFuncOptionally(
ebF, "resource_groups", List.class, ebF, "resource_groups", List.class,
LoadPartitionsParam.Builder::withResourceGroups LoadPartitionsParam.Builder::withResourceGroups
); );
ebF = op.enhanceFuncOptionally( ebF = op.enhanceFuncOptionally(
ebF, List.of("database_name", "database"), String.class, ebF, "database", String.class,
LoadPartitionsParam.Builder::withDatabaseName LoadPartitionsParam.Builder::withDatabaseName
); );
ebF = op.enhanceFuncOptionally(ebF, "refresh", Boolean.class, LoadPartitionsParam.Builder::withRefresh); ebF = op.enhanceFuncOptionally(ebF, "refresh", Boolean.class, LoadPartitionsParam.Builder::withRefresh);

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusLoadingProgressOpDispenser.java
View File

@ -19,8 +19,10 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.GetLoadingProgressParam; import io.milvus.param.collection.GetLoadingProgressParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusGetLoadingProgressOp; import io.nosqlbench.adapter.milvus.ops.MilvusGetLoadingProgressOp;
import io.nosqlbench.adapter.milvus.ops.MilvusSearchOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
import java.util.List; import java.util.List;
@ -30,8 +32,9 @@ public class MilvusLoadingProgressOpDispenser extends MilvusBaseOpDispenser<GetL
public MilvusLoadingProgressOpDispenser(MilvusDriverAdapter adapter, public MilvusLoadingProgressOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -42,7 +45,7 @@ public class MilvusLoadingProgressOpDispenser extends MilvusBaseOpDispenser<GetL
) { ) {
LongFunction<GetLoadingProgressParam.Builder> ebF = LongFunction<GetLoadingProgressParam.Builder> ebF =
l -> GetLoadingProgressParam.newBuilder().withCollectionName(targetF.apply(l)); l -> GetLoadingProgressParam.newBuilder().withCollectionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF,List.of("partition_names","partitions"), List.class, ebF = op.enhanceFuncOptionally(ebF,"partitions", List.class,
GetLoadingProgressParam.Builder::withPartitionNames); GetLoadingProgressParam.Builder::withPartitionNames);
final LongFunction<GetLoadingProgressParam.Builder> lastF = ebF; final LongFunction<GetLoadingProgressParam.Builder> lastF = ebF;

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusManualCompactOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.control.ManualCompactParam; import io.milvus.param.control.ManualCompactParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusManualCompactOp; import io.nosqlbench.adapter.milvus.ops.MilvusManualCompactOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusManualCompactOpDispenser extends MilvusBaseOpDispenser<Manual
public MilvusManualCompactOpDispenser(MilvusDriverAdapter adapter, public MilvusManualCompactOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusQueryOpDispenser.java
View File

@ -20,6 +20,7 @@ import io.milvus.client.MilvusServiceClient;
import io.milvus.common.clientenum.ConsistencyLevelEnum; import io.milvus.common.clientenum.ConsistencyLevelEnum;
import io.milvus.param.dml.QueryParam; import io.milvus.param.dml.QueryParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusQueryOp; import io.nosqlbench.adapter.milvus.ops.MilvusQueryOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -31,8 +32,10 @@ public class MilvusQueryOpDispenser extends MilvusBaseOpDispenser<QueryParam> {
public MilvusQueryOpDispenser(MilvusDriverAdapter adapter, public MilvusQueryOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -44,7 +47,7 @@ public class MilvusQueryOpDispenser extends MilvusBaseOpDispenser<QueryParam> {
LongFunction<QueryParam.Builder> ebF = LongFunction<QueryParam.Builder> ebF =
l -> QueryParam.newBuilder().withCollectionName(targetF.apply(l)); l -> QueryParam.newBuilder().withCollectionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("partition_names", "partitions"), List.class, ebF = op.enhanceFuncOptionally(ebF, "partitions", List.class,
QueryParam.Builder::withPartitionNames); QueryParam.Builder::withPartitionNames);
ebF = op.enhanceEnumOptionally(ebF, "consistency_level", ConsistencyLevelEnum.class, QueryParam.Builder::withConsistencyLevel); ebF = op.enhanceEnumOptionally(ebF, "consistency_level", ConsistencyLevelEnum.class, QueryParam.Builder::withConsistencyLevel);
ebF = op.enhanceFuncOptionally(ebF, "expr", String.class, QueryParam.Builder::withExpr); ebF = op.enhanceFuncOptionally(ebF, "expr", String.class, QueryParam.Builder::withExpr);

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusReleaseCollectionOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.collection.ReleaseCollectionParam; import io.milvus.param.collection.ReleaseCollectionParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusReleaseCollectionOp; import io.nosqlbench.adapter.milvus.ops.MilvusReleaseCollectionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusReleaseCollectionOpDispenser extends MilvusBaseOpDispenser<Re
public MilvusReleaseCollectionOpDispenser(MilvusDriverAdapter adapter, public MilvusReleaseCollectionOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusReleasePartitionsOpDispenser.java
View File

@ -20,6 +20,7 @@ import io.milvus.client.MilvusServiceClient;
import io.milvus.param.partition.ReleasePartitionsParam; import io.milvus.param.partition.ReleasePartitionsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusAdapterUtils; import io.nosqlbench.adapter.milvus.MilvusAdapterUtils;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusReleasePartitionsOp; import io.nosqlbench.adapter.milvus.ops.MilvusReleasePartitionsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -31,8 +32,10 @@ public class MilvusReleasePartitionsOpDispenser extends MilvusBaseOpDispenser<Re
public MilvusReleasePartitionsOpDispenser(MilvusDriverAdapter adapter, public MilvusReleasePartitionsOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -47,7 +50,7 @@ public class MilvusReleasePartitionsOpDispenser extends MilvusBaseOpDispenser<Re
LongFunction<ReleasePartitionsParam.Builder> finalEbF = ebF; LongFunction<ReleasePartitionsParam.Builder> finalEbF = ebF;
ebF = l -> finalEbF.apply(l).withPartitionNames(partNamesF.apply(l)); ebF = l -> finalEbF.apply(l).withPartitionNames(partNamesF.apply(l));
ebF = op.enhanceFuncOptionally(ebF,List.of("collection_name","collection"),String.class, ebF = op.enhanceFuncOptionally(ebF,"collection",String.class,
ReleasePartitionsParam.Builder::withCollectionName); ReleasePartitionsParam.Builder::withCollectionName);
final LongFunction<ReleasePartitionsParam.Builder> lastF = ebF; final LongFunction<ReleasePartitionsParam.Builder> lastF = ebF;

10
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusSearchOpDispenser.java
View File

@ -21,6 +21,7 @@ import io.milvus.common.clientenum.ConsistencyLevelEnum;
import io.milvus.param.MetricType; import io.milvus.param.MetricType;
import io.milvus.param.dml.SearchParam; import io.milvus.param.dml.SearchParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusSearchOp; import io.nosqlbench.adapter.milvus.ops.MilvusSearchOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -32,8 +33,9 @@ public class MilvusSearchOpDispenser extends MilvusBaseOpDispenser<SearchParam>
public MilvusSearchOpDispenser( public MilvusSearchOpDispenser(
MilvusDriverAdapter adapter, MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction, LongFunction<MilvusSpace> spaceF
super(adapter, op, targetFunction); ) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -43,7 +45,7 @@ public class MilvusSearchOpDispenser extends MilvusBaseOpDispenser<SearchParam>
LongFunction<SearchParam.Builder> ebF = LongFunction<SearchParam.Builder> ebF =
l -> SearchParam.newBuilder().withCollectionName(targetF.apply(l)); l -> SearchParam.newBuilder().withCollectionName(targetF.apply(l));
ebF = op.enhanceFuncOptionally(ebF, List.of("partition_names", "partitions"), List.class, SearchParam.Builder::withPartitionNames); ebF = op.enhanceFuncOptionally(ebF, "partitions", List.class, SearchParam.Builder::withPartitionNames);
ebF = op.enhanceFuncOptionally(ebF, "out_fields", List.class, SearchParam.Builder::withOutFields); ebF = op.enhanceFuncOptionally(ebF, "out_fields", List.class, SearchParam.Builder::withOutFields);
@ -56,7 +58,7 @@ public class MilvusSearchOpDispenser extends MilvusBaseOpDispenser<SearchParam>
(SearchParam.Builder b, Number n) -> b.withRoundDecimal(n.intValue())); (SearchParam.Builder b, Number n) -> b.withRoundDecimal(n.intValue()));
ebF = op.enhanceFuncOptionally(ebF, "ignore_growing", Boolean.class, SearchParam.Builder::withIgnoreGrowing); ebF = op.enhanceFuncOptionally(ebF, "ignore_growing", Boolean.class, SearchParam.Builder::withIgnoreGrowing);
ebF = op.enhanceFuncOptionally(ebF, "params", String.class, SearchParam.Builder::withParams); ebF = op.enhanceFuncOptionally(ebF, "params", String.class, SearchParam.Builder::withParams);
ebF = op.enhanceFunc(ebF, List.of("vector_field_name", "vector_field"), String.class, ebF = op.enhanceFunc(ebF, "vector_field", String.class,
SearchParam.Builder::withVectorFieldName); SearchParam.Builder::withVectorFieldName);
// TODO: sanity check List of Floats vs List of List of Floats at func construction time. // TODO: sanity check List of Floats vs List of List of Floats at func construction time.
ebF = op.enhanceFuncOptionally(ebF, "vectors", List.class, SearchParam.Builder::withVectors); ebF = op.enhanceFuncOptionally(ebF, "vectors", List.class, SearchParam.Builder::withVectors);

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusShowCollectionsOpDispenser.java
View File

@ -21,6 +21,7 @@ import io.milvus.grpc.ShowType;
import io.milvus.param.collection.ShowCollectionsParam; import io.milvus.param.collection.ShowCollectionsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusAdapterUtils; import io.nosqlbench.adapter.milvus.MilvusAdapterUtils;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusShowCollectionsOp; import io.nosqlbench.adapter.milvus.ops.MilvusShowCollectionsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -32,8 +33,10 @@ public class MilvusShowCollectionsOpDispenser extends MilvusBaseOpDispenser<Show
public MilvusShowCollectionsOpDispenser(MilvusDriverAdapter adapter, public MilvusShowCollectionsOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -47,7 +50,7 @@ public class MilvusShowCollectionsOpDispenser extends MilvusBaseOpDispenser<Show
LongFunction<List<String>> collectionsF = l -> MilvusAdapterUtils.splitNames(targetF.apply(l)); LongFunction<List<String>> collectionsF = l -> MilvusAdapterUtils.splitNames(targetF.apply(l));
LongFunction<ShowCollectionsParam.Builder> finalEbF = ebF; LongFunction<ShowCollectionsParam.Builder> finalEbF = ebF;
ebF = l -> finalEbF.apply(l).withCollectionNames(collectionsF.apply(l)); ebF = l -> finalEbF.apply(l).withCollectionNames(collectionsF.apply(l));
ebF = op.enhanceFuncOptionally(ebF,List.of("database_name","database"),String.class, ebF = op.enhanceFuncOptionally(ebF,"database",String.class,
ShowCollectionsParam.Builder::withDatabaseName); ShowCollectionsParam.Builder::withDatabaseName);
ebF = op.enhanceEnumOptionally(ebF,"show_type", ShowType.class,ShowCollectionsParam.Builder::withShowType); ebF = op.enhanceEnumOptionally(ebF,"show_type", ShowType.class,ShowCollectionsParam.Builder::withShowType);
logger.warn(this.getClass().getSimpleName() + " is deprecated, use get_loading_progress instead"); logger.warn(this.getClass().getSimpleName() + " is deprecated, use get_loading_progress instead");

9
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusShowPartitionsOpDispenser.java
View File

@ -20,6 +20,7 @@ import io.milvus.client.MilvusServiceClient;
import io.milvus.param.partition.ShowPartitionsParam; import io.milvus.param.partition.ShowPartitionsParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusAdapterUtils; import io.nosqlbench.adapter.milvus.MilvusAdapterUtils;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusShowPartitionsOp; import io.nosqlbench.adapter.milvus.ops.MilvusShowPartitionsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -31,8 +32,10 @@ public class MilvusShowPartitionsOpDispenser extends MilvusBaseOpDispenser<ShowP
public MilvusShowPartitionsOpDispenser(MilvusDriverAdapter adapter, public MilvusShowPartitionsOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override
@ -47,7 +50,7 @@ public class MilvusShowPartitionsOpDispenser extends MilvusBaseOpDispenser<ShowP
LongFunction<List<String>> partitionsF = l -> MilvusAdapterUtils.splitNames(targetF.apply(l)); LongFunction<List<String>> partitionsF = l -> MilvusAdapterUtils.splitNames(targetF.apply(l));
LongFunction<ShowPartitionsParam.Builder> finalEbF = ebF; LongFunction<ShowPartitionsParam.Builder> finalEbF = ebF;
ebF = l -> finalEbF.apply(l).withPartitionNames(partitionsF.apply(l)); ebF = l -> finalEbF.apply(l).withPartitionNames(partitionsF.apply(l));
ebF = op.enhanceFuncOptionally(ebF,List.of("collection_name","collection"),String.class, ebF = op.enhanceFuncOptionally(ebF,"collection",String.class,
ShowPartitionsParam.Builder::withCollectionName); ShowPartitionsParam.Builder::withCollectionName);
final LongFunction<ShowPartitionsParam.Builder> lastF = ebF; final LongFunction<ShowPartitionsParam.Builder> lastF = ebF;
final LongFunction<ShowPartitionsParam> collectionParamF = l -> lastF.apply(l).build(); final LongFunction<ShowPartitionsParam> collectionParamF = l -> lastF.apply(l).build();

7
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/opdispensers/MilvusUpdateCredentialOpDispenser.java
View File

@ -19,6 +19,7 @@ package io.nosqlbench.adapter.milvus.opdispensers;
import io.milvus.client.MilvusServiceClient; import io.milvus.client.MilvusServiceClient;
import io.milvus.param.credential.UpdateCredentialParam; import io.milvus.param.credential.UpdateCredentialParam;
import io.nosqlbench.adapter.milvus.MilvusDriverAdapter; import io.nosqlbench.adapter.milvus.MilvusDriverAdapter;
import io.nosqlbench.adapter.milvus.MilvusSpace;
import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp; import io.nosqlbench.adapter.milvus.ops.MilvusBaseOp;
import io.nosqlbench.adapter.milvus.ops.MilvusUpdateCredentialOp; import io.nosqlbench.adapter.milvus.ops.MilvusUpdateCredentialOp;
import io.nosqlbench.adapters.api.templating.ParsedOp; import io.nosqlbench.adapters.api.templating.ParsedOp;
@ -29,8 +30,10 @@ public class MilvusUpdateCredentialOpDispenser extends MilvusBaseOpDispenser<Upd
public MilvusUpdateCredentialOpDispenser(MilvusDriverAdapter adapter, public MilvusUpdateCredentialOpDispenser(MilvusDriverAdapter adapter,
ParsedOp op, ParsedOp op,
LongFunction<String> targetFunction) { LongFunction<String> targetFunction,
super(adapter, op, targetFunction); LongFunction<MilvusSpace> spaceF
) {
super(adapter, op, targetFunction, spaceF);
} }
@Override @Override

2
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/ops/MilvusBaseOp.java
View File

@ -52,7 +52,7 @@ public abstract class MilvusBaseOp<T> implements CycleOp<Object> {
try { try {
Object result = applyOp(value); Object result = applyOp(value);
if (result instanceof R<?> r) { if (result instanceof R<?> r) {
var error = r.getException(); Exception error = r.getException();
if (error!=null) { if (error!=null) {
throw error; throw error;
} }

4
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/ops/MilvusDescribeIndexOp.java
View File

@ -21,7 +21,7 @@ import io.milvus.grpc.DescribeIndexResponse;
import io.milvus.grpc.IndexDescription; import io.milvus.grpc.IndexDescription;
import io.milvus.param.R; import io.milvus.param.R;
import io.milvus.param.index.DescribeIndexParam; import io.milvus.param.index.DescribeIndexParam;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op; import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.OpGenerator; import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.OpGenerator;
import io.nosqlbench.adapters.api.scheduling.TimeoutPredicate; import io.nosqlbench.adapters.api.scheduling.TimeoutPredicate;
@ -98,7 +98,7 @@ public class MilvusDescribeIndexOp extends MilvusBaseOp<DescribeIndexParam> impl
} }
@Override @Override
public Op getNextOp() { public CycleOp<Object> getNextOp() {
return nextOp; return nextOp;
} }
} }

4
nb-adapters/adapter-milvus/src/main/java/io/nosqlbench/adapter/milvus/ops/MilvusGetLoadStateOp.java
View File

@ -22,7 +22,7 @@ import io.milvus.grpc.LoadState;
import io.milvus.param.R; import io.milvus.param.R;
import io.milvus.param.collection.GetLoadStateParam; import io.milvus.param.collection.GetLoadStateParam;
import io.nosqlbench.adapter.milvus.exceptions.MilvusAwaitStateIncompleteError; import io.nosqlbench.adapter.milvus.exceptions.MilvusAwaitStateIncompleteError;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op; import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.OpGenerator; import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.OpGenerator;
import io.nosqlbench.adapters.api.scheduling.TimeoutPredicate; import io.nosqlbench.adapters.api.scheduling.TimeoutPredicate;
@ -65,7 +65,7 @@ public class MilvusGetLoadStateOp extends MilvusBaseOp<GetLoadStateParam> implem
} }
@Override @Override
public Op getNextOp() { public CycleOp<Object> getNextOp() {
return this.nextOp; return this.nextOp;
} }
} }

6
nb-adapters/adapter-mongodb/src/main/java/io/nosqlbench/adapter/mongodb/core/MongoOpMapper.java
View File

@ -43,7 +43,7 @@ public class MongoOpMapper<MC extends MongoDirectCommandOp> implements OpMapper<
} }
@Override @Override
public OpDispenser<MongoDirectCommandOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<MongoSpace> spaceInitF) { public OpDispenser<MongoDirectCommandOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<MongoSpace> spaceF) {
LongFunction<String> ctxNamer = op.getAsFunctionOr("space", "default"); LongFunction<String> ctxNamer = op.getAsFunctionOr("space", "default");
@ -65,12 +65,12 @@ public class MongoOpMapper<MC extends MongoDirectCommandOp> implements OpMapper<
if (target.isPresent()) { if (target.isPresent()) {
TypeAndTarget<MongoDBOpTypes, String> targetData = target.get(); TypeAndTarget<MongoDBOpTypes, String> targetData = target.get();
return switch (targetData.enumId) { return switch (targetData.enumId) {
case command -> new MongoCommandOpDispenser(adapter, spaceInitF, op); case command -> new MongoCommandOpDispenser(adapter, spaceF, op);
}; };
} }
// For everything else use the command API // For everything else use the command API
else { else {
return new MongoCommandOpDispenser(adapter, spaceInitF, op); return new MongoCommandOpDispenser(adapter, spaceF, op);
} }

2
nb-adapters/adapter-neo4j/src/main/java/io/nosqlbench/adapter/neo4j/Neo4JOpMapper.java
View File

@ -36,7 +36,7 @@ public class Neo4JOpMapper implements OpMapper<Neo4JBaseOp,Neo4JSpace> {
} }
@Override @Override
public OpDispenser<Neo4JBaseOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<Neo4JSpace> spaceInitF) { public OpDispenser<Neo4JBaseOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<Neo4JSpace> spaceF) {
TypeAndTarget<Neo4JOpType, String> typeAndTarget = op.getTypeAndTarget(Neo4JOpType.class, String.class); TypeAndTarget<Neo4JOpType, String> typeAndTarget = op.getTypeAndTarget(Neo4JOpType.class, String.class);
LongFunction<Neo4JSpace> spaceFunc = adapter.getSpaceFunc(op); LongFunction<Neo4JSpace> spaceFunc = adapter.getSpaceFunc(op);
return switch (typeAndTarget.enumId) { return switch (typeAndTarget.enumId) {

3
nb-adapters/adapter-neo4j/src/main/java/io/nosqlbench/adapter/neo4j/ops/Neo4JSyncReadTxnOp.java
View File

@ -18,6 +18,7 @@ package io.nosqlbench.adapter.neo4j.ops;
import org.neo4j.driver.Query; import org.neo4j.driver.Query;
import org.neo4j.driver.Record; import org.neo4j.driver.Record;
import org.neo4j.driver.Result;
import org.neo4j.driver.Session; import org.neo4j.driver.Session;
import java.util.List; import java.util.List;
@ -35,7 +36,7 @@ public class Neo4JSyncReadTxnOp extends Neo4JBaseOp{
public final Record[] apply(long value) { public final Record[] apply(long value) {
List<Record> recordList = session.executeRead( List<Record> recordList = session.executeRead(
txn -> { txn -> {
var result = txn.run(query); Result result = txn.run(query);
return result.list(); return result.list();
} }
); );

3
nb-adapters/adapter-neo4j/src/main/java/io/nosqlbench/adapter/neo4j/ops/Neo4JSyncWriteTxnOp.java
View File

@ -18,6 +18,7 @@ package io.nosqlbench.adapter.neo4j.ops;
import org.neo4j.driver.Query; import org.neo4j.driver.Query;
import org.neo4j.driver.Record; import org.neo4j.driver.Record;
import org.neo4j.driver.Result;
import org.neo4j.driver.Session; import org.neo4j.driver.Session;
import java.util.List; import java.util.List;
@ -35,7 +36,7 @@ public class Neo4JSyncWriteTxnOp extends Neo4JBaseOp{
public final Record[] apply(long value) { public final Record[] apply(long value) {
List<Record> recordList = session.executeWrite( List<Record> recordList = session.executeWrite(
txn -> { txn -> {
var result = txn.run(query); Result result = txn.run(query);
return result.list(); return result.list();
} }
); );

2
nb-adapters/adapter-pulsar/src/main/java/io/nosqlbench/adapter/pulsar/PulsarOpMapper.java
View File

@ -42,7 +42,7 @@ public class PulsarOpMapper implements OpMapper<PulsarOp,PulsarSpace> {
} }
@Override @Override
public OpDispenser<PulsarOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<PulsarSpace> spaceInitF) { public OpDispenser<PulsarOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<PulsarSpace> spaceF) {
int spaceName = op.getStaticConfigOr("space", 0); int spaceName = op.getStaticConfigOr("space", 0);
// PulsarSpace pulsarSpace = spaceCache.get(spaceName); // PulsarSpace pulsarSpace = spaceCache.get(spaceName);
PulsarSpace pulsarSpace = adapter.getSpaceFunc(op).apply(spaceName); PulsarSpace pulsarSpace = adapter.getSpaceFunc(op).apply(spaceName);

4
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/QdrantOpMapper.java
View File

@ -48,11 +48,11 @@ public class QdrantOpMapper implements OpMapper<QdrantBaseOp<?,?>,QdrantSpace> {
* @param adapterC * @param adapterC
* @param op * @param op
* The {@link ParsedOp} to be evaluated * The {@link ParsedOp} to be evaluated
* @param spaceInitF * @param spaceF
* @return The correct {@link QdrantBaseOpDispenser} subclass based on the op type * @return The correct {@link QdrantBaseOpDispenser} subclass based on the op type
*/ */
@Override @Override
public OpDispenser<QdrantBaseOp<?,?>> apply(NBComponent adapterC, ParsedOp op, LongFunction<QdrantSpace> spaceInitF) { public OpDispenser<QdrantBaseOp<?,?>> apply(NBComponent adapterC, ParsedOp op, LongFunction<QdrantSpace> spaceF) {
TypeAndTarget<QdrantOpType, String> typeAndTarget = op.getTypeAndTarget( TypeAndTarget<QdrantOpType, String> typeAndTarget = op.getTypeAndTarget(
QdrantOpType.class, QdrantOpType.class,
String.class, String.class,

2
nb-adapters/adapter-s4j/src/main/java/io/nosqlbench/adapter/s4j/S4JOpMapper.java
View File

@ -40,7 +40,7 @@ public class S4JOpMapper implements OpMapper<S4JOp,S4JSpace> {
} }
@Override @Override
public OpDispenser<S4JOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<S4JSpace> spaceInitF) { public OpDispenser<S4JOp> apply(NBComponent adapterC, ParsedOp op, LongFunction<S4JSpace> spaceF) {
/* /*
* If the user provides a body element, then they want to provide the JSON or * If the user provides a body element, then they want to provide the JSON or

2
nb-adapters/adapter-stdout/src/main/java/io/nosqlbench/adapter/stdout/StdoutDriverAdapter.java
View File

@ -95,7 +95,7 @@ public class StdoutDriverAdapter extends BaseDriverAdapter<StdoutOp, StdoutSpace
} }
OpData op = new OpData("synthetic", "synthetic", Map.of(), opsDocList.getDocBindings(), cfg, OpData op = new OpData("synthetic", "synthetic", Map.of(), opsDocList.getDocBindings(), cfg,
Map.of("stmt", genStatementTemplate(filteredBindingNames, cfg))); Map.of("stmt", genStatementTemplate(filteredBindingNames, cfg)),200);
return List.of(op); return List.of(op);
} }

Some files were not shown because too many files have changed in this diff Show More