From 14c38e1f30e2d1e0aa71675b6ba69a7635dbaecf Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Wed, 17 May 2023 20:18:43 -0500 Subject: [PATCH] implement missing list template logic and optimize generator function --- .../engine/api/templating/ParsedOpTest.java | 61 ++++++++++++++++--- .../api/templating/ParsedTemplateList.java | 54 +++++++++++----- 2 files changed, 91 insertions(+), 24 deletions(-) diff --git a/adapters-api/src/test/java/io/nosqlbench/engine/api/templating/ParsedOpTest.java b/adapters-api/src/test/java/io/nosqlbench/engine/api/templating/ParsedOpTest.java index fab544e8c..bd7f5591c 100644 --- a/adapters-api/src/test/java/io/nosqlbench/engine/api/templating/ParsedOpTest.java +++ b/adapters-api/src/test/java/io/nosqlbench/engine/api/templating/ParsedOpTest.java @@ -77,11 +77,11 @@ public class ParsedOpTest { final OpTemplate opTemplate = stmtsDocs.getOps().get(0); final ParsedOp parsedOp = new ParsedOp(opTemplate, cfg, List.of(), NBLabeledElement.forMap(Map.of())); - assertThat(parsedOp.getAsFunctionOr("d1","invalid").apply(1L)).isEqualTo("one"); - assertThat(parsedOp.getAsFunctionOr("s1","invalid").apply(1L)).isEqualTo("static-one"); - assertThat(parsedOp.getAsFunctionOr("ps1","invalid").apply(1L)).isEqualTo("param-one"); - assertThat(parsedOp.getAsFunctionOr("puppy","invalid").apply(1L)).isEqualTo("dog"); - assertThat(parsedOp.getAsFunctionOr("surname","invalid").apply(1L)).isEqualTo("yes"); + assertThat(parsedOp.getAsFunctionOr("d1", "invalid").apply(1L)).isEqualTo("one"); + assertThat(parsedOp.getAsFunctionOr("s1", "invalid").apply(1L)).isEqualTo("static-one"); + assertThat(parsedOp.getAsFunctionOr("ps1", "invalid").apply(1L)).isEqualTo("param-one"); + assertThat(parsedOp.getAsFunctionOr("puppy", "invalid").apply(1L)).isEqualTo("dog"); + assertThat(parsedOp.getAsFunctionOr("surname", "invalid").apply(1L)).isEqualTo("yes"); } @@ -101,7 +101,7 @@ public class ParsedOpTest { "field3-template", "pre-{dyna1}-post", "field4-map-template", Map.of( "subfield1-object", "{{Identity(); ToString()}}" - ),"field5-map-literal", Map.of( + ), "field5-map-literal", Map.of( "subfield2-literal", "LiteralValue" ) ), @@ -119,8 +119,8 @@ public class ParsedOpTest { final LongFunction f1 = parsedOp.getAsRequiredFunction("field1-literal"); final LongFunction f2 = parsedOp.getAsRequiredFunction("field2-object"); final LongFunction f3 = parsedOp.getAsRequiredFunction("field3-template"); - final LongFunction f4 = parsedOp.getAsRequiredFunction("field4-map-template",Map.class); - final LongFunction f5 = parsedOp.getAsRequiredFunction("field5-map-literal",Map.class); + final LongFunction f4 = parsedOp.getAsRequiredFunction("field4-map-template", Map.class); + final LongFunction f5 = parsedOp.getAsRequiredFunction("field5-map-literal", Map.class); assertThat(f1.apply(1)).isNotNull(); assertThat(f2.apply(2)).isNotNull(); assertThat(f3.apply(3)).isNotNull(); @@ -159,5 +159,50 @@ public class ParsedOpTest { assertThat(objects).isEqualTo(new Object[]{"three", "three", 3L, 3L}); } + @Test + public void testLayeredListBinder() { + ParsedOp pc = new ParsedOp( + new OpData().applyFields( + Map.of( + "op", Map.of( + "alist", List.of( + List.of( + "item1", + "item2-{dyna1}" + ), + Map.of( + "akey", "avalue", + "akey2", "a {dyna1} value2" + ) + ) + ), + "bindings", Map.of( + "dyna1", "NumberNameToString()" + ) + ) + ), + ConfigModel.of(ParsedOpTest.class) + .add(Param.defaultTo("testcfg", "testval")) + .asReadOnly() + .apply(Map.of()), + List.of(), + NBLabeledElement.forMap(Map.of()) + ); + + Map result = pc.getTemplateMap().apply(1); + assertThat(result).isEqualTo( + Map.of( + "alist", List.of( + List.of("item1", "item2-one"), + Map.of( + "akey", "avalue", + "akey2", "a one value2" + ) + ) + ) + ); + + } + } diff --git a/virtdata-api/src/main/java/io/nosqlbench/engine/api/templating/ParsedTemplateList.java b/virtdata-api/src/main/java/io/nosqlbench/engine/api/templating/ParsedTemplateList.java index 3eafba7cd..d25f56f13 100644 --- a/virtdata-api/src/main/java/io/nosqlbench/engine/api/templating/ParsedTemplateList.java +++ b/virtdata-api/src/main/java/io/nosqlbench/engine/api/templating/ParsedTemplateList.java @@ -19,36 +19,58 @@ package io.nosqlbench.engine.api.templating; import io.nosqlbench.virtdata.core.templates.CapturePoint; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.function.LongFunction; public class ParsedTemplateList implements LongFunction> { - private final List protolist = new ArrayList<>(); + private final Object[] protolist; private final int[] dynamic_idx; private final LongFunction[] functions; private final List captures = new ArrayList<>(); - public ParsedTemplateList(List sublist, Map bindings, List> cfgsources) { + public ParsedTemplateList(List list, Map bindings, List> cfgsources) { List> funcs = new ArrayList<>(); List dindexes = new ArrayList<>(); + protolist = new Object[list.size()]; - for (int i = 0; i < sublist.size(); i++) { - Object item = sublist.get(i); + for (int i = 0; i < list.size(); i++) { + Object item = list.get(i); Templatizer.Result result = Templatizer.make(bindings, item, null, cfgsources); this.captures.addAll(result.getCaptures()); - switch (result.getType()) { - case literal: - protolist.add(result.getValue()); - break; - case bindref: - case concat: - protolist.add(null); + + if (item instanceof String string) { + switch (result.getType()) { + case literal: + protolist[i]=string; + break; + case bindref: + case concat: + funcs.add(result.getFunction()); + dindexes.add(i); + } + } else if (item instanceof List sublist) { + ParsedTemplateList listTemplate = new ParsedTemplateList(sublist, bindings, cfgsources); + if (listTemplate.isStatic()) { + protolist[i]=sublist; + } else { funcs.add(result.getFunction()); dindexes.add(i); - break; + } + } else if (item instanceof Map submap) { + ParsedTemplateMap mapTemplate = new ParsedTemplateMap("anonymous", submap, bindings, cfgsources); + if (mapTemplate.isStatic()) { + protolist[i]=submap; + } else { + funcs.add(result.getFunction()); + dindexes.add(i); + } + } else { + protolist[i]=item; } + } this.dynamic_idx = dindexes.stream().mapToInt(Integer::intValue).toArray(); this.functions = funcs.toArray(new LongFunction[0]); @@ -57,12 +79,12 @@ public class ParsedTemplateList implements LongFunction> { @Override public List apply(long value) { - List list = new ArrayList<>(protolist); + Object[] resultAry=new Object[protolist.length]; + System.arraycopy(protolist,0,resultAry,0,protolist.length); for (int i = 0; i < dynamic_idx.length; i++) { - Object obj = functions[i].apply(value); - list.set(dynamic_idx[i], obj); + resultAry[dynamic_idx[i]]=functions[i].apply(value); } - return list; + return Arrays.asList(resultAry); } public boolean isStatic() {