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/nosqlbench-2057-flattenop (#2067)

Browse Source 
* remove ChainingOp

* typos and other minor fixes

* remove Op, ChainingOp, flatten to CycleOp, derive RunnableOp

* refactor qdrant for aligned op types

* refactor mongodb for aligned op types

* refactor cqld4 for aligned op types

* minor API alignment

refactor gcpspanner for aligned op types

* minor API alignment

refactor gcpspanner for aligned op types

add license

* fix cqld4 batch statement mapper

* fix cql base op mapper

* remove var inference

* remove emitter for runnable op
This commit is contained in:
Jonathan Shook
2024-11-04 16:42:05 -06:00
committed by GitHub
parent 62ad93cb59
commit ea7fceae49
87 changed files with 331 additions and 539 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -32,14 +32,14 @@ import io.nosqlbench.nb.api.labels.NBLabels;
import static io.nosqlbench.adapter.azureaisearch.AzureAISearchAdapterUtils.AZURE_AI_SEARCH;
@Service(value = DriverAdapter.class, selector = AZURE_AI_SEARCH)
public class AzureAISearchDriverAdapter extends BaseDriverAdapter<AzureAISearchBaseOp, AzureAISearchSpace> {
public class AzureAISearchDriverAdapter extends BaseDriverAdapter<AzureAISearchBaseOp<?,?>, AzureAISearchSpace> {
public AzureAISearchDriverAdapter(NBComponent parentComponent, NBLabels labels) {
super(parentComponent, labels);
}
@Override
public OpMapper<AzureAISearchBaseOp,AzureAISearchSpace> getOpMapper() {
public OpMapper<AzureAISearchBaseOp<?,?>,AzureAISearchSpace> getOpMapper() {
return new AzureAISearchOpMapper(this);
}

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

@@ -16,6 +16,7 @@
package io.nosqlbench.adapter.azureaisearch;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@@ -34,7 +35,7 @@ import io.nosqlbench.engine.api.templating.TypeAndTarget;
import java.util.function.LongFunction;
public class AzureAISearchOpMapper implements OpMapper<AzureAISearchBaseOp, AzureAISearchSpace> {
public class AzureAISearchOpMapper implements OpMapper<AzureAISearchBaseOp<?,?>, AzureAISearchSpace> {
private static final Logger logger = LogManager.getLogger(AzureAISearchOpMapper.class);
private final AzureAISearchDriverAdapter adapter;
@@ -60,7 +61,7 @@ public class AzureAISearchOpMapper implements OpMapper<AzureAISearchBaseOp, Azur
* the op type
*/
@Override
public OpDispenser<AzureAISearchBaseOp> apply(ParsedOp op, LongFunction<AzureAISearchSpace> spaceInitF) {
public OpDispenser<AzureAISearchBaseOp<?,?>> apply(ParsedOp op, LongFunction<AzureAISearchSpace> spaceInitF) {
TypeAndTarget<AzureAISearchOpType, String> typeAndTarget = op.getTypeAndTarget(AzureAISearchOpType.class,
String.class, "type", "target");

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

@@ -29,7 +29,7 @@ import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
import io.nosqlbench.adapters.api.templating.ParsedOp;
public abstract class AzureAISearchBaseOpDispenser<REQUEST,RESULT>
extends BaseOpDispenser<AzureAISearchBaseOp, AzureAISearchSpace> {
extends BaseOpDispenser<AzureAISearchBaseOp<?,?>, AzureAISearchSpace> {
protected final LongFunction<AzureAISearchSpace> azureAISearchSpaceFunction;
protected final LongFunction<SearchIndexClient> clientFunction;

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

@@ -18,13 +18,11 @@ package io.nosqlbench.adapter.cqld4;
import io.nosqlbench.adapter.cqld4.opmappers.Cqld4CoreOpMapper;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
import io.nosqlbench.nb.api.config.standard.NBConfigModel;
import io.nosqlbench.nb.api.config.standard.NBConfiguration;
import io.nosqlbench.adapters.api.activityimpl.OpMapper;
import io.nosqlbench.adapters.api.activityimpl.uniform.BaseDriverAdapter;
import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import io.nosqlbench.nb.api.labels.NBLabels;
import io.nosqlbench.nb.api.components.core.NBComponent;
import io.nosqlbench.nb.annotations.Service;
@@ -39,7 +37,7 @@ import java.util.function.Function;
import java.util.function.LongFunction;
@Service(value = DriverAdapter.class, selector = "cqld4")
public class Cqld4DriverAdapter extends BaseDriverAdapter<Cqld4BaseOp, Cqld4Space> {
public class Cqld4DriverAdapter extends BaseDriverAdapter<Cqld4BaseOp<?>, Cqld4Space> {
private final static Logger logger = LogManager.getLogger(Cqld4DriverAdapter.class);
public Cqld4DriverAdapter(NBComponent parentComponent, NBLabels labels) {
@@ -47,7 +45,7 @@ public class Cqld4DriverAdapter extends BaseDriverAdapter<Cqld4BaseOp, Cqld4Spac
}
@Override
public OpMapper<Cqld4BaseOp,Cqld4Space> getOpMapper() {
public OpMapper<Cqld4BaseOp<?>, Cqld4Space> getOpMapper() {
NBConfiguration config = getConfiguration();
return new Cqld4CoreOpMapper(this, config);
}

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4BaseOpDispenser.java
View File

@@ -43,7 +43,7 @@ import java.util.Map;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
public abstract class Cqld4BaseOpDispenser<T extends Cqld4BaseOp> extends BaseOpDispenser<T, Cqld4Space> implements CqlOpMetrics {
public abstract class Cqld4BaseOpDispenser<T extends Cqld4BaseOp<?>> extends BaseOpDispenser<T, Cqld4Space> implements CqlOpMetrics {
private final static Logger logger = LogManager.getLogger("CQLD4");

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4GremlinOpDispenser.java
View File

@@ -31,7 +31,7 @@ import io.nosqlbench.adapters.api.templating.ParsedOp;
import java.util.Optional;
import java.util.function.LongFunction;
public class Cqld4GremlinOpDispenser extends BaseOpDispenser<Cqld4BaseOp, Cqld4Space> {
public class Cqld4GremlinOpDispenser extends BaseOpDispenser<Cqld4BaseOp<?>, Cqld4Space> {
private final LongFunction<? extends ScriptGraphStatement> stmtFunc;
private final LongFunction<CqlSession> sessionFunc;

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

@@ -16,6 +16,7 @@
package io.nosqlbench.adapter.cqld4.opmappers;
import com.datastax.oss.driver.api.core.cql.Row;
import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
import io.nosqlbench.adapter.cqld4.Cqld4Space;
import io.nosqlbench.adapter.cqld4.opdispensers.CqlD4BatchStmtDispenser;
@@ -25,9 +26,10 @@ import io.nosqlbench.adapters.api.activityimpl.OpDispenser;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.nosqlbench.engine.api.templating.TypeAndTarget;
import java.util.List;
import java.util.function.LongFunction;
public class CqlD4BatchStmtMapper extends Cqld4CqlBaseOpMapper<Cqld4CqlBatchStatement> {
public class CqlD4BatchStmtMapper<RESULT extends List<? extends Row>> extends Cqld4CqlBaseOpMapper<Cqld4CqlBatchStatement> {
private final TypeAndTarget<CqlD4OpType, String> target;

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

@@ -20,21 +20,16 @@ import com.datastax.oss.driver.api.core.CqlSession;
import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
import io.nosqlbench.adapter.cqld4.Cqld4Space;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
import io.nosqlbench.adapters.api.activityimpl.OpDispenser;
import io.nosqlbench.adapters.api.activityimpl.OpMapper;
import io.nosqlbench.adapters.api.activityimpl.uniform.BaseSpace;
import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.nosqlbench.engine.api.templating.TypeAndTarget;
import io.nosqlbench.nb.api.config.standard.NBConfiguration;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.function.LongFunction;
public abstract class Cqld4BaseOpMapper<T extends Cqld4BaseOp> implements OpMapper<T,Cqld4Space> {
public abstract class Cqld4BaseOpMapper<T extends Cqld4BaseOp<?>> implements OpMapper<T,Cqld4Space> {
protected final static Logger logger = LogManager.getLogger(Cqld4BaseOpMapper.class);
protected final Cqld4DriverAdapter adapter;

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

@@ -19,8 +19,7 @@ package io.nosqlbench.adapter.cqld4.opmappers;
import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
import io.nosqlbench.adapter.cqld4.Cqld4Space;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import io.nosqlbench.nb.api.config.standard.NBConfiguration;
import io.nosqlbench.adapters.api.activityimpl.OpDispenser;
import io.nosqlbench.adapters.api.templating.ParsedOp;
@@ -31,12 +30,11 @@ import org.apache.logging.log4j.Logger;
import java.util.function.LongFunction;
public class Cqld4CoreOpMapper extends Cqld4BaseOpMapper<Cqld4BaseOp> {
public class Cqld4CoreOpMapper extends Cqld4BaseOpMapper<Cqld4BaseOp<?>> {
private final static Logger logger = LogManager.getLogger(Cqld4CoreOpMapper.class);
public Cqld4CoreOpMapper(Cqld4DriverAdapter adapter,
NBConfiguration config) {
public Cqld4CoreOpMapper(Cqld4DriverAdapter adapter, NBConfiguration config) {
super(adapter);
}
@@ -53,16 +51,17 @@ public class Cqld4CoreOpMapper extends Cqld4BaseOpMapper<Cqld4BaseOp> {
*/
@Override
public OpDispenser<Cqld4BaseOp> apply(ParsedOp op, LongFunction<Cqld4Space> cqld4SpaceLongFunction) {
public OpDispenser<Cqld4BaseOp<?>> apply(ParsedOp op, LongFunction<Cqld4Space> cqld4SpaceLongFunction) {
CqlD4OpType opType = CqlD4OpType.prepared;
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() + "'");
return (OpDispenser<Cqld4BaseOp>) switch (target.enumId) {
return (OpDispenser<Cqld4BaseOp<?>>) switch (target.enumId) {
case raw, simple, prepared, batch -> new Cqld4CqlOpMapper(adapter).apply(op, spaceFunc);
case gremlin -> new Cqld4GremlinOpMapper(adapter, target.targetFunction).apply(op, spaceFunc);
case fluent -> new Cqld4FluentGraphOpMapper(adapter, target).apply(op, spaceFunc);
case rainbow -> new CqlD4RainbowTableMapper(adapter, sessionFunc, target.targetFunction).apply(op, spaceFunc);
case rainbow ->
new CqlD4RainbowTableMapper(adapter, sessionFunc, target.targetFunction).apply(op, spaceFunc);
default -> throw new OpConfigError("Unsupported op type " + opType);
// 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

@@ -22,6 +22,7 @@ import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
import io.nosqlbench.adapter.cqld4.Cqld4Space;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
import io.nosqlbench.adapters.api.activityimpl.OpDispenser;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import java.util.function.LongFunction;
@@ -34,4 +35,5 @@ public abstract class Cqld4CqlBaseOpMapper<T extends Cqld4CqlOp> extends Cqld4Ba
@Override
public abstract OpDispenser<T> apply(ParsedOp op, LongFunction<Cqld4Space> spaceInitF);
}

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

@@ -17,21 +17,14 @@
package io.nosqlbench.adapter.cqld4.opmappers;
import com.datastax.dse.driver.api.core.graph.DseGraph;
import com.datastax.oss.driver.api.core.CqlSession;
import groovy.lang.Binding;
import groovy.lang.GroovyShell;
import groovy.lang.Script;
import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
import io.nosqlbench.adapter.cqld4.Cqld4Space;
import io.nosqlbench.adapter.cqld4.opdispensers.Cqld4FluentGraphOpDispenser;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
import io.nosqlbench.adapter.cqld4.optypes.Cqld4FluentGraphOp;
import io.nosqlbench.adapters.api.activityimpl.OpDispenser;
import io.nosqlbench.adapters.api.activityimpl.OpMapper;
import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
import io.nosqlbench.adapters.api.activityimpl.uniform.Space;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.nosqlbench.engine.api.templating.TypeAndTarget;
import io.nosqlbench.nb.api.errors.OpConfigError;

5
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4BaseOp.java
View File

@@ -18,7 +18,8 @@ package io.nosqlbench.adapter.cqld4.optypes;
*/
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import com.datastax.oss.driver.api.core.cql.ResultSet;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
public interface Cqld4BaseOp extends Op {
public interface Cqld4BaseOp<T> extends CycleOp<T> {
}

4
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4CqlBatchStatement.java
View File

@@ -18,9 +18,13 @@ package io.nosqlbench.adapter.cqld4.optypes;
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.BatchStatement;
import com.datastax.oss.driver.api.core.cql.Row;
import io.nosqlbench.adapter.cqld4.RSProcessors;
import io.nosqlbench.adapter.cqld4.instruments.CqlOpMetrics;
import java.util.ArrayList;
import java.util.List;
public class Cqld4CqlBatchStatement extends Cqld4CqlOp {
private final BatchStatement stmt;

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

@@ -17,10 +17,7 @@
package io.nosqlbench.adapter.cqld4.optypes;
import com.datastax.oss.driver.api.core.CqlSession;
import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
import com.datastax.oss.driver.api.core.cql.BoundStatement;
import com.datastax.oss.driver.api.core.cql.Row;
import com.datastax.oss.driver.api.core.cql.Statement;
import com.datastax.oss.driver.api.core.cql.*;
import io.nosqlbench.adapter.cqld4.Cqld4CqlReboundStatement;
import io.nosqlbench.adapter.cqld4.LWTRebinder;
import io.nosqlbench.adapter.cqld4.RSProcessors;
@@ -50,7 +47,7 @@ import java.util.concurrent.*;
public abstract class Cqld4CqlOp
implements Cqld4BaseOp, CycleOp<List<Row>>, VariableCapture, OpGenerator, OpResultSize {
implements Cqld4BaseOp<List<Row>>, VariableCapture, OpGenerator, OpResultSize {
private final static Logger logger = LogManager.getLogger(Cqld4CqlOp.class);
@@ -101,7 +98,8 @@ public abstract class Cqld4CqlOp
this.metrics = metrics;
}
public final ArrayList<Row> apply(long cycle) {
@Override
public List<Row> apply(long cycle) {
Statement<?> statement = getStmt();
logger.trace(() -> "apply() invoked, statement obtained, executing async with page size: " + statement.getPageSize() + " thread local rows: ");
@@ -136,15 +134,16 @@ public abstract class Cqld4CqlOp
metrics.recordFetchedRows(fetchedRows);
metrics.recordFetchedBytes(fetchedBytes);
}
}
// logger.trace(() -> "\n\n--- Rows collected for cycle: " + cycle + " count: "
// + rs.size() + " dt: " + System.nanoTime());
//
// results.set(completeRowSet);
// processors.flush();
}
private static class PrintableRowList extends ArrayList<Row> {
public static class PrintableRowList extends ArrayList<Row> {
public PrintableRowList(List<Row> values) {
super(values);
}
@@ -159,10 +158,9 @@ public abstract class Cqld4CqlOp
}
}
// private BiFunction<AsyncResultSet,Throwable> handler
@Override
public Op getNextOp() {
Op next = nextOp;
public CycleOp<?> getNextOp() {
CycleOp<?> next = nextOp;
nextOp = null;
return next;
}
@@ -181,7 +179,7 @@ public abstract class Cqld4CqlOp
}
private CompletionStage<List<Row>> collect(AsyncResultSet resultSet, ArrayList<Row> rowList, final long cycle) {
fetchedBytes+=resultSet.getExecutionInfo().getResponseSizeInBytes();
fetchedBytes += resultSet.getExecutionInfo().getResponseSizeInBytes();
if (++fetchedPages > maxPages) {
throw new UnexpectedPagingException(resultSet, getQueryString(), fetchedPages, maxPages, getStmt().getPageSize());
}

40
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4CqlOpImpl.java Normal file
View File

@@ -0,0 +1,40 @@
package io.nosqlbench.adapter.cqld4.optypes;
/*
* 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.CqlSession;
import com.datastax.oss.driver.api.core.cql.Statement;
import io.nosqlbench.adapter.cqld4.RSProcessors;
import io.nosqlbench.adapter.cqld4.instruments.CqlOpMetrics;
public class Cqld4CqlOpImpl extends Cqld4CqlOp {
public Cqld4CqlOpImpl(CqlSession session, int maxPages, boolean retryReplace, int maxLwtRetries, RSProcessors processors, CqlOpMetrics metrics) {
super(session, maxPages, retryReplace, maxLwtRetries, processors, metrics);
}
@Override
public Statement<?> getStmt() {
return null;
}
@Override
public String getQueryString() {
return "";
}
}

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4FluentGraphOp.java
View File

@@ -22,7 +22,7 @@ import com.datastax.oss.driver.api.core.CqlSession;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.OpResultSize;
public class Cqld4FluentGraphOp implements Cqld4BaseOp, CycleOp<GraphResultSet>, OpResultSize {
public class Cqld4FluentGraphOp implements Cqld4BaseOp<GraphResultSet>, OpResultSize {
private final CqlSession session;
private final FluentGraphStatement stmt;
private int resultSize=0;

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

@@ -23,7 +23,7 @@ import java.util.Map;
// Need to create RainbowTableStatement
public class Cqld4RainbowTableOp
implements Cqld4BaseOp, CycleOp<ResultSet>, VariableCapture, OpGenerator, OpResultSize {
implements Cqld4BaseOp<ResultSet>, VariableCapture, OpGenerator, OpResultSize {
// private final CqlSession session;
// private final RainbowTableStatement stmt;
@@ -35,7 +35,7 @@ public class Cqld4RainbowTableOp
}
@Override
public Op getNextOp() {
public CycleOp getNextOp() {
throw new RuntimeException("implement me");
}

2
nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4ScriptGraphOp.java
View File

@@ -22,7 +22,7 @@ import com.datastax.oss.driver.api.core.CqlSession;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.OpResultSize;
public class Cqld4ScriptGraphOp implements Cqld4BaseOp, CycleOp<GraphResultSet>, OpResultSize {
public class Cqld4ScriptGraphOp implements Cqld4BaseOp<GraphResultSet>, OpResultSize {
private final CqlSession session;
private final ScriptGraphStatement stmt;
private int resultSize=0;

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

@@ -21,7 +21,7 @@ import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public abstract class DataApiBaseOp implements CycleOp {
public abstract class DataApiBaseOp implements CycleOp<Object> {
protected static final Logger logger = LogManager.getLogger(DataApiBaseOp.class);
protected final Database db;

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

@@ -32,14 +32,14 @@ import java.util.function.LongFunction;
import static io.nosqlbench.adapter.gcpspanner.GCPSpannerAdapterUtils.SPANNER;
@Service(value = DriverAdapter.class, selector = SPANNER)
public class GCPSpannerDriverAdapter extends BaseDriverAdapter<GCPSpannerBaseOp, GCPSpannerSpace> {
public class GCPSpannerDriverAdapter extends BaseDriverAdapter<GCPSpannerBaseOp<?,?>, GCPSpannerSpace> {
public GCPSpannerDriverAdapter(NBComponent parentComponent, NBLabels labels) {
super(parentComponent, labels);
}
@Override
public OpMapper<GCPSpannerBaseOp,GCPSpannerSpace> getOpMapper() {
public OpMapper<GCPSpannerBaseOp<?,?>,GCPSpannerSpace> getOpMapper() {
return new GCPSpannerOpMapper(this);
}

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

@@ -30,7 +30,7 @@ import org.apache.logging.log4j.Logger;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
public class GCPSpannerOpMapper implements OpMapper<GCPSpannerBaseOp, GCPSpannerSpace> {
public class GCPSpannerOpMapper implements OpMapper<GCPSpannerBaseOp<?,?>, GCPSpannerSpace> {
private static final Logger logger = LogManager.getLogger(GCPSpannerOpMapper.class);
private final GCPSpannerDriverAdapter adapter;
@@ -56,12 +56,12 @@ public class GCPSpannerOpMapper implements OpMapper<GCPSpannerBaseOp, GCPSpanner
* the op type
*/
@Override
public OpDispenser<GCPSpannerBaseOp> apply(ParsedOp op, LongFunction<GCPSpannerSpace> spaceInitF) {
public OpDispenser<GCPSpannerBaseOp<?,?>> apply(ParsedOp op, LongFunction<GCPSpannerSpace> spaceInitF) {
TypeAndTarget<GCPSpannerOpType, String> typeAndTarget = op.getTypeAndTarget(GCPSpannerOpType.class,
String.class, "type", "target");
logger.info(() -> "Using '" + typeAndTarget.enumId + "' op type for op template '" + op.getName() + "'");
return switch (typeAndTarget.enumId) {
OpDispenser<GCPSpannerBaseOp<?, ?>> dispenser = switch (typeAndTarget.enumId) {
case drop_database_ddl ->
new GCPSpannerDropDatabaseDdlOpDispenser(adapter, op, typeAndTarget.targetFunction);
case create_database_ddl ->
@@ -71,5 +71,6 @@ public class GCPSpannerOpMapper implements OpMapper<GCPSpannerBaseOp, GCPSpanner
case insert -> new GCPSpannerInsertOpDispenser(adapter, op, typeAndTarget.targetFunction);
case execute_dml -> new GCPSpannerExecuteDmlOpDispenser(adapter, op, typeAndTarget.targetFunction);
};
return dispenser;
}
}

2
nb-adapters/adapter-gcp-spanner/src/main/java/io/nosqlbench/adapter/gcpspanner/opdispensers/GCPSpannerBaseOpDispenser.java
View File

@@ -32,7 +32,7 @@ import java.util.function.LongFunction;
* for creating GCP Spanner operations.
*/
public abstract class GCPSpannerBaseOpDispenser<OP extends GCPSpannerBaseOp,RESULT>
extends BaseOpDispenser<GCPSpannerBaseOp, GCPSpannerSpace> {
extends BaseOpDispenser<GCPSpannerBaseOp<?,?>, GCPSpannerSpace> {
/**
* A function that provides the target string based on a long input.
*/

1
nb-adapters/adapter-gcp-spanner/src/main/java/io/nosqlbench/adapter/gcpspanner/ops/GCPSpannerBaseOp.java
View File

@@ -18,7 +18,6 @@ package io.nosqlbench.adapter.gcpspanner.ops;
import com.google.cloud.spanner.Spanner;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

2
nb-adapters/adapter-http/src/main/java/io/nosqlbench/adapter/http/core/HttpOp.java
View File

@@ -27,7 +27,7 @@ import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
public class HttpOp implements CycleOp {
public class HttpOp implements CycleOp<Object> {
public final Pattern ok_status;
public final Pattern ok_body;

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

@@ -18,20 +18,17 @@ package io.nosqlbench.adapter.mongodb.core;
import io.nosqlbench.adapter.mongodb.dispensers.MongoCommandOpDispenser;
import io.nosqlbench.adapter.mongodb.ops.MongoDirectCommandOp;
import io.nosqlbench.adapters.api.activityimpl.uniform.Space;
import io.nosqlbench.adapters.api.activityimpl.uniform.ConcurrentSpaceCache;
import io.nosqlbench.nb.api.config.standard.NBConfiguration;
import io.nosqlbench.nb.api.errors.BasicError;
import io.nosqlbench.adapters.api.activityimpl.OpDispenser;
import io.nosqlbench.adapters.api.activityimpl.OpMapper;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.nosqlbench.engine.api.templating.TypeAndTarget;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.Optional;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
public class MongoOpMapper<MC extends MongoDirectCommandOp> implements OpMapper<MongoDirectCommandOp,MongoSpace> {

7
nb-adapters/adapter-mongodb/src/main/java/io/nosqlbench/adapter/mongodb/core/MongodbDriverAdapter.java
View File

@@ -17,31 +17,30 @@
package io.nosqlbench.adapter.mongodb.core;
import io.nosqlbench.adapter.mongodb.ops.MongoDirectCommandOp;
import io.nosqlbench.adapter.mongodb.ops.MongoOp;
import io.nosqlbench.nb.api.config.standard.NBConfigModel;
import io.nosqlbench.nb.api.config.standard.NBConfiguration;
import io.nosqlbench.adapters.api.activityimpl.OpMapper;
import io.nosqlbench.adapters.api.activityimpl.uniform.BaseDriverAdapter;
import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import io.nosqlbench.nb.api.labels.NBLabels;
import io.nosqlbench.nb.api.components.core.NBComponent;
import io.nosqlbench.nb.annotations.Service;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
/**
* Special thanks to Justin Chu who authored the original NoSQLBench MongoDB ActivityType.
*/
@Service(value = DriverAdapter.class, selector = "mongodb")
public class MongodbDriverAdapter extends BaseDriverAdapter<MongoDirectCommandOp, MongoSpace> {
public class MongodbDriverAdapter extends BaseDriverAdapter<MongoOp<?>, MongoSpace> {
public MongodbDriverAdapter(NBComponent parentComponent, NBLabels labels) {
super(parentComponent, labels);
}
@Override
public OpMapper<MongoDirectCommandOp,MongoSpace> getOpMapper() {
public OpMapper<MongoOp<?>,MongoSpace> getOpMapper() {
return new MongoOpMapper(this, getConfiguration(), getSpaceCache());
}

3
nb-adapters/adapter-mongodb/src/main/java/io/nosqlbench/adapter/mongodb/dispensers/MongoCommandOpDispenser.java
View File

@@ -20,14 +20,11 @@ import io.nosqlbench.adapter.mongodb.core.MongoSpace;
import io.nosqlbench.adapter.mongodb.ops.MongoDirectCommandOp;
import io.nosqlbench.adapters.api.activityimpl.BaseOpDispenser;
import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
import io.nosqlbench.adapters.api.activityimpl.uniform.Space;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import org.bson.Document;
import org.bson.conversions.Bson;
import java.util.Map;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
public class MongoCommandOpDispenser extends BaseOpDispenser<MongoDirectCommandOp, MongoSpace> {

20
nb-adapters/adapter-mongodb/src/main/java/io/nosqlbench/adapter/mongodb/dispensers/MongoDbUpdateOpDispenser.java
View File

@@ -20,9 +20,14 @@ import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoDatabase;
import io.nosqlbench.adapter.mongodb.core.MongoSpace;
import io.nosqlbench.adapter.mongodb.core.MongodbDriverAdapter;
import io.nosqlbench.adapter.mongodb.ops.MongoDbUpdateOp;
import io.nosqlbench.adapter.mongodb.ops.MongoDirectCommandOp;
import io.nosqlbench.adapter.mongodb.ops.MongoOp;
import io.nosqlbench.adapters.api.activityimpl.BaseOpDispenser;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import org.bson.BsonDocument;
import org.bson.conversions.Bson;
import java.util.function.LongFunction;
@@ -30,9 +35,9 @@ import java.util.function.LongFunction;
* https://www.mongodb.com/docs/manual/reference/command/update/#mongodb-dbcommand-dbcmd.update
* https://www.mongodb.com/docs/drivers/java/sync/current/usage-examples/updateOne/
*/
public class MongoDbUpdateOpDispenser extends BaseOpDispenser<Op, MongoSpace> {
public class MongoDbUpdateOpDispenser extends BaseOpDispenser<MongoOp<?>, MongoSpace> {
private final LongFunction<MongoSpace> spaceF;
private final LongFunction<Op> opF;
private final LongFunction<MongoOp<?>> opF;
private final LongFunction<String> collectionF;
public MongoDbUpdateOpDispenser(MongodbDriverAdapter adapter, ParsedOp pop, LongFunction<String> collectionF) {
@@ -42,15 +47,16 @@ public class MongoDbUpdateOpDispenser extends BaseOpDispenser<Op, MongoSpace> {
this.opF = createOpF(pop);
}
private LongFunction<Op> createOpF(ParsedOp pop) {
private LongFunction<MongoOp<?>> createOpF(ParsedOp pop) {
LongFunction<MongoClient> clientF = cycle -> spaceF.apply(cycle).getClient();
LongFunction<MongoDatabase> docF = l -> clientF.apply(l).getDatabase(collectionF.apply(l));
return l -> new Op() {};
// TODO This needs to be completed for at least one working example of a specialized op form.
return l -> new MongoDirectCommandOp(clientF.apply(l),docF.apply(l).getName(),new BsonDocument());
}
@Override
public Op getOp(long value) {
Op op = opF.apply(value);
public MongoOp<?> getOp(long value) {
MongoOp<?> op = opF.apply(value);
return op;
}

30
nb-adapters/adapter-mongodb/src/main/java/io/nosqlbench/adapter/mongodb/ops/MongoDbUpdateOp.java Normal file
View File

@@ -0,0 +1,30 @@
package io.nosqlbench.adapter.mongodb.ops;
/*
* 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 io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import org.bson.Document;
public class MongoDbUpdateOp implements CycleOp<Document> {
@Override
public Document apply(long value) {
return null;
}
}

2
nb-adapters/adapter-mongodb/src/main/java/io/nosqlbench/adapter/mongodb/ops/MongoDirectCommandOp.java
View File

@@ -21,7 +21,7 @@ import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
import org.bson.Document;
import org.bson.conversions.Bson;
public class MongoDirectCommandOp implements CycleOp<Document> {
public class MongoDirectCommandOp implements MongoOp<Document> {
private final MongoClient client;
private final Bson rqBson;

24
nb-adapters/adapter-mongodb/src/main/java/io/nosqlbench/adapter/mongodb/ops/MongoOp.java Normal file
View File

@@ -0,0 +1,24 @@
package io.nosqlbench.adapter.mongodb.ops;
/*
* 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 io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.CycleOp;
public interface MongoOp<T> extends CycleOp<T> {
}

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

@@ -33,14 +33,14 @@ import java.util.function.LongFunction;
import static io.nosqlbench.adapter.qdrant.QdrantAdapterUtils.QDRANT;
@Service(value = DriverAdapter.class, selector = QDRANT)
public class QdrantDriverAdapter extends BaseDriverAdapter<QdrantBaseOp, QdrantSpace> {
public class QdrantDriverAdapter extends BaseDriverAdapter<QdrantBaseOp<?,?>, QdrantSpace> {
public QdrantDriverAdapter(NBComponent parentComponent, NBLabels labels) {
super(parentComponent, labels);
}
@Override
public OpMapper<QdrantBaseOp,QdrantSpace> getOpMapper() {
public OpMapper<QdrantBaseOp<?,?>,QdrantSpace> getOpMapper() {
return new QdrantOpMapper(this);
}

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

@@ -30,7 +30,7 @@ import org.apache.logging.log4j.Logger;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
public class QdrantOpMapper implements OpMapper<QdrantBaseOp,QdrantSpace> {
public class QdrantOpMapper implements OpMapper<QdrantBaseOp<?,?>,QdrantSpace> {
private static final Logger logger = LogManager.getLogger(QdrantOpMapper.class);
private final QdrantDriverAdapter adapter;
@@ -52,7 +52,7 @@ public class QdrantOpMapper implements OpMapper<QdrantBaseOp,QdrantSpace> {
* @return The correct {@link QdrantBaseOpDispenser} subclass based on the op type
*/
@Override
public OpDispenser<QdrantBaseOp> apply(ParsedOp op, LongFunction<QdrantSpace> spaceInitF) {
public OpDispenser<QdrantBaseOp<?,?>> apply(ParsedOp op, LongFunction<QdrantSpace> spaceInitF) {
TypeAndTarget<QdrantOpType, String> typeAndTarget = op.getTypeAndTarget(
QdrantOpType.class,
String.class,
@@ -61,7 +61,7 @@ public class QdrantOpMapper implements OpMapper<QdrantBaseOp,QdrantSpace> {
);
logger.info(() -> "Using '" + typeAndTarget.enumId + "' op type for op template '" + op.getName() + "'");
return switch (typeAndTarget.enumId) {
OpDispenser<QdrantBaseOp<?,?>> dispenser = switch (typeAndTarget.enumId) {
case delete_collection -> new QdrantDeleteCollectionOpDispenser(adapter, op, typeAndTarget.targetFunction);
case create_collection -> new QdrantCreateCollectionOpDispenser(adapter, op, typeAndTarget.targetFunction);
case create_payload_index ->
@@ -78,6 +78,7 @@ public class QdrantOpMapper implements OpMapper<QdrantBaseOp,QdrantSpace> {
// default -> throw new RuntimeException("Unrecognized op type '" + typeAndTarget.enumId.name() + "' while " +
// "mapping parsed op " + op);
};
return dispenser;
}
}

17
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/opdispensers/QdrantBaseOpDispenser.java
View File

@@ -41,12 +41,13 @@ import java.util.function.LongFunction;
import static io.qdrant.client.ConditionFactory.*;
public abstract class QdrantBaseOpDispenser<T> extends BaseOpDispenser<QdrantBaseOp, QdrantSpace> {
public abstract class QdrantBaseOpDispenser<REQUEST,RESULT>
extends BaseOpDispenser<QdrantBaseOp<?,?>, QdrantSpace> {
protected final LongFunction<QdrantSpace> qdrantSpaceFunction;
protected final LongFunction<QdrantClient> clientFunction;
private final LongFunction<? extends QdrantBaseOp<T>> opF;
private final LongFunction<T> paramF;
private final LongFunction<? extends QdrantBaseOp<REQUEST, RESULT>> opF;
private final LongFunction<REQUEST> paramF;
protected QdrantBaseOpDispenser(QdrantDriverAdapter adapter, ParsedOp op, LongFunction<String> targetF) {
super((DriverAdapter)adapter, op);
@@ -59,21 +60,21 @@ public abstract class QdrantBaseOpDispenser<T> extends BaseOpDispenser<QdrantBas
return (QdrantDriverAdapter) adapter;
}
public abstract LongFunction<T> getParamFunc(
public abstract LongFunction<REQUEST> getParamFunc(
LongFunction<QdrantClient> clientF,
ParsedOp op,
LongFunction<String> targetF
);
public abstract LongFunction<QdrantBaseOp<T>> createOpFunc(
LongFunction<T> paramF,
public abstract LongFunction<QdrantBaseOp<REQUEST, RESULT>> createOpFunc(
LongFunction<REQUEST> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op,
LongFunction<String> targetF
);
@Override
public QdrantBaseOp<T> getOp(long value) {
public QdrantBaseOp<REQUEST, RESULT> getOp(long value) {
return opF.apply(value);
}
@@ -477,7 +478,7 @@ public abstract class QdrantBaseOpDispenser<T> extends BaseOpDispenser<QdrantBas
}
/**
* This {@link nested} is only valid within a 'must' filter condition.
* This {@link io.qdrant.client.grpc.Points.NestedCondition} is only valid within a 'must' filter condition.
*
* @param filterFields
* @return

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

@@ -25,7 +25,7 @@ import io.qdrant.client.grpc.Collections.CollectionExistsRequest;
import java.util.function.LongFunction;
public class QdrantCollectionExistsOpDispenser extends QdrantBaseOpDispenser<CollectionExistsRequest> {
public class QdrantCollectionExistsOpDispenser extends QdrantBaseOpDispenser<CollectionExistsRequest,Boolean> {
public QdrantCollectionExistsOpDispenser(QdrantDriverAdapter adapter, ParsedOp op, LongFunction<String> targetFunction) {
super(adapter, op, targetFunction);
}
@@ -41,7 +41,7 @@ public class QdrantCollectionExistsOpDispenser extends QdrantBaseOpDispenser<Col
}
@Override
public LongFunction<QdrantBaseOp<CollectionExistsRequest>> createOpFunc(
public LongFunction<QdrantBaseOp<CollectionExistsRequest,Boolean>> createOpFunc(
LongFunction<CollectionExistsRequest> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op,

5
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/opdispensers/QdrantCollectionInfoOpDispenser.java
View File

@@ -21,10 +21,11 @@ import io.nosqlbench.adapter.qdrant.ops.QdrantBaseOp;
import io.nosqlbench.adapter.qdrant.ops.QdrantCollectionInfoOp;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.grpc.Collections;
import java.util.function.LongFunction;
public class QdrantCollectionInfoOpDispenser extends QdrantBaseOpDispenser<String> {
public class QdrantCollectionInfoOpDispenser extends QdrantBaseOpDispenser<String, Collections.CollectionInfo> {
public QdrantCollectionInfoOpDispenser(QdrantDriverAdapter adapter, ParsedOp op, LongFunction<String> targetFunction) {
super(adapter, op, targetFunction);
}
@@ -36,7 +37,7 @@ public class QdrantCollectionInfoOpDispenser extends QdrantBaseOpDispenser<Strin
}
@Override
public LongFunction<QdrantBaseOp<String>> createOpFunc(
public LongFunction<QdrantBaseOp<String, Collections.CollectionInfo>> createOpFunc(
LongFunction<String> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op,

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

@@ -26,7 +26,7 @@ import io.qdrant.client.grpc.Points.Filter;
import java.util.function.LongFunction;
public class QdrantCountPointsOpDispenser extends QdrantBaseOpDispenser<CountPoints> {
public class QdrantCountPointsOpDispenser extends QdrantBaseOpDispenser<CountPoints,Long> {
public QdrantCountPointsOpDispenser(QdrantDriverAdapter adapter, ParsedOp op, LongFunction<String> targetFunction) {
super(adapter, op, targetFunction);
}
@@ -50,7 +50,7 @@ public class QdrantCountPointsOpDispenser extends QdrantBaseOpDispenser<CountPoi
}
@Override
public LongFunction<QdrantBaseOp<CountPoints>> createOpFunc(
public LongFunction<QdrantBaseOp<CountPoints,Long>> createOpFunc(
LongFunction<CountPoints> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op,

5
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/opdispensers/QdrantCreateCollectionOpDispenser.java
View File

@@ -21,6 +21,7 @@ import java.util.Map;
import java.util.Optional;
import java.util.function.LongFunction;
import io.qdrant.client.grpc.Collections;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@@ -48,7 +49,7 @@ import io.qdrant.client.grpc.Collections.VectorParamsMap;
import io.qdrant.client.grpc.Collections.VectorsConfig;
import io.qdrant.client.grpc.Collections.WalConfigDiff;
public class QdrantCreateCollectionOpDispenser extends QdrantBaseOpDispenser<CreateCollection> {
public class QdrantCreateCollectionOpDispenser extends QdrantBaseOpDispenser<CreateCollection, Collections.CollectionOperationResponse> {
private static final Logger logger = LogManager.getLogger(QdrantCreateCollectionOpDispenser.class);
/**
@@ -364,7 +365,7 @@ public class QdrantCreateCollectionOpDispenser extends QdrantBaseOpDispenser<Cre
// https://qdrant.tech/documentation/concepts/collections/#create-a-collection
@Override
public LongFunction<QdrantBaseOp<CreateCollection>> createOpFunc(
public LongFunction<QdrantBaseOp<CreateCollection, Collections.CollectionOperationResponse>> createOpFunc(
LongFunction<CreateCollection> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op,

5
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/opdispensers/QdrantCreatePayloadIndexOpDispenser.java
View File

@@ -21,6 +21,7 @@ import io.nosqlbench.adapter.qdrant.ops.QdrantBaseOp;
import io.nosqlbench.adapter.qdrant.ops.QdrantCreatePayloadIndexOp;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.grpc.Points;
import io.qdrant.client.grpc.Points.CreateFieldIndexCollection;
import io.qdrant.client.grpc.Points.FieldType;
import io.qdrant.client.grpc.Points.WriteOrdering;
@@ -29,7 +30,7 @@ import io.qdrant.client.grpc.Points.WriteOrderingType;
import java.util.Optional;
import java.util.function.LongFunction;
public class QdrantCreatePayloadIndexOpDispenser extends QdrantBaseOpDispenser<CreateFieldIndexCollection> {
public class QdrantCreatePayloadIndexOpDispenser extends QdrantBaseOpDispenser<CreateFieldIndexCollection, Points.UpdateResult> {
public QdrantCreatePayloadIndexOpDispenser(
QdrantDriverAdapter adapter,
ParsedOp op,
@@ -65,7 +66,7 @@ public class QdrantCreatePayloadIndexOpDispenser extends QdrantBaseOpDispenser<C
}
@Override
public LongFunction<QdrantBaseOp<CreateFieldIndexCollection>> createOpFunc(
public LongFunction<QdrantBaseOp<CreateFieldIndexCollection, Points.UpdateResult>> createOpFunc(
LongFunction<CreateFieldIndexCollection> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op,

17
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/opdispensers/QdrantDeleteCollectionOpDispenser.java
View File

@@ -21,11 +21,14 @@ import io.nosqlbench.adapter.qdrant.ops.QdrantBaseOp;
import io.nosqlbench.adapter.qdrant.ops.QdrantDeleteCollectionOp;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.grpc.Collections;
import io.qdrant.client.grpc.Collections.DeleteCollection;
import java.util.List;
import java.util.function.LongFunction;
public class QdrantDeleteCollectionOpDispenser extends QdrantBaseOpDispenser<DeleteCollection> {
public class QdrantDeleteCollectionOpDispenser
extends QdrantBaseOpDispenser<DeleteCollection, Collections.CollectionOperationResponse> {
/**
* Create a new {@link QdrantDeleteCollectionOpDispenser} subclassed from {@link QdrantBaseOpDispenser}.
@@ -42,21 +45,15 @@ public class QdrantDeleteCollectionOpDispenser extends QdrantBaseOpDispenser<Del
}
@Override
public LongFunction<DeleteCollection> getParamFunc(
LongFunction<QdrantClient> clientF,
ParsedOp op,
LongFunction<String> targetF) {
public LongFunction<DeleteCollection> getParamFunc(LongFunction<QdrantClient> clientF, ParsedOp op, LongFunction<String> targetF) {
LongFunction<DeleteCollection.Builder> ebF =
l -> DeleteCollection.newBuilder().setCollectionName(targetF.apply(l));
return l -> ebF.apply(l).build();
}
@Override
public LongFunction<QdrantBaseOp<DeleteCollection>> createOpFunc(
LongFunction<DeleteCollection> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op,
LongFunction<String> targetF) {
public LongFunction<QdrantBaseOp<DeleteCollection, Collections.CollectionOperationResponse>> createOpFunc(LongFunction<DeleteCollection> paramF, LongFunction<QdrantClient> clientF, ParsedOp op, LongFunction<String> targetF) {
return l -> new QdrantDeleteCollectionOp(clientF.apply(l), paramF.apply(l));
}
}

5
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/opdispensers/QdrantListCollectionAliasesOpDispenser.java
View File

@@ -23,9 +23,10 @@ import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.grpc.Collections.ListCollectionAliasesRequest;
import java.util.List;
import java.util.function.LongFunction;
public class QdrantListCollectionAliasesOpDispenser extends QdrantBaseOpDispenser<ListCollectionAliasesRequest> {
public class QdrantListCollectionAliasesOpDispenser extends QdrantBaseOpDispenser<ListCollectionAliasesRequest, List<String>> {
public QdrantListCollectionAliasesOpDispenser(QdrantDriverAdapter adapter, ParsedOp op,
LongFunction<String> targetFunction) {
super(adapter, op, targetFunction);
@@ -42,7 +43,7 @@ public class QdrantListCollectionAliasesOpDispenser extends QdrantBaseOpDispense
}
@Override
public LongFunction<QdrantBaseOp<ListCollectionAliasesRequest>> createOpFunc(
public LongFunction<QdrantBaseOp<ListCollectionAliasesRequest,List<String>>> createOpFunc(
LongFunction<ListCollectionAliasesRequest> paramF,
LongFunction<QdrantClient> clientF, ParsedOp op, LongFunction<String> targetF) {
return l -> new QdrantListCollectionAliasesOp(clientF.apply(l), paramF.apply(l));

19
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/opdispensers/QdrantListCollectionsOpDispenser.java
View File

@@ -22,24 +22,29 @@ import io.nosqlbench.adapter.qdrant.ops.QdrantListCollectionsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.qdrant.client.QdrantClient;
import java.util.List;
import java.util.function.LongFunction;
public class QdrantListCollectionsOpDispenser extends QdrantBaseOpDispenser<Object> {
public class QdrantListCollectionsOpDispenser extends QdrantBaseOpDispenser<Void,List<String>> {
public QdrantListCollectionsOpDispenser(QdrantDriverAdapter adapter,
ParsedOp op, LongFunction<String> targetFunction) {
super(adapter, op, targetFunction);
}
@Override
public LongFunction<Object> getParamFunc(LongFunction<QdrantClient> clientF, ParsedOp op, LongFunction<String> targetF) {
return l -> "";
public LongFunction<Void> getParamFunc(LongFunction<QdrantClient> clientF, ParsedOp op,
LongFunction<String> targetF) {
return null;
}
@Override
public LongFunction<QdrantBaseOp<Object>> createOpFunc(
LongFunction<Object> paramF,
public LongFunction<QdrantBaseOp<Void, List<String>>> createOpFunc(
LongFunction<Void> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op, LongFunction<String> targetF) {
return l -> new QdrantListCollectionsOp(clientF.apply(l), null);
ParsedOp op,
LongFunction<String> targetF
) {
return l -> new QdrantListCollectionsOp(clientF.apply(l), null);
}
}

12
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/opdispensers/QdrantListSnapshotsOpDispenser.java
View File

@@ -21,11 +21,13 @@ import io.nosqlbench.adapter.qdrant.ops.QdrantBaseOp;
import io.nosqlbench.adapter.qdrant.ops.QdrantListSnapshotsOp;
import io.nosqlbench.adapters.api.templating.ParsedOp;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.grpc.SnapshotsService;
import io.qdrant.client.grpc.SnapshotsService.ListSnapshotsRequest;
import java.util.List;
import java.util.function.LongFunction;
public class QdrantListSnapshotsOpDispenser extends QdrantBaseOpDispenser<ListSnapshotsRequest> {
public class QdrantListSnapshotsOpDispenser extends QdrantBaseOpDispenser<ListSnapshotsRequest, List<SnapshotsService.SnapshotDescription>> {
public QdrantListSnapshotsOpDispenser(QdrantDriverAdapter adapter, ParsedOp op, LongFunction<String> targetFunction) {
super(adapter, op, targetFunction);
}
@@ -41,9 +43,11 @@ public class QdrantListSnapshotsOpDispenser extends QdrantBaseOpDispenser<ListSn
}
@Override
public LongFunction<QdrantBaseOp<ListSnapshotsRequest>> createOpFunc(LongFunction<ListSnapshotsRequest> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op, LongFunction<String> targetF) {
public LongFunction<QdrantBaseOp<ListSnapshotsRequest, List<SnapshotsService.SnapshotDescription>>> createOpFunc(
LongFunction<ListSnapshotsRequest> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op, LongFunction<String> targetF
) {
return l -> new QdrantListSnapshotsOp(clientF.apply(l), paramF.apply(l));
}
}

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

@@ -33,13 +33,13 @@ import java.util.Map;
import java.util.Optional;
import java.util.function.LongFunction;
public class QdrantSearchPointsOpDispenser extends QdrantBaseOpDispenser<SearchPoints> {
public class QdrantSearchPointsOpDispenser extends QdrantBaseOpDispenser<SearchPoints,List<ScoredPoint>> {
public QdrantSearchPointsOpDispenser(QdrantDriverAdapter adapter, ParsedOp op, LongFunction<String> targetFunction) {
super(adapter, op, targetFunction);
}
@Override
public LongFunction<QdrantBaseOp<SearchPoints>> createOpFunc(
public LongFunction<QdrantBaseOp<SearchPoints,List<ScoredPoint>>> createOpFunc(
LongFunction<SearchPoints> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op, LongFunction<String> targetF) {

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

@@ -36,7 +36,7 @@ import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.LongFunction;
public class QdrantUpsertPointsOpDispenser extends QdrantBaseOpDispenser<UpsertPoints> {
public class QdrantUpsertPointsOpDispenser extends QdrantBaseOpDispenser<UpsertPoints,UpdateResult> {
private static final Logger logger = LogManager.getLogger(QdrantUpsertPointsOpDispenser.class);
/**
@@ -181,7 +181,7 @@ public class QdrantUpsertPointsOpDispenser extends QdrantBaseOpDispenser<UpsertP
* @see <a href="https://qdrant.tech/documentation/concepts/points/">Upsert Points</a>
*/
@Override
public LongFunction<QdrantBaseOp<UpsertPoints>> createOpFunc(
public LongFunction<QdrantBaseOp<UpsertPoints,UpdateResult>> createOpFunc(
LongFunction<UpsertPoints> paramF,
LongFunction<QdrantClient> clientF,
ParsedOp op,

14
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/ops/QdrantBaseOp.java
View File

@@ -23,32 +23,32 @@ import org.apache.logging.log4j.Logger;
import java.util.function.LongFunction;
public abstract class QdrantBaseOp<T> implements CycleOp<Object> {
public abstract class QdrantBaseOp<REQUEST,RESULT> implements CycleOp<RESULT> {
protected final static Logger logger = LogManager.getLogger(QdrantBaseOp.class);
protected final QdrantClient client;
protected final T request;
protected final REQUEST request;
protected final LongFunction<Object> apiCall;
public QdrantBaseOp(QdrantClient client, T requestParam) {
public QdrantBaseOp(QdrantClient client, REQUEST requestParam) {
this.client = client;
this.request = requestParam;
this.apiCall = this::applyOp;
}
public QdrantBaseOp(QdrantClient client, T requestParam, LongFunction<Object> call) {
public QdrantBaseOp(QdrantClient client, REQUEST requestParam, LongFunction<Object> call) {
this.client = client;
this.request = requestParam;
this.apiCall = call;
}
@Override
public final Object apply(long value) {
public final RESULT apply(long value) {
logger.trace("applying op: {}", this);
try {
Object result = applyOp(value);
RESULT result = applyOp(value);
return result;
} catch (Exception e) {
RuntimeException rte = (RuntimeException) e;
@@ -56,7 +56,7 @@ public abstract class QdrantBaseOp<T> implements CycleOp<Object> {
}
}
public abstract Object applyOp(long value);
public abstract RESULT applyOp(long value);
@Override
public String toString() {

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

@@ -21,13 +21,13 @@ import io.qdrant.client.grpc.Collections.CollectionExistsRequest;
import java.time.Duration;
public class QdrantCollectionExistsOp extends QdrantBaseOp<CollectionExistsRequest> {
public class QdrantCollectionExistsOp extends QdrantBaseOp<CollectionExistsRequest,Boolean> {
public QdrantCollectionExistsOp(QdrantClient client, CollectionExistsRequest request) {
super(client, request);
}
@Override
public Object applyOp(long value) {
public Boolean applyOp(long value) {
Boolean response;
try {
response = client.collectionExistsAsync(request.getCollectionName(), Duration.ofSeconds(600)).get();

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

@@ -21,13 +21,13 @@ import io.qdrant.client.grpc.Collections.CollectionInfo;
import java.time.Duration;
public class QdrantCollectionInfoOp extends QdrantBaseOp<String> {
public class QdrantCollectionInfoOp extends QdrantBaseOp<String, CollectionInfo> {
public QdrantCollectionInfoOp(QdrantClient client, String request) {
super(client, request);
}
@Override
public Object applyOp(long value) {
public CollectionInfo applyOp(long value) {
CollectionInfo response;
try {
response = client.getCollectionInfoAsync(request, Duration.ofSeconds(600)).get();

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

@@ -22,13 +22,13 @@ import io.qdrant.client.grpc.Points.CountPoints;
import java.time.Duration;
import java.util.concurrent.ExecutionException;
public class QdrantCountPointsOp extends QdrantBaseOp<CountPoints> {
public class QdrantCountPointsOp extends QdrantBaseOp<CountPoints,Long> {
public QdrantCountPointsOp(QdrantClient client, CountPoints request) {
super(client, request);
}
@Override
public Object applyOp(long value) {
public Long applyOp(long value) {
long result;
try {
boolean hasFilters = request.getFilter() != null && (request.getFilter().getMustCount() > 0

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

@@ -23,7 +23,7 @@ import io.qdrant.client.grpc.Collections.CreateCollection;
import java.util.concurrent.ExecutionException;
public class QdrantCreateCollectionOp extends QdrantBaseOp<CreateCollection> {
public class QdrantCreateCollectionOp extends QdrantBaseOp<CreateCollection,CollectionOperationResponse> {
/**
* Create a new {@link ParsedOp} encapsulating a call to the <b>Qdrant</b> create collection method.
*
@@ -35,7 +35,7 @@ public class QdrantCreateCollectionOp extends QdrantBaseOp<CreateCollection> {
}
@Override
public Object applyOp(long value) {
public CollectionOperationResponse applyOp(long value) {
CollectionOperationResponse response = null;
try {
response = client.createCollectionAsync(request).get();

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

@@ -23,13 +23,13 @@ import io.qdrant.client.grpc.Points.UpdateResult;
import java.time.Duration;
public class QdrantCreatePayloadIndexOp extends QdrantBaseOp<CreateFieldIndexCollection> {
public class QdrantCreatePayloadIndexOp extends QdrantBaseOp<CreateFieldIndexCollection,UpdateResult> {
public QdrantCreatePayloadIndexOp(QdrantClient client, CreateFieldIndexCollection request) {
super(client, request);
}
@Override
public Object applyOp(long value) {
public UpdateResult applyOp(long value) {
UpdateResult response;
try {
response = client.createPayloadIndexAsync(

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

@@ -22,13 +22,13 @@ import io.qdrant.client.grpc.Collections.DeleteCollection;
import java.util.concurrent.ExecutionException;
public class QdrantDeleteCollectionOp extends QdrantBaseOp<DeleteCollection> {
public class QdrantDeleteCollectionOp extends QdrantBaseOp<DeleteCollection,CollectionOperationResponse> {
public QdrantDeleteCollectionOp(QdrantClient client, DeleteCollection request) {
super(client, request);
}
@Override
public Object applyOp(long value) {
public CollectionOperationResponse applyOp(long value) {
CollectionOperationResponse response = null;
try {
response = client.deleteCollectionAsync(request.getCollectionName()).get();

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

@@ -22,13 +22,13 @@ import io.qdrant.client.grpc.Collections.ListCollectionAliasesRequest;
import java.time.Duration;
import java.util.List;
public class QdrantListCollectionAliasesOp extends QdrantBaseOp<ListCollectionAliasesRequest> {
public class QdrantListCollectionAliasesOp extends QdrantBaseOp<ListCollectionAliasesRequest,List<String>> {
public QdrantListCollectionAliasesOp(QdrantClient client, ListCollectionAliasesRequest request) {
super(client, request);
}
@Override
public Object applyOp(long value) {
public List<String> applyOp(long value) {
List<String> response;
try {
response = client.listCollectionAliasesAsync(request.getCollectionName(), Duration.ofSeconds(600)).get();

6
nb-adapters/adapter-qdrant/src/main/java/io/nosqlbench/adapter/qdrant/ops/QdrantListCollectionsOp.java
View File

@@ -21,12 +21,12 @@ import io.qdrant.client.QdrantClient;
import java.time.Duration;
import java.util.List;
public class QdrantListCollectionsOp extends QdrantBaseOp<Object> {
public class QdrantListCollectionsOp extends QdrantBaseOp<Void,List<String>> {
public QdrantListCollectionsOp(QdrantClient client, Object request) {
super(client, request);
super(client, (Void)request);
}
@Override
public Object applyOp(long value) {
public List<String> applyOp(long value) {
List<String> response;
try {
response = client.listCollectionsAsync(Duration.ofSeconds(300)).get();

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

@@ -23,13 +23,13 @@ import io.qdrant.client.grpc.SnapshotsService.SnapshotDescription;
import java.time.Duration;
import java.util.List;
public class QdrantListSnapshotsOp extends QdrantBaseOp<ListSnapshotsRequest> {
public class QdrantListSnapshotsOp extends QdrantBaseOp<ListSnapshotsRequest,List<SnapshotDescription>> {
public QdrantListSnapshotsOp(QdrantClient client, ListSnapshotsRequest request) {
super(client, request);
}
@Override
public Object applyOp(long value) {
public List<SnapshotDescription> applyOp(long value) {
List<SnapshotDescription> response;
try {
response = client.listSnapshotAsync(request.getCollectionName(), Duration.ofSeconds(600)).get();

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

@@ -23,13 +23,13 @@ import io.qdrant.client.grpc.Points.SearchPoints;
import java.util.List;
import java.util.concurrent.ExecutionException;
public class QdrantSearchPointsOp extends QdrantBaseOp<SearchPoints> {
public class QdrantSearchPointsOp extends QdrantBaseOp<SearchPoints,List<ScoredPoint>> {
public QdrantSearchPointsOp(QdrantClient client, SearchPoints request) {
super(client, request);
}
@Override
public Object applyOp(long value) {
public List<ScoredPoint> applyOp(long value) {
List<ScoredPoint> response = null;
try {
logger.debug("[QdrantSearchPointsOp] Cycle {} has request: {}", value, request.toString());

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

@@ -22,13 +22,13 @@ import io.qdrant.client.grpc.Points.UpsertPoints;
import java.util.concurrent.ExecutionException;
public class QdrantUpsertPointsOp extends QdrantBaseOp<UpsertPoints> {
public class QdrantUpsertPointsOp extends QdrantBaseOp<UpsertPoints,UpdateResult> {
public QdrantUpsertPointsOp(QdrantClient client, UpsertPoints request) {
super(client, request);
}
@Override
public Object applyOp(long value) {
public UpdateResult applyOp(long value) {
UpdateResult response = null;
String responseStatus;
long responseOperationId;

2
nb-adapters/adapter-tcp/src/main/java/io/nosqlbench/adapter/tcpclient/TcpClientOp.java
View File

@@ -27,6 +27,8 @@ public class TcpClientOp implements RunnableOp {
this.ctx = ctx;
this.text = text;
}
@Override
public void run() {
ctx.writeflush(text);
}