From 3bcda60485354b4d0d58bab317f361bcd2756646 Mon Sep 17 00:00:00 2001
From: Jonathan Shook <jshook@gmail.com>
Date: Thu, 24 Oct 2024 14:19:46 -0500
Subject: [PATCH] align adapter-cqld4 to API changes

---
 .../adapter/cqld4/Cqld4DriverAdapter.java     | 12 ++--
 .../nosqlbench/adapter/cqld4/Cqld4Space.java  | 10 +--
 .../opdispensers/CqlD4BatchStmtDispenser.java | 19 ++---
 .../CqlD4RainbowTableDispenser.java           |  8 ++-
 .../opdispensers/Cqld4BaseOpDispenser.java    | 10 ++-
 .../Cqld4FluentGraphOpDispenser.java          | 24 ++++---
 .../opdispensers/Cqld4GremlinOpDispenser.java |  8 ++-
 .../Cqld4PreparedStmtDispenser.java           |  9 ++-
 .../opdispensers/Cqld4RawStmtDispenser.java   | 10 ++-
 .../Cqld4SimpleCqlStmtDispenser.java          |  9 ++-
 .../cqld4/opmappers/CqlD4BatchStmtMapper.java | 34 ++++-----
 .../opmappers/CqlD4CqlSimpleStmtMapper.java   | 18 +++--
 .../opmappers/CqlD4PreparedStmtMapper.java    | 23 +++----
 .../opmappers/CqlD4RainbowTableMapper.java    | 17 +++--
 .../cqld4/opmappers/CqlD4RawStmtMapper.java   | 28 +++++---
 .../cqld4/opmappers/Cqld4BaseOpMapper.java    | 52 ++++++++++++++
 .../cqld4/opmappers/Cqld4CoreOpMapper.java    | 53 ++++++--------
 .../cqld4/opmappers/Cqld4CqlOpMapper.java     | 69 +++++++++++++++++++
 .../opmappers/Cqld4FluentGraphOpMapper.java   | 30 +++++---
 .../cqld4/opmappers/Cqld4GremlinOpMapper.java | 17 +++--
 .../adapter/cqld4/optypes/Cqld4BaseOp.java    |  6 ++
 .../adapter/cqld4/optypes/Cqld4CqlOp.java     |  4 +-
 .../cqld4/optypes/Cqld4FluentGraphOp.java     |  2 +-
 .../cqld4/optypes/Cqld4RainbowTableOp.java    |  9 +--
 .../cqld4/optypes/Cqld4ScriptGraphOp.java     |  2 +-
 25 files changed, 331 insertions(+), 152 deletions(-)
 create mode 100644 nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4BaseOpMapper.java
 create mode 100644 nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CqlOpMapper.java
 create mode 100644 nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4BaseOp.java

diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/Cqld4DriverAdapter.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/Cqld4DriverAdapter.java
index b279067a2..10822f1a6 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/Cqld4DriverAdapter.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/Cqld4DriverAdapter.java
@@ -17,6 +17,8 @@
 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;
@@ -35,9 +37,10 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
+import java.util.function.LongFunction;
 
 @Service(value = DriverAdapter.class, selector = "cqld4")
-public class Cqld4DriverAdapter extends BaseDriverAdapter<Op, Cqld4Space> {
+public class Cqld4DriverAdapter extends BaseDriverAdapter<Cqld4BaseOp, Cqld4Space> {
     private final static Logger logger = LogManager.getLogger(Cqld4DriverAdapter.class);
 
     public Cqld4DriverAdapter(NBComponent parentComponent, NBLabels labels) {
@@ -45,14 +48,13 @@ public class Cqld4DriverAdapter extends BaseDriverAdapter<Op, Cqld4Space> {
     }
 
     @Override
-    public OpMapper<Op> getOpMapper() {
-        StringDriverSpaceCache<? extends Cqld4Space> spaceCache = getSpaceCache();
+    public OpMapper<Cqld4BaseOp,Cqld4Space> getOpMapper() {
         NBConfiguration config = getConfiguration();
-        return new Cqld4CoreOpMapper(this, config, spaceCache);
+        return new Cqld4CoreOpMapper(this, config);
     }
 
     @Override
-    public Function<String, ? extends Cqld4Space> getSpaceInitializer(NBConfiguration cfg) {
+    public LongFunction<Cqld4Space> getSpaceInitializer(NBConfiguration cfg) {
         return s -> new Cqld4Space(s,cfg);
     }
 
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/Cqld4Space.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/Cqld4Space.java
index f6bf017c9..9ec1f1cad 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/Cqld4Space.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/Cqld4Space.java
@@ -28,6 +28,7 @@ import io.nosqlbench.adapter.cqld4.optionhelpers.OptionHelpers;
 import io.nosqlbench.adapter.cqld4.wrapper.Cqld4LoadBalancerObserver;
 import io.nosqlbench.adapter.cqld4.wrapper.Cqld4SessionBuilder;
 import io.nosqlbench.adapter.cqld4.wrapper.NodeSummary;
+import io.nosqlbench.adapters.api.activityimpl.uniform.BaseSpace;
 import io.nosqlbench.nb.api.config.standard.*;
 import io.nosqlbench.nb.api.errors.OpConfigError;
 import io.nosqlbench.nb.api.nbio.Content;
@@ -47,14 +48,13 @@ import java.nio.file.Paths;
 import java.util.*;
 import java.util.stream.Collectors;
 
-public class Cqld4Space implements AutoCloseable {
+public class Cqld4Space extends BaseSpace {
     private final static Logger logger = LogManager.getLogger(Cqld4Space.class);
-    private final String space;
 
     CqlSession session;
 
-    public Cqld4Space(String space, NBConfiguration cfg) {
-        this.space = space;
+    public Cqld4Space(long space, NBConfiguration cfg) {
+        super(space);
         session = createSession(cfg);
     }
 
@@ -340,7 +340,7 @@ public class Cqld4Space implements AutoCloseable {
         try {
             this.getSession().close();
         } catch (Exception e) {
-            logger.warn("auto-closeable cql session threw exception in cql space(" + this.space + "): " + e);
+            logger.warn("auto-closeable cql session threw exception in cql space(" + getName() + "): " + e);
             throw e;
         }
     }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/CqlD4BatchStmtDispenser.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/CqlD4BatchStmtDispenser.java
index 74501e223..fe77fff31 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/CqlD4BatchStmtDispenser.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/CqlD4BatchStmtDispenser.java
@@ -18,25 +18,28 @@ package io.nosqlbench.adapter.cqld4.opdispensers;
 
 import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.cql.*;
+import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
+import io.nosqlbench.adapter.cqld4.Cqld4Space;
 import io.nosqlbench.adapter.cqld4.optionhelpers.BatchTypeEnum;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlBatchStatement;
 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.templating.ParsedOp;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.function.LongFunction;
 
-public class CqlD4BatchStmtDispenser extends Cqld4BaseOpDispenser {
+public class CqlD4BatchStmtDispenser<OT extends Cqld4CqlBatchStatement> extends Cqld4BaseOpDispenser<Cqld4CqlBatchStatement> {
     private final int repeat;
     private final ParsedOp subop;
     private final OpMapper submapper;
     private LongFunction<Statement> opfunc;
 
     public CqlD4BatchStmtDispenser(
-        DriverAdapter adapter,
+        Cqld4DriverAdapter adapter,
         LongFunction<CqlSession> sessionFunc,
         ParsedOp op,
         int repeat,
@@ -48,7 +51,7 @@ public class CqlD4BatchStmtDispenser extends Cqld4BaseOpDispenser {
         this.subop = subop;
         this.opfunc = createStmtFunc(op, subopDispenser);
         this.submapper = adapter.getOpMapper();
-        subopDispenser = submapper.apply(subop);
+        subopDispenser = submapper.apply(subop, adapter.getSpaceFunc(op));
 
     }
 
@@ -62,19 +65,19 @@ public class CqlD4BatchStmtDispenser extends Cqld4BaseOpDispenser {
         BatchTypeEnum bte = topOp.getEnumFromFieldOr(BatchTypeEnum.class, BatchTypeEnum.unlogged, "batchtype");
         LongFunction<BatchStatementBuilder> bsbf = l -> new BatchStatementBuilder(bte.batchtype);
         LongFunction<Statement> bsf = getBatchAccumulator(bsbf, subopDispenser);
-        bsf = getEnhancedStmtFunc(bsf,topOp);
+        bsf = getEnhancedStmtFunc(bsf, topOp);
         return bsf;
     }
 
     @NotNull
     private LongFunction<Statement> getBatchAccumulator(LongFunction<BatchStatementBuilder> bsb, OpDispenser<? extends Cqld4CqlOp> subopDispenser) {
         LongFunction<BatchStatementBuilder> f = l -> {
-            long base=l*repeat;
+            long base = l * repeat;
             BatchStatementBuilder bsa = bsb.apply(l);
             for (int i = 0; i < repeat; i++) {
-                Cqld4CqlOp op = subopDispenser.apply(base+i);
+                Cqld4CqlOp op = subopDispenser.apply(base + i);
                 BatchableStatement<?> stmt = (BatchableStatement<?>) op.getStmt();
-                bsa= bsa.addStatement(stmt);
+                bsa = bsa.addStatement(stmt);
             }
             return bsa;
         };
@@ -84,7 +87,7 @@ public class CqlD4BatchStmtDispenser extends Cqld4BaseOpDispenser {
     }
 
     @Override
-    public Cqld4CqlOp getOp(long value) {
+    public Cqld4CqlBatchStatement getOp(long value) {
         Statement bstmt = opfunc.apply(value);
         return new Cqld4CqlBatchStatement(
             getSessionFunc().apply(value),
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/CqlD4RainbowTableDispenser.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/CqlD4RainbowTableDispenser.java
index 41e05e134..38ae865ca 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/CqlD4RainbowTableDispenser.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/CqlD4RainbowTableDispenser.java
@@ -17,18 +17,22 @@
 package io.nosqlbench.adapter.cqld4.opdispensers;
 
 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.Cqld4CqlOp;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4RainbowTableOp;
 import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
 import io.nosqlbench.adapters.api.templating.ParsedOp;
 
 import java.util.function.LongFunction;
 
-public class CqlD4RainbowTableDispenser extends Cqld4BaseOpDispenser {
+public class CqlD4RainbowTableDispenser extends Cqld4BaseOpDispenser<Cqld4RainbowTableOp> {
 
 //    private final LongFunction<Statement> stmtFunc;
     private final LongFunction<String> targetFunction;
 
-    public CqlD4RainbowTableDispenser(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, LongFunction<String> targetFunction, ParsedOp cmd) {
+    public CqlD4RainbowTableDispenser(Cqld4DriverAdapter adapter, LongFunction<CqlSession> sessionFunc,
+                                      LongFunction<String> targetFunction, ParsedOp cmd) {
         super(adapter, sessionFunc,cmd);
         this.targetFunction=targetFunction;
 //        this.tableFunc =createTableFunc(cmd);
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4BaseOpDispenser.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4BaseOpDispenser.java
index 1b9e17551..5a9e33c57 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4BaseOpDispenser.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4BaseOpDispenser.java
@@ -24,8 +24,10 @@ import com.datastax.oss.driver.api.core.config.DriverExecutionProfile;
 import com.datastax.oss.driver.api.core.cql.*;
 import com.datastax.oss.driver.api.core.metadata.Node;
 import com.datastax.oss.driver.api.core.metadata.token.Token;
+import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
 import io.nosqlbench.adapter.cqld4.Cqld4Space;
 import io.nosqlbench.adapter.cqld4.instruments.CqlOpMetrics;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
 import io.nosqlbench.adapters.api.activityimpl.BaseOpDispenser;
 import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
@@ -40,19 +42,21 @@ import java.time.Duration;
 import java.util.Map;
 import java.util.function.LongFunction;
 
-public abstract class Cqld4BaseOpDispenser extends BaseOpDispenser<Cqld4CqlOp, Cqld4Space> implements CqlOpMetrics {
+public abstract class Cqld4BaseOpDispenser<T extends Cqld4BaseOp> extends BaseOpDispenser<Cqld4BaseOp, Cqld4Space> implements CqlOpMetrics {
 
     private final static Logger logger = LogManager.getLogger("CQLD4");
 
     private final int maxpages;
-    private final LongFunction<CqlSession> sessionFunc;
+    protected final LongFunction<CqlSession> sessionFunc;
     private final boolean isRetryReplace;
     private final int maxLwtRetries;
     private final Histogram rowsHistogram;
     private final Histogram pagesHistogram;
     private final Histogram payloadBytesHistogram;
 
-    public Cqld4BaseOpDispenser(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, ParsedOp op) {
+    public Cqld4BaseOpDispenser(Cqld4DriverAdapter adapter,
+                                LongFunction<CqlSession> sessionFunc,
+                                ParsedOp op) {
         super(adapter, op);
         this.sessionFunc = sessionFunc;
         this.maxpages = op.getStaticConfigOr("maxpages", 1);
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4FluentGraphOpDispenser.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4FluentGraphOpDispenser.java
index 145cd07cb..8c6cdb1af 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4FluentGraphOpDispenser.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4FluentGraphOpDispenser.java
@@ -20,11 +20,12 @@ import com.datastax.dse.driver.api.core.graph.FluentGraphStatement;
 import com.datastax.dse.driver.api.core.graph.FluentGraphStatementBuilder;
 import com.datastax.oss.driver.api.core.CqlSession;
 import groovy.lang.Script;
+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.adapter.cqld4.optypes.Cqld4FluentGraphOp;
-import io.nosqlbench.adapters.api.activityimpl.BaseOpDispenser;
 import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
-import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
 import io.nosqlbench.adapters.api.templating.ParsedOp;
 import io.nosqlbench.virtdata.core.bindings.Bindings;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
@@ -34,7 +35,7 @@ import java.util.Map;
 import java.util.function.LongFunction;
 import java.util.function.Supplier;
 
-public class Cqld4FluentGraphOpDispenser extends BaseOpDispenser<Op, Cqld4Space> {
+public class Cqld4FluentGraphOpDispenser extends Cqld4BaseOpDispenser<Cqld4BaseOp> {
 
     private final LongFunction<? extends String> graphnameFunc;
     private final LongFunction<CqlSession> sessionFunc;
@@ -42,22 +43,23 @@ public class Cqld4FluentGraphOpDispenser extends BaseOpDispenser<Op, Cqld4Space>
     private final ThreadLocal<Script> tlScript;
 
     public Cqld4FluentGraphOpDispenser(
-        DriverAdapter adapter,
-        ParsedOp optpl,
-        LongFunction<? extends String> graphnameFunc,
+        Cqld4DriverAdapter adapter,
         LongFunction<CqlSession> sessionFunc,
+        ParsedOp op,
+        LongFunction<? extends String> graphnameFunc,
+        LongFunction<CqlSession> sessionFunc1,
         Bindings virtdataBindings,
-        Supplier<Script> scriptSource
+        Supplier<Script> scriptSupplier
     ) {
-        super(adapter, optpl);
+        super(adapter, sessionFunc, op);
         this.graphnameFunc = graphnameFunc;
-        this.sessionFunc = sessionFunc;
+        this.sessionFunc = sessionFunc1;
         this.virtdataBindings = virtdataBindings;
-        this.tlScript = ThreadLocal.withInitial(scriptSource);
+        this.tlScript = ThreadLocal.withInitial(scriptSupplier);
     }
 
     @Override
-    public Op getOp(long value) {
+    public Cqld4BaseOp getOp(long value) {
         String graphname = graphnameFunc.apply(value);
         Script script = tlScript.get();
         Map<String, Object> allMap = virtdataBindings.getAllMap(value);
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4GremlinOpDispenser.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4GremlinOpDispenser.java
index 8f3c74686..d190d8e1b 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4GremlinOpDispenser.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4GremlinOpDispenser.java
@@ -19,7 +19,10 @@ package io.nosqlbench.adapter.cqld4.opdispensers;
 import com.datastax.dse.driver.api.core.graph.ScriptGraphStatement;
 import com.datastax.dse.driver.api.core.graph.ScriptGraphStatementBuilder;
 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.adapter.cqld4.optypes.Cqld4ScriptGraphOp;
 import io.nosqlbench.adapters.api.activityimpl.BaseOpDispenser;
 import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
@@ -28,13 +31,14 @@ import io.nosqlbench.adapters.api.templating.ParsedOp;
 import java.util.Optional;
 import java.util.function.LongFunction;
 
-public class Cqld4GremlinOpDispenser extends BaseOpDispenser<Cqld4ScriptGraphOp, Cqld4Space> {
+public class Cqld4GremlinOpDispenser extends BaseOpDispenser<Cqld4BaseOp, Cqld4Space> {
 
     private final LongFunction<? extends ScriptGraphStatement> stmtFunc;
     private final LongFunction<CqlSession> sessionFunc;
     private final LongFunction<Long> diagFunc;
 
-    public Cqld4GremlinOpDispenser(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, LongFunction<String> targetFunction, ParsedOp cmd) {
+    public Cqld4GremlinOpDispenser(Cqld4DriverAdapter adapter,
+                                   LongFunction<CqlSession> sessionFunc, LongFunction<String> targetFunction, ParsedOp cmd) {
         super(adapter,cmd);
         this.sessionFunc = sessionFunc;
         this.diagFunc = cmd.getAsFunctionOr("diag", 0L);
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4PreparedStmtDispenser.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4PreparedStmtDispenser.java
index acf25c74c..821fc80a3 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4PreparedStmtDispenser.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4PreparedStmtDispenser.java
@@ -20,6 +20,8 @@ import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.cql.BoundStatement;
 import com.datastax.oss.driver.api.core.cql.PreparedStatement;
 import com.datastax.oss.driver.api.core.cql.Statement;
+import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
+import io.nosqlbench.adapter.cqld4.Cqld4Space;
 import io.nosqlbench.adapter.cqld4.RSProcessors;
 import io.nosqlbench.adapter.cqld4.diagnostics.CQLD4PreparedStmtDiagnostics;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
@@ -44,7 +46,12 @@ public class Cqld4PreparedStmtDispenser extends Cqld4BaseOpDispenser {
     private CqlSession boundSession;
 
     public Cqld4PreparedStmtDispenser(
-            DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, ParsedOp op, ParsedTemplateString stmtTpl, RSProcessors processors) {
+        Cqld4DriverAdapter adapter,
+            LongFunction<CqlSession> sessionFunc,
+            ParsedOp op,
+            ParsedTemplateString stmtTpl,
+            RSProcessors processors
+    ) {
         super(adapter, sessionFunc, op);
         if (op.isDynamic("space")) {
             throw new RuntimeException("Prepared statements and dynamic space values are not yet  supported" +
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4RawStmtDispenser.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4RawStmtDispenser.java
index 9c5139c0f..ad1cdae55 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4RawStmtDispenser.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4RawStmtDispenser.java
@@ -20,6 +20,8 @@ import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.cql.SimpleStatementBuilder;
 import com.datastax.oss.driver.api.core.cql.Statement;
+import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
+import io.nosqlbench.adapter.cqld4.Cqld4Space;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlSimpleStatement;
 import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
@@ -27,12 +29,14 @@ import io.nosqlbench.adapters.api.templating.ParsedOp;
 
 import java.util.function.LongFunction;
 
-public class Cqld4RawStmtDispenser extends Cqld4BaseOpDispenser {
+public class Cqld4RawStmtDispenser extends Cqld4BaseOpDispenser<Cqld4CqlOp> {
 
     private final LongFunction<Statement> stmtFunc;
     private final LongFunction<String> targetFunction;
 
-    public Cqld4RawStmtDispenser(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, LongFunction<String> targetFunction, ParsedOp cmd) {
+    public Cqld4RawStmtDispenser(Cqld4DriverAdapter adapter,
+                                 LongFunction<CqlSession> sessionFunc,
+                                 LongFunction<String> targetFunction, ParsedOp cmd) {
         super(adapter, sessionFunc, cmd);
         this.targetFunction=targetFunction;
         this.stmtFunc = createStmtFunc(cmd);
@@ -44,7 +48,7 @@ public class Cqld4RawStmtDispenser extends Cqld4BaseOpDispenser {
     }
 
     @Override
-    public Cqld4CqlOp getOp(long value) {
+    public Cqld4CqlSimpleStatement getOp(long value) {
         return new Cqld4CqlSimpleStatement(
             getSessionFunc().apply(value),
             (SimpleStatement) stmtFunc.apply(value),
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4SimpleCqlStmtDispenser.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4SimpleCqlStmtDispenser.java
index c4c3fbfea..5d4cde43e 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4SimpleCqlStmtDispenser.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opdispensers/Cqld4SimpleCqlStmtDispenser.java
@@ -19,18 +19,21 @@ package io.nosqlbench.adapter.cqld4.opdispensers;
 import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
 import com.datastax.oss.driver.api.core.cql.Statement;
+import io.nosqlbench.adapter.cqld4.Cqld4DriverAdapter;
+import io.nosqlbench.adapter.cqld4.Cqld4Space;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlSimpleStatement;
 import io.nosqlbench.adapters.api.activityimpl.uniform.DriverAdapter;
 import io.nosqlbench.adapters.api.templating.ParsedOp;
 
 import java.util.function.LongFunction;
 
-public class Cqld4SimpleCqlStmtDispenser extends Cqld4BaseOpDispenser {
+public class Cqld4SimpleCqlStmtDispenser<T extends Cqld4CqlOp> extends Cqld4BaseOpDispenser<T> {
 
     private final LongFunction<Statement> stmtFunc;
     private final LongFunction<String> targetFunction;
 
-    public Cqld4SimpleCqlStmtDispenser(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, LongFunction<String> targetFunction, ParsedOp cmd) {
+    public Cqld4SimpleCqlStmtDispenser(Cqld4DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, LongFunction<String> targetFunction, ParsedOp cmd) {
         super(adapter, sessionFunc,cmd);
         this.targetFunction=targetFunction;
         this.stmtFunc =createStmtFunc(cmd);
@@ -43,7 +46,7 @@ public class Cqld4SimpleCqlStmtDispenser extends Cqld4BaseOpDispenser {
     @Override
     public Cqld4CqlSimpleStatement getOp(long value) {
         return new Cqld4CqlSimpleStatement(
-            getSessionFunc().apply(value),
+            sessionFunc.apply(value),
             (SimpleStatement) stmtFunc.apply(value),
             getMaxPages(),
             isRetryReplace(),
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4BatchStmtMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4BatchStmtMapper.java
index e20f153a8..d6a0eaa91 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4BatchStmtMapper.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4BatchStmtMapper.java
@@ -17,43 +17,39 @@
 package io.nosqlbench.adapter.cqld4.opmappers;
 
 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.opdispensers.CqlD4BatchStmtDispenser;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlBatchStatement;
 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.Space;
 import io.nosqlbench.adapters.api.templating.ParsedOp;
 import io.nosqlbench.engine.api.templating.TypeAndTarget;
+import io.nosqlbench.nb.api.errors.OpConfigError;
 
 import java.util.function.LongFunction;
 
-public class CqlD4BatchStmtMapper implements OpMapper<Cqld4CqlOp> {
+public class CqlD4BatchStmtMapper extends Cqld4BaseOpMapper<Cqld4BaseOp> {
 
-    private final LongFunction<CqlSession> sessionFunc;
     private final TypeAndTarget<CqlD4OpType, String> target;
-    private final DriverAdapter adapter;
 
-
-    public CqlD4BatchStmtMapper(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, TypeAndTarget<CqlD4OpType,String> target) {
-        this.sessionFunc=sessionFunc;
+    public CqlD4BatchStmtMapper(Cqld4DriverAdapter adapter,
+                                TypeAndTarget<CqlD4OpType, String> target) {
+        super(adapter);
         this.target = target;
-        this.adapter = adapter;
     }
 
-    /**
-     * TODO: Make this not require a sub-op element for "uniform batches",
-     * but allow a sub-op sequence for custom batches.
-     * @param op the function argument
-     * @return
-     */
-    public OpDispenser<Cqld4CqlOp> apply(ParsedOp op) {
-
+    @Override
+    public OpDispenser<Cqld4BaseOp> apply(ParsedOp op, LongFunction<Cqld4Space> spaceInitF) {
         ParsedOp subop = op.getAsSubOp("op_template", ParsedOp.SubOpNaming.ParentAndSubKey);
         int repeat = op.getStaticValue("repeat");
-        OpMapper<Cqld4CqlOp> subopMapper = adapter.getOpMapper();
-        OpDispenser<? extends Cqld4CqlOp> subopDispenser = subopMapper.apply(subop);
-        return new CqlD4BatchStmtDispenser(adapter, sessionFunc, op,repeat, subop, subopDispenser);
-
+        OpDispenser<? extends Cqld4BaseOp> od = new Cqld4CqlOpMapper(adapter).apply(op, spaceInitF);
+        return new CqlD4BatchStmtDispenser(adapter, sessionFunc, op, repeat, subop, od);
     }
+
 }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4CqlSimpleStmtMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4CqlSimpleStmtMapper.java
index a07e03a42..f9ffaaf8e 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4CqlSimpleStmtMapper.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4CqlSimpleStmtMapper.java
@@ -17,28 +17,32 @@
 package io.nosqlbench.adapter.cqld4.opmappers;
 
 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.opdispensers.Cqld4SimpleCqlStmtDispenser;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlSimpleStatement;
 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.templating.ParsedOp;
 
 import java.util.function.LongFunction;
 
-public class CqlD4CqlSimpleStmtMapper implements OpMapper<Cqld4CqlOp> {
-    private final LongFunction<CqlSession> sessionFunc;
+public class CqlD4CqlSimpleStmtMapper extends Cqld4BaseOpMapper<Cqld4BaseOp> {
     private final LongFunction<String> targetFunction;
-    private final DriverAdapter adapter;
 
-    public CqlD4CqlSimpleStmtMapper(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, LongFunction<String> targetFunction) {
-        this.sessionFunc = sessionFunc;
+    public CqlD4CqlSimpleStmtMapper(Cqld4DriverAdapter adapter,
+                                    LongFunction<String> targetFunction) {
+        super(adapter);
         this.targetFunction = targetFunction;
-        this.adapter = adapter;
     }
 
     @Override
-    public OpDispenser<? extends Cqld4CqlOp> apply(ParsedOp op) {
+    public OpDispenser<Cqld4BaseOp> apply(ParsedOp op, LongFunction spaceInitF) {
         return new Cqld4SimpleCqlStmtDispenser(adapter, sessionFunc,targetFunction, op);
     }
+
 }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4PreparedStmtMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4PreparedStmtMapper.java
index 4a5a9d144..34c47351d 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4PreparedStmtMapper.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4PreparedStmtMapper.java
@@ -17,15 +17,16 @@
 package io.nosqlbench.adapter.cqld4.opmappers;
 
 import com.datastax.oss.driver.api.core.CqlSession;
-import io.nosqlbench.adapter.cqld4.Cqld4Processors;
-import io.nosqlbench.adapter.cqld4.RSProcessors;
-import io.nosqlbench.adapter.cqld4.ResultSetProcessor;
+import io.nosqlbench.adapter.cqld4.*;
 import io.nosqlbench.adapter.cqld4.opdispensers.Cqld4PreparedStmtDispenser;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlPreparedStatement;
 import io.nosqlbench.adapter.cqld4.processors.CqlFieldCaptureProcessor;
 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.templating.ParsedOp;
 import io.nosqlbench.engine.api.templating.TypeAndTarget;
 import io.nosqlbench.nb.api.config.params.ParamsParser;
@@ -37,20 +38,18 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.function.LongFunction;
 
-public class CqlD4PreparedStmtMapper implements OpMapper<Cqld4CqlOp> {
+public class CqlD4PreparedStmtMapper extends Cqld4BaseOpMapper<Cqld4BaseOp> {
 
-    private final LongFunction<CqlSession> sessionFunc;
     private final TypeAndTarget<CqlD4OpType, String> target;
-    private final DriverAdapter adapter;
 
-    public CqlD4PreparedStmtMapper(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, TypeAndTarget<CqlD4OpType,String> target) {
-        this.sessionFunc=sessionFunc;
+    public CqlD4PreparedStmtMapper(Cqld4DriverAdapter adapter,
+                                   TypeAndTarget<CqlD4OpType, String> target) {
+        super(adapter);
         this.target = target;
-        this.adapter = adapter;
     }
 
-    public OpDispenser<Cqld4CqlOp> apply(ParsedOp op) {
-
+    @Override
+    public OpDispenser<Cqld4BaseOp> apply(ParsedOp op, LongFunction<Cqld4Space> spaceInitF) {
         ParsedTemplateString stmtTpl = op.getAsTemplate(target.field).orElseThrow(() -> new BasicError(
             "No statement was found in the op template:" + op
         ));
@@ -71,6 +70,6 @@ public class CqlD4PreparedStmtMapper implements OpMapper<Cqld4CqlOp> {
         });
 
         return new Cqld4PreparedStmtDispenser(adapter, sessionFunc, op, stmtTpl, processors);
-
     }
+
 }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RainbowTableMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RainbowTableMapper.java
index 8656a26ab..d2979f681 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RainbowTableMapper.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RainbowTableMapper.java
@@ -17,27 +17,34 @@
 package io.nosqlbench.adapter.cqld4.opmappers;
 
 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.Cqld4CqlOp;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4RainbowTableOp;
 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.templating.ParsedOp;
 
 import java.util.function.LongFunction;
 
-public class CqlD4RainbowTableMapper implements OpMapper<Cqld4RainbowTableOp> {
-    private final LongFunction<CqlSession> sessionFunc;
+public class CqlD4RainbowTableMapper<CO extends Cqld4RainbowTableOp> extends Cqld4BaseOpMapper<Cqld4RainbowTableOp> {
     private final LongFunction<String> targetFunction;
     private final DriverAdapter adapter;
 
-    public CqlD4RainbowTableMapper(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, LongFunction<String> targetFunction) {
-        this.sessionFunc = sessionFunc;
+    public CqlD4RainbowTableMapper(
+        Cqld4DriverAdapter adapter,
+        LongFunction<CqlSession> sessionFunc,
+        LongFunction<String> targetFunction
+    ) {
+        super(adapter);
         this.targetFunction = targetFunction;
         this.adapter = adapter;
     }
 
     @Override
-    public OpDispenser<? extends Cqld4RainbowTableOp> apply(ParsedOp op) {
+    public OpDispenser<Cqld4RainbowTableOp> apply(ParsedOp op, LongFunction spaceInitF) {
         return null;
 //        return new CqlD4RainbowTableDispenser(adapter, sessionFunc,targetFunction, op);
     }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RawStmtMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RawStmtMapper.java
index 14035a551..372b06f90 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RawStmtMapper.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/CqlD4RawStmtMapper.java
@@ -16,30 +16,40 @@
 
 package io.nosqlbench.adapter.cqld4.opmappers;
 
-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.opdispensers.Cqld4RawStmtDispenser;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4BaseOp;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlSimpleStatement;
 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.templating.ParsedOp;
 
 import java.util.function.LongFunction;
 
-public class CqlD4RawStmtMapper implements OpMapper<Cqld4CqlOp> {
+public class CqlD4RawStmtMapper extends Cqld4BaseOpMapper<Cqld4BaseOp> {
 
-    private final LongFunction<CqlSession> sessionFunc;
     private final LongFunction<String> targetFunction;
-    private final DriverAdapter adapter;
 
-    public CqlD4RawStmtMapper(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, LongFunction<String> targetFunction) {
-        this.sessionFunc = sessionFunc;
+    public CqlD4RawStmtMapper(Cqld4DriverAdapter adapter,
+                              LongFunction<String> targetFunction) {
+        super(adapter);
         this.targetFunction = targetFunction;
-        this.adapter = adapter;
     }
 
     @Override
-    public OpDispenser<? extends Cqld4CqlOp> apply(ParsedOp op) {
+    public OpDispenser<Cqld4BaseOp> apply(ParsedOp op, LongFunction<Cqld4Space> spaceInitF) {
         return new Cqld4RawStmtDispenser(adapter, sessionFunc, targetFunction, op);
     }
+
+    //    @Override
+//    public OpDispenser<Cqld4CqlOp> apply(ParsedOp op, LongFunction<Cqld4Space> spaceInitF) {
+//        return new Cqld4RawStmtDispenser(adapter, sessionFunc, targetFunction, op);
+//    }
+
+//    @Override
+//    public OpDispenser<Cqld4CqlOp> apply(ParsedOp parsedOp, LongFunction<Cqld4Space> longFunction) {
+//        return new Cqld4RawStmtDispenser(adapter, sessionFunc, targetFunction, parsedOp);
+//    }
 }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4BaseOpMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4BaseOpMapper.java
new file mode 100644
index 000000000..a8b854283
--- /dev/null
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4BaseOpMapper.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2022-2023 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.
+ */
+
+package io.nosqlbench.adapter.cqld4.opmappers;
+
+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.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> {
+
+    protected final static Logger logger = LogManager.getLogger(Cqld4BaseOpMapper.class);
+    protected final Cqld4DriverAdapter adapter;
+    protected final LongFunction<Cqld4Space> spaceFunc;
+    protected final LongFunction<CqlSession> sessionFunc;
+
+    public Cqld4BaseOpMapper(Cqld4DriverAdapter adapter) {
+        this.adapter = adapter;
+        spaceFunc = l -> adapter.getSpaceCache().get(l);
+        sessionFunc = l -> spaceFunc.apply(l).getSession();
+    }
+
+    @Override
+    public abstract OpDispenser<T> apply(ParsedOp op, LongFunction<Cqld4Space> spaceInitF);
+}
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CoreOpMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CoreOpMapper.java
index 40f53a88d..37d4a9978 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CoreOpMapper.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CoreOpMapper.java
@@ -16,33 +16,28 @@
 
 package io.nosqlbench.adapter.cqld4.opmappers;
 
-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.uniform.DriverAdapter;
 import io.nosqlbench.nb.api.config.standard.NBConfiguration;
 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.StringDriverSpaceCache;
-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;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import java.util.function.LongFunction;
 
-public class Cqld4CoreOpMapper implements OpMapper<Op> {
+public class Cqld4CoreOpMapper extends Cqld4BaseOpMapper<Cqld4BaseOp> {
 
     private final static Logger logger = LogManager.getLogger(Cqld4CoreOpMapper.class);
 
-    private final StringDriverSpaceCache<? extends Cqld4Space> cache;
-    private final NBConfiguration cfg;
-    private final DriverAdapter adapter;
-
-    public Cqld4CoreOpMapper(DriverAdapter adapter, NBConfiguration config, StringDriverSpaceCache<? extends Cqld4Space> cache) {
-        this.cfg = config;
-        this.cache = cache;
-        this.adapter = adapter;
+    public Cqld4CoreOpMapper(Cqld4DriverAdapter adapter,
+                             NBConfiguration config) {
+        super(adapter);
     }
 
     /**
@@ -50,35 +45,27 @@ public class Cqld4CoreOpMapper implements OpMapper<Op> {
      * for it. Since the operations under the CQL driver 4.* do not follow a common type structure, we use the
      * base types in the NoSQLBench APIs and treat them somewhat more generically than with other drivers.
      *
-     * @param op The {@link ParsedOp} which is the parsed version of the user-provided op template.
-     *            This contains all the fields provided by the user, as well as explicit knowledge of
-     *            which ones are static and dynamic.
+     * @param op
+     *     The {@link ParsedOp} which is the parsed version of the user-provided op template.
+     *     This contains all the fields provided by the user, as well as explicit knowledge of
+     *     which ones are static and dynamic.
      * @return An op dispenser for each provided op command
      */
-    public OpDispenser<? extends Op> apply(ParsedOp op) {
-
-        LongFunction<String> spaceName = op.getAsFunctionOr("space", "default");
-        // Since the only needed thing in the Cqld4Space is the session, we can short-circuit
-        // to it here instead of stepping down from the cycle to the space to the session
-        LongFunction<CqlSession> sessionFunc = l -> cache.get(spaceName.apply(l)).getSession();
 
+    @Override
+    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()+"'");
 
         return switch (target.enumId) {
-            case raw -> new CqlD4RawStmtMapper(adapter, sessionFunc, target.targetFunction).apply(op);
-            case simple -> new CqlD4CqlSimpleStmtMapper(adapter, sessionFunc, target.targetFunction).apply(op);
-            case prepared -> new CqlD4PreparedStmtMapper(adapter, sessionFunc, target).apply(op);
-            case batch -> new CqlD4BatchStmtMapper(adapter, sessionFunc, target).apply(op);
-            case gremlin -> new Cqld4GremlinOpMapper(adapter, sessionFunc, target.targetFunction).apply(op);
-            case fluent -> new Cqld4FluentGraphOpMapper(adapter, sessionFunc, target).apply(op);
-            case rainbow -> new CqlD4RainbowTableMapper(adapter, sessionFunc, target.targetFunction).apply(op);
+            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);
+            default -> throw new OpConfigError("Unsupported op type " + opType);
 //            case sst -> new Cqld4SsTableMapper(adapter, sessionFunc, target.targetFunction).apply(op);
         };
     }
 
-
 }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CqlOpMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CqlOpMapper.java
new file mode 100644
index 000000000..907a40295
--- /dev/null
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4CqlOpMapper.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2022-2023 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.
+ */
+
+package io.nosqlbench.adapter.cqld4.opmappers;
+
+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.adapter.cqld4.optypes.Cqld4CqlSimpleStatement;
+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.templating.ParsedOp;
+import io.nosqlbench.engine.api.templating.TypeAndTarget;
+import io.nosqlbench.nb.api.errors.OpConfigError;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.LongFunction;
+
+public class Cqld4CqlOpMapper extends Cqld4BaseOpMapper<Cqld4BaseOp> {
+
+    protected final static Logger logger = LogManager.getLogger(Cqld4CqlOpMapper.class);
+
+    public Cqld4CqlOpMapper(Cqld4DriverAdapter adapter) {
+        super(adapter);
+    }
+
+    @Override
+    public OpDispenser<Cqld4BaseOp> apply(ParsedOp op, LongFunction<Cqld4Space> spaceInitF) {
+        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() + "'");
+
+        return switch (target.enumId) {
+            case raw -> {
+                CqlD4RawStmtMapper cqlD4RawStmtMapper = new CqlD4RawStmtMapper(adapter, target.targetFunction);
+                OpDispenser<Cqld4BaseOp> apply = cqlD4RawStmtMapper.apply(op, spaceFunc);
+                yield apply;
+            }
+            case simple -> new CqlD4CqlSimpleStmtMapper(adapter, target.targetFunction).apply(op, spaceFunc);
+            case prepared -> new CqlD4PreparedStmtMapper(adapter, target).apply(op, spaceFunc);
+
+            case batch -> new CqlD4BatchStmtMapper(adapter, target).apply(op, spaceFunc);
+            default -> throw new OpConfigError("Unsupported op type for CQL category of statement forms:" + target.enumId);
+        };
+    }
+
+
+}
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4FluentGraphOpMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4FluentGraphOpMapper.java
index e14481d45..f0a8ce535 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4FluentGraphOpMapper.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4FluentGraphOpMapper.java
@@ -21,10 +21,16 @@ 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;
@@ -45,22 +51,21 @@ import java.util.Map;
 import java.util.function.LongFunction;
 import java.util.function.Supplier;
 
-public class Cqld4FluentGraphOpMapper implements OpMapper<Op> {
+public class Cqld4FluentGraphOpMapper<CO extends Cqld4FluentGraphOp> extends Cqld4BaseOpMapper<Cqld4BaseOp> {
     private final static Logger logger = LogManager.getLogger(Cqld4FluentGraphOpMapper.class);
 
-    private final LongFunction<CqlSession> sessionFunc;
     private final TypeAndTarget<CqlD4OpType, String> target;
-    private final DriverAdapter adapter;
     private GraphTraversalSource gtsPlaceHolder;
 
-    public Cqld4FluentGraphOpMapper(DriverAdapter adapter, LongFunction<CqlSession> sessionFunc, TypeAndTarget<CqlD4OpType, String> target) {
-        this.sessionFunc = sessionFunc;
+
+    public Cqld4FluentGraphOpMapper(Cqld4DriverAdapter adapter,
+                                    TypeAndTarget<CqlD4OpType, String> target) {
+        super(adapter);
         this.target = target;
-        this.adapter = adapter;
     }
 
     @Override
-    public OpDispenser<? extends Op> apply(ParsedOp op) {
+    public OpDispenser<Cqld4BaseOp> apply(ParsedOp op, LongFunction<Cqld4Space> cqld4SpaceLongFunction) {
         GraphTraversalSource g = DseGraph.g;
 
         ParsedTemplateString fluent = op.getAsTemplate(target.field).orElseThrow();
@@ -88,7 +93,15 @@ public class Cqld4FluentGraphOpMapper implements OpMapper<Op> {
         LongFunction<? extends String> graphnameFunc = op.getAsRequiredFunction("graphname");
         Bindings virtdataBindings = new BindingsTemplate(fluent.getBindPoints()).resolveBindings();
 
-        return new Cqld4FluentGraphOpDispenser(adapter, op, graphnameFunc, sessionFunc, virtdataBindings, supplier);
+        return new Cqld4FluentGraphOpDispenser(
+            adapter,
+            sessionFunc,
+            op,
+            graphnameFunc,
+            sessionFunc,
+            virtdataBindings,
+            supplier
+        );
     }
 
     private String[] expandClassNames(List l) {
@@ -110,4 +123,5 @@ public class Cqld4FluentGraphOpMapper implements OpMapper<Op> {
         }
         return classNames.toArray(new String[0]);
     }
+
 }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4GremlinOpMapper.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4GremlinOpMapper.java
index ec1123522..695d59d81 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4GremlinOpMapper.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/opmappers/Cqld4GremlinOpMapper.java
@@ -17,27 +17,30 @@
 package io.nosqlbench.adapter.cqld4.opmappers;
 
 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.opdispensers.Cqld4GremlinOpDispenser;
+import io.nosqlbench.adapter.cqld4.optypes.Cqld4CqlOp;
 import io.nosqlbench.adapter.cqld4.optypes.Cqld4ScriptGraphOp;
 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.templating.ParsedOp;
 
 import java.util.function.LongFunction;
 
-public class Cqld4GremlinOpMapper implements OpMapper<Cqld4ScriptGraphOp> {
-    private final LongFunction<CqlSession> sessionFunc;
+public class Cqld4GremlinOpMapper<CO extends Cqld4ScriptGraphOp> extends Cqld4BaseOpMapper<Cqld4ScriptGraphOp> {
     private final LongFunction<String> targetFunction;
-    private final DriverAdapter adapter;
 
-    public Cqld4GremlinOpMapper(DriverAdapter adapter, LongFunction<CqlSession> session, LongFunction<String> targetFunction) {
-        this.sessionFunc = session;
+    public Cqld4GremlinOpMapper(Cqld4DriverAdapter adapter, LongFunction<String> targetFunction) {
+        super(adapter);
         this.targetFunction = targetFunction;
-        this.adapter = adapter;
     }
 
-    public OpDispenser<Cqld4ScriptGraphOp> apply(ParsedOp op) {
+    @Override
+    public Cqld4GremlinOpDispenser apply(ParsedOp op, LongFunction spaceInitF) {
         return new Cqld4GremlinOpDispenser(adapter, sessionFunc, targetFunction, op);
     }
+
 }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4BaseOp.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4BaseOp.java
new file mode 100644
index 000000000..c6beed180
--- /dev/null
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4BaseOp.java
@@ -0,0 +1,6 @@
+package io.nosqlbench.adapter.cqld4.optypes;
+
+import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.Op;
+
+public interface Cqld4BaseOp extends Op {
+}
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4CqlOp.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4CqlOp.java
index 689c6b6fc..2232ba61c 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4CqlOp.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4CqlOp.java
@@ -49,7 +49,9 @@ import java.util.concurrent.*;
 // TODO: add rows histogram resultSetSizeHisto
 
 
-public abstract class Cqld4CqlOp implements CycleOp<List<Row>>, VariableCapture, OpGenerator, OpResultSize {
+public abstract class Cqld4CqlOp
+    implements Cqld4BaseOp, CycleOp<List<Row>>, VariableCapture, OpGenerator, OpResultSize {
+
     private final static Logger logger = LogManager.getLogger(Cqld4CqlOp.class);
 
     private final CqlSession session;
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4FluentGraphOp.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4FluentGraphOp.java
index 2a25b6917..17b67b072 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4FluentGraphOp.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4FluentGraphOp.java
@@ -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 CycleOp<GraphResultSet>, OpResultSize {
+public class Cqld4FluentGraphOp implements Cqld4BaseOp, CycleOp<GraphResultSet>, OpResultSize {
     private final CqlSession session;
     private final FluentGraphStatement stmt;
     private int resultSize=0;
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4RainbowTableOp.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4RainbowTableOp.java
index 92fad8ed1..26900be27 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4RainbowTableOp.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4RainbowTableOp.java
@@ -22,7 +22,8 @@ import io.nosqlbench.adapters.api.activityimpl.uniform.flowtypes.*;
 import java.util.Map;
 
 // Need to create RainbowTableStatement
-public class Cqld4RainbowTableOp implements CycleOp<ResultSet>, VariableCapture, OpGenerator, OpResultSize {
+public class Cqld4RainbowTableOp
+    implements Cqld4BaseOp, CycleOp<ResultSet>, VariableCapture, OpGenerator, OpResultSize {
 //    private final CqlSession session;
 //    private final RainbowTableStatement stmt;
 
@@ -41,10 +42,6 @@ public class Cqld4RainbowTableOp implements CycleOp<ResultSet>, VariableCapture,
     @Override
     public Map<String, ?> capture() {
         throw new RuntimeException("implement me");
-   }
-//
-//    public Cqld4RainbowTableOp(CqlSession session, RainbowTableStatement stmt, int maxpages, boolean retryreplace) {
-//        //
-//    }
+    }
 
 }
diff --git a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4ScriptGraphOp.java b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4ScriptGraphOp.java
index fb6227c79..632c9dda9 100644
--- a/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4ScriptGraphOp.java
+++ b/nb-adapters/adapter-cqld4/src/main/java/io/nosqlbench/adapter/cqld4/optypes/Cqld4ScriptGraphOp.java
@@ -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 CycleOp<GraphResultSet>, OpResultSize {
+public class Cqld4ScriptGraphOp implements Cqld4BaseOp, CycleOp<GraphResultSet>, OpResultSize {
     private final CqlSession session;
     private final ScriptGraphStatement stmt;
     private int resultSize=0;