diff --git a/docs/hop-user-manual/modules/ROOT/pages/pipeline/transforms/sortedmerge.adoc b/docs/hop-user-manual/modules/ROOT/pages/pipeline/transforms/sortedmerge.adoc index f0ab958af4b..6d3995d4089 100644 --- a/docs/hop-user-manual/modules/ROOT/pages/pipeline/transforms/sortedmerge.adoc +++ b/docs/hop-user-manual/modules/ROOT/pages/pipeline/transforms/sortedmerge.adoc @@ -25,6 +25,8 @@ under the License. The Sorted Merge transform merges rows coming from multiple input transforms providing these rows are sorted themselves on the given key fields. +Every input must be sorted on the key fields in the direction set for each field in the Fields table. The transform merges in that direction, even when a transform before it sorted the rows the other way. When a row of an input sorts before the previous row of the same input, the transform stops with an error naming the input and the two rows, rather than merging the rows in the wrong place. Verify pipeline warns when a previous transform, such as Sort rows, sorts a key field descending while the merge sorts it ascending. + == Options [options="header"] diff --git a/integration-tests/transforms/0129-sorted-merge-descending.hpl b/integration-tests/transforms/0129-sorted-merge-descending.hpl new file mode 100644 index 00000000000..efbabfe6808 --- /dev/null +++ b/integration-tests/transforms/0129-sorted-merge-descending.hpl @@ -0,0 +1,441 @@ + + + + + 0129-sorted-merge-descending + Y + Sorted merge on a descending field merges descending, whether or not a Sort rows before it marked the field descending (#9528) + + + Normal + + + N + 1000 + 100 + - + 2026/11/16 12:00:00.000 + - + 2026/11/16 12:00:00.000 + + + + + + descending a + merge descending input + Y + + + descending b + merge descending input + Y + + + merge descending input + number descending input + Y + + + number descending input + validate descending input + Y + + + unsorted c + sort c descending + Y + + + unsorted d + sort d descending + Y + + + sort c descending + merge sorted input + Y + + + sort d descending + merge sorted input + Y + + + merge sorted input + number sorted input + Y + + + number sorted input + validate sorted input + Y + + + + descending a + DataGrid + + Y + + 1 + + none + + + + + N + -1 + id + -1 + Integer + + + + + 5 + + + 3 + + + 1 + + + + + 96 + 64 + + + + descending b + DataGrid + + Y + + 1 + + none + + + + + N + -1 + id + -1 + Integer + + + + + 6 + + + 4 + + + 2 + + + + + 96 + 160 + + + + merge descending input + SortedMerge + + Y + + 1 + + none + + + + + id + N + + + + + 288 + 112 + + + + number descending input + Sequence + + Y + + 1 + + none + + + 1 + 999999999 + SEQ_ + SEQ_DESCENDING_INPUT + 1 + Y + N + nr + + + 480 + 112 + + + + validate descending input + Dummy + + Y + + 1 + + none + + + + + 672 + 112 + + + + unsorted c + DataGrid + + Y + + 1 + + none + + + + + N + -1 + id + -1 + Integer + + + + + 1 + + + 5 + + + 3 + + + + + 96 + 288 + + + + unsorted d + DataGrid + + Y + + 1 + + none + + + + + N + -1 + id + -1 + Integer + + + + + 4 + + + 2 + + + 6 + + + + + 96 + 384 + + + + sort c descending + SortRows + + Y + + 1 + + none + + + ${java.io.tmpdir} + out + 1000000 + + N + + N + + + id + N + Y + N + 0 + N + + + + + 288 + 288 + + + + sort d descending + SortRows + + Y + + 1 + + none + + + ${java.io.tmpdir} + out + 1000000 + + N + + N + + + id + N + Y + N + 0 + N + + + + + 288 + 384 + + + + merge sorted input + SortedMerge + + Y + + 1 + + none + + + + + id + N + + + + + 480 + 336 + + + + number sorted input + Sequence + + Y + + 1 + + none + + + 1 + 999999999 + SEQ_ + SEQ_SORTED_INPUT + 1 + Y + N + nr + + + 672 + 336 + + + + validate sorted input + Dummy + + Y + + 1 + + none + + + + + 864 + 336 + + + + + + diff --git a/integration-tests/transforms/datasets/golden-0129-sorted-merge-descending.csv b/integration-tests/transforms/datasets/golden-0129-sorted-merge-descending.csv new file mode 100644 index 00000000000..154dc2e7fe8 --- /dev/null +++ b/integration-tests/transforms/datasets/golden-0129-sorted-merge-descending.csv @@ -0,0 +1,7 @@ +nr,id +1,6 +2,5 +3,4 +4,3 +5,2 +6,1 diff --git a/integration-tests/transforms/main-0129-sorted-merge-descending.hwf b/integration-tests/transforms/main-0129-sorted-merge-descending.hwf new file mode 100644 index 00000000000..b1d5872634d --- /dev/null +++ b/integration-tests/transforms/main-0129-sorted-merge-descending.hwf @@ -0,0 +1,80 @@ + + + + main-0129-sorted-merge-descending + Y + + + + - + 2026/06/03 20:00:00.000 + - + 2026/06/03 20:00:00.000 + + + + + Start + + SPECIAL + + 1 + N + 12 + 60 + 0 + 0 + N + 0 + 1 + N + 96 + 64 + + + + 0129-sorted-merge-descending UNIT + + RunPipelineTests + + + + 0129-sorted-merge-descending UNIT + + + N + 288 + 64 + + + + + + Start + 0129-sorted-merge-descending UNIT + Y + Y + Y + + + + + + diff --git a/integration-tests/transforms/metadata/dataset/golden-0129-sorted-merge-descending.json b/integration-tests/transforms/metadata/dataset/golden-0129-sorted-merge-descending.json new file mode 100644 index 00000000000..6f55e8fe66d --- /dev/null +++ b/integration-tests/transforms/metadata/dataset/golden-0129-sorted-merge-descending.json @@ -0,0 +1,24 @@ +{ + "base_filename": "golden-0129-sorted-merge-descending.csv", + "name": "golden-0129-sorted-merge-descending", + "description": "Six ids merged descending, numbered in the order they come out", + "dataset_fields": [ + { + "field_comment": "", + "field_length": -1, + "field_type": 5, + "field_precision": -1, + "field_name": "nr", + "field_format": "" + }, + { + "field_comment": "", + "field_length": -1, + "field_type": 5, + "field_precision": -1, + "field_name": "id", + "field_format": "" + } + ], + "folder_name": "" +} diff --git a/integration-tests/transforms/metadata/unit-test/0129-sorted-merge-descending UNIT.json b/integration-tests/transforms/metadata/unit-test/0129-sorted-merge-descending UNIT.json new file mode 100644 index 00000000000..72311b93fbb --- /dev/null +++ b/integration-tests/transforms/metadata/unit-test/0129-sorted-merge-descending UNIT.json @@ -0,0 +1,49 @@ +{ + "database_replacements": [], + "autoOpening": true, + "description": "", + "persist_filename": "", + "test_type": "UNIT_TEST", + "variableValues": [], + "basePath": "${HOP_UNIT_TESTS_FOLDER}", + "golden_data_sets": [ + { + "field_mappings": [ + { + "transform_field": "nr", + "data_set_field": "nr" + }, + { + "transform_field": "id", + "data_set_field": "id" + } + ], + "field_order": [ + "nr" + ], + "data_set_name": "golden-0129-sorted-merge-descending", + "transform_name": "validate descending input" + }, + { + "field_mappings": [ + { + "transform_field": "nr", + "data_set_field": "nr" + }, + { + "transform_field": "id", + "data_set_field": "id" + } + ], + "field_order": [ + "nr" + ], + "data_set_name": "golden-0129-sorted-merge-descending", + "transform_name": "validate sorted input" + } + ], + "input_data_sets": [], + "name": "0129-sorted-merge-descending UNIT", + "trans_test_tweaks": [], + "pipeline_filename": "./0129-sorted-merge-descending.hpl" +} diff --git a/plugins/transforms/sortedmerge/src/main/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMerge.java b/plugins/transforms/sortedmerge/src/main/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMerge.java index e149aa26ee5..d1637fe3754 100644 --- a/plugins/transforms/sortedmerge/src/main/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMerge.java +++ b/plugins/transforms/sortedmerge/src/main/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMerge.java @@ -20,11 +20,13 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; +import org.apache.hop.core.Const; import org.apache.hop.core.IRowSet; import org.apache.hop.core.exception.HopException; import org.apache.hop.core.exception.HopRuntimeException; import org.apache.hop.core.exception.HopTransformException; import org.apache.hop.core.exception.HopValueException; +import org.apache.hop.core.row.IValueMeta; import org.apache.hop.i18n.BaseMessages; import org.apache.hop.pipeline.Pipeline; import org.apache.hop.pipeline.PipelineMeta; @@ -82,6 +84,8 @@ private synchronized Object[] getRowSorted() throws HopException { // Add it to the sorted buffer in the right position... // if (extraRow != null) { + verifyMergeOrder(smallestRow, extraRow); + // Add this one to the sortedBuffer // RowSetRow add = @@ -160,10 +164,12 @@ private void getRowSortedFirstCall() throws HopTransformException { } } + // Compare with the metadata that carries the merge settings: the metadata of the rows only + // says how they are sorted when the transform before this one says so data.comparator = (o1, o2) -> { try { - return o1.getRowMeta().compare(o1.getRowData(), o2.getRowData(), data.fieldIndices); + return data.rowMeta.compare(o1.getRowData(), o2.getRowData(), data.fieldIndices); } catch (HopValueException e) { throw new HopRuntimeException( BaseMessages.getString(PKG, "SortedMerge.Exception.ErrorComparingRows"), e); @@ -176,6 +182,87 @@ private void getRowSortedFirstCall() throws HopTransformException { } } + /** + * Every input must give its rows in the merge order. A row that sorts before the previous row of + * the same input would be merged in the wrong place, without an error, so the merge stops there. + * + * @param previous the previous row of the input, the row just merged + * @param row the next row of that input + */ + private void verifyMergeOrder(RowSetRow previous, Object[] row) throws HopTransformException { + int order; + try { + order = data.rowMeta.compare(row, previous.getRowData(), data.fieldIndices); + } catch (HopValueException e) { + throw new HopTransformException( + BaseMessages.getString(PKG, "SortedMerge.Exception.ErrorComparingRows"), e); + } + if (order >= 0) { + return; + } + + IRowSet rowSet = previous.getRowSet(); + StringBuilder mergeOrder = new StringBuilder(); + StringBuilder hint = new StringBuilder(); + for (int f = 0; f < data.fieldIndices.length; f++) { + SortedMergeMeta.MergeField mergeField = meta.getMergeFields().get(f); + if (f > 0) { + mergeOrder.append(", "); + } + mergeOrder + .append(mergeField.getFieldName()) + .append(' ') + .append( + BaseMessages.getString( + PKG, + mergeField.isAscending() + ? "SortedMerge.Exception.Ascending" + : "SortedMerge.Exception.Descending")); + + // The transform before this one can say the rows are sorted the other way + IValueMeta declared = + rowSet.getRowMeta() == null + ? null + : rowSet.getRowMeta().searchValueMeta(mergeField.getFieldName()); + if (mergeField.isAscending() && declared != null && declared.isSortedDescending()) { + hint.append(Const.CR) + .append( + BaseMessages.getString( + PKG, + "SortedMerge.Exception.InputSortedDescending", + rowSet.getOriginTransformName(), + mergeField.getFieldName())); + } + } + throw new HopTransformException( + BaseMessages.getString( + PKG, + "SortedMerge.Exception.InputNotInMergeOrder", + rowSet.getOriginTransformName(), + mergeValues(row), + mergeValues(previous.getRowData()), + mergeOrder.toString()) + + hint); + } + + /** The values of the merge fields of a row, for a message. */ + private String mergeValues(Object[] row) { + StringBuilder values = new StringBuilder(); + for (int index : data.fieldIndices) { + IValueMeta valueMeta = data.rowMeta.getValueMeta(index); + if (!values.isEmpty()) { + values.append(", "); + } + values.append(valueMeta.getName()).append('='); + try { + values.append(valueMeta.getString(row[index])); + } catch (HopValueException e) { + values.append(row[index]); + } + } + return values.toString(); + } + @Override public boolean processRow() throws HopException { // get row, sorted diff --git a/plugins/transforms/sortedmerge/src/main/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeMeta.java b/plugins/transforms/sortedmerge/src/main/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeMeta.java index 14db79b7c0f..172bed11bd3 100644 --- a/plugins/transforms/sortedmerge/src/main/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeMeta.java +++ b/plugins/transforms/sortedmerge/src/main/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeMeta.java @@ -129,6 +129,7 @@ public void check( BaseMessages.getString(PKG, "SortedMergeMeta.CheckResult.AllSortKeysFound"), transformMeta); remarks.add(cr); + checkInputSortOrder(remarks, pipelineMeta, transformMeta, variables); } else { cr = new CheckResult( @@ -165,6 +166,43 @@ public void check( } } + /** + * Warns about an input that says its rows are sorted descending on a field the merge sorts + * ascending: the merge would stop at its first row out of order. + */ + private void checkInputSortOrder( + List remarks, + PipelineMeta pipelineMeta, + TransformMeta transformMeta, + IVariables variables) { + if (pipelineMeta == null) { + return; + } + for (TransformMeta previous : pipelineMeta.findPreviousTransforms(transformMeta)) { + IRowMeta fields; + try { + fields = pipelineMeta.getTransformFields(variables, previous); + } catch (HopTransformException e) { + // The missing fields are reported above + continue; + } + for (MergeField field : mergeFields) { + IValueMeta valueMeta = fields.searchValueMeta(field.getFieldName()); + if (field.isAscending() && valueMeta != null && valueMeta.isSortedDescending()) { + remarks.add( + new CheckResult( + ICheckResult.TYPE_RESULT_WARNING, + BaseMessages.getString( + PKG, + "SortedMergeMeta.CheckResult.InputSortedDescending", + previous.getName(), + field.getFieldName()), + transformMeta)); + } + } + } + } + @Override public PipelineType[] getSupportedPipelineTypes() { return new PipelineType[] { diff --git a/plugins/transforms/sortedmerge/src/main/resources/org/apache/hop/pipeline/transforms/sortedmerge/messages/messages_en_US.properties b/plugins/transforms/sortedmerge/src/main/resources/org/apache/hop/pipeline/transforms/sortedmerge/messages/messages_en_US.properties index 7dc41727711..3d0e48adc9b 100644 --- a/plugins/transforms/sortedmerge/src/main/resources/org/apache/hop/pipeline/transforms/sortedmerge/messages/messages_en_US.properties +++ b/plugins/transforms/sortedmerge/src/main/resources/org/apache/hop/pipeline/transforms/sortedmerge/messages/messages_en_US.properties @@ -20,6 +20,10 @@ SortedMerge.Injection.ASCENDING=Specify if the fields are ascending or not (Y/N) SortedMerge.Injection.FIELD_NAME=The name of the input field used for sorting. SortedMerge.Injection.FIELDS=The names of the input fields that are being merged. SortedMerge.Exception.ErrorComparingRows=Error comparing rows during sorted merge +SortedMerge.Exception.Ascending=ascending +SortedMerge.Exception.Descending=descending +SortedMerge.Exception.InputNotInMergeOrder=The rows from {0} are not in the merge order ({3}): {1} comes after {2}. Every input of a Sorted merge must be sorted on the merge fields, in the order set for each field. +SortedMerge.Exception.InputSortedDescending={0} gives its rows sorted descending on {1}: set Ascending to N for {1}. SortedMerge.Log.LineNumber=Linenr SortedMerge.Name=Sorted merge SortedMergeDialog.Ascending.Column=Ascending @@ -37,6 +41,7 @@ SortedMergeMeta.CheckResult.AllSortKeysFound=All sort keys are found in the inpu SortedMergeMeta.CheckResult.ExpectedInputError=No input received from other transforms! SortedMergeMeta.CheckResult.ExpectedInputOk=Transform is receiving info from other transforms. SortedMergeMeta.CheckResult.FieldsReceived=Transform is connected to previous one, receiving {0} fields +SortedMergeMeta.CheckResult.InputSortedDescending={0} gives its rows sorted descending on {1}, but the merge sorts {1} ascending: set Ascending to N for {1}. SortedMergeMeta.CheckResult.NoFields=Couldn''t find fields from previous transforms, check the hops...! SortedMergeMeta.CheckResult.NoSortKeysEntered=No sort keys are entered. SortedMergeMeta.CheckResult.SortKeysNotFound=Sort keys that were not found in input stream:\n\n{0} diff --git a/plugins/transforms/sortedmerge/src/test/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeMetaTest.java b/plugins/transforms/sortedmerge/src/test/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeMetaTest.java index 125640025c7..ab4c76b4a8b 100644 --- a/plugins/transforms/sortedmerge/src/test/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeMetaTest.java +++ b/plugins/transforms/sortedmerge/src/test/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeMetaTest.java @@ -20,7 +20,10 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; import java.util.ArrayList; import java.util.List; @@ -29,6 +32,7 @@ import org.apache.hop.core.row.IRowMeta; import org.apache.hop.core.row.RowMeta; import org.apache.hop.core.row.value.ValueMetaString; +import org.apache.hop.core.variables.IVariables; import org.apache.hop.core.variables.Variables; import org.apache.hop.junit.rules.RestoreHopEngineEnvironmentExtension; import org.apache.hop.pipeline.PipelineMeta; @@ -170,6 +174,43 @@ private static List check(SortedMergeMeta meta, IRowMeta prev, Str return remarks; } + /** An input sorted descending on a field the merge sorts ascending: Verify pipeline warns. */ + @Test + void checkWarnsWhenAnInputIsSortedDescendingOnAnAscendingMergeField() throws Exception { + SortedMergeMeta meta = new SortedMergeMeta(); + meta.getMergeFields().add(new MergeField("key", true)); + TransformMeta transformMeta = mock(TransformMeta.class); + TransformMeta sort = new TransformMeta(); + sort.setName("Sort descending"); + IRowMeta sortedDescending = stringMeta("key"); + sortedDescending.getValueMeta(0).setSortedDescending(true); + PipelineMeta pipelineMeta = mock(PipelineMeta.class); + when(pipelineMeta.findPreviousTransforms(transformMeta)).thenReturn(List.of(sort)); + when(pipelineMeta.getTransformFields(any(IVariables.class), eq(sort))) + .thenReturn(sortedDescending); + + List remarks = new ArrayList<>(); + meta.check( + remarks, + pipelineMeta, + transformMeta, + stringMeta("key"), + new String[] {"Sort descending"}, + new String[0], + null, + new Variables(), + null); + + assertTrue( + remarks.stream() + .anyMatch( + r -> + r.getType() == ICheckResult.TYPE_RESULT_WARNING + && r.getText().contains("Sort descending") + && r.getText().contains("set Ascending to N for key")), + remarks.toString()); + } + private static IRowMeta stringMeta(String... names) { RowMeta rowMeta = new RowMeta(); for (String name : names) { diff --git a/plugins/transforms/sortedmerge/src/test/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeTest.java b/plugins/transforms/sortedmerge/src/test/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeTest.java index 54f489da249..b5b4a50202c 100644 --- a/plugins/transforms/sortedmerge/src/test/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeTest.java +++ b/plugins/transforms/sortedmerge/src/test/java/org/apache/hop/pipeline/transforms/sortedmerge/SortedMergeTest.java @@ -23,6 +23,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; @@ -109,6 +110,69 @@ void processRowReturnsFalseWhenAllStreamsAreEmpty() throws Exception { assertTrue(drain(transform.getOutputRowSets().getFirst()).isEmpty()); } + /** Rows sorted descending, without a transform before saying so, merge descending. */ + @Test + void processRowMergesDescendingStreams() throws Exception { + SortedMerge transform = + createTransform( + descendingKey(), + stringKeyMeta(), + new Object[][] {{"echo"}, {"charlie"}, {"alpha"}}, + new Object[][] {{"foxtrot"}, {"delta"}, {"bravo"}}); + + assertEquals( + List.of("foxtrot", "echo", "delta", "charlie", "bravo", "alpha"), + keys(runToCompletion(transform))); + } + + /** Rows a Sort rows marked descending merge descending when the merge says so too. */ + @Test + void processRowMergesStreamsMarkedDescending() throws Exception { + IRowMeta rowMeta = stringKeyMeta(); + rowMeta.getValueMeta(0).setSortedDescending(true); + SortedMerge transform = + createTransform( + descendingKey(), + rowMeta, + new Object[][] {{"echo"}, {"charlie"}, {"alpha"}}, + new Object[][] {{"foxtrot"}, {"delta"}, {"bravo"}}); + + assertEquals( + List.of("foxtrot", "echo", "delta", "charlie", "bravo", "alpha"), + keys(runToCompletion(transform))); + } + + /** An input that is not in the merge order would be merged wrongly: the merge stops there. */ + @Test + void processRowFailsWhenAnInputIsNotInTheMergeOrder() { + SortedMerge transform = + createTransform( + stringKeyMeta(), new Object[][] {{"bravo"}, {"alpha"}}, new Object[][] {{"charlie"}}); + + HopTransformException thrown = + assertThrows(HopTransformException.class, () -> runToCompletion(transform)); + assertTrue( + thrown.getMessage().contains("key=alpha comes after key=bravo"), thrown.getMessage()); + assertFalse(thrown.getMessage().contains("set Ascending to N"), thrown.getMessage()); + } + + /** + * Rows a Sort rows marked descending, merged ascending: the setting decides, and the error says + * what to change. + */ + @Test + void processRowFailsWithAHintWhenAnInputIsMarkedDescending() { + IRowMeta rowMeta = stringKeyMeta(); + rowMeta.getValueMeta(0).setSortedDescending(true); + SortedMerge transform = + createTransform( + rowMeta, new Object[][] {{"bravo"}, {"alpha"}}, new Object[][] {{"charlie"}}); + + HopTransformException thrown = + assertThrows(HopTransformException.class, () -> runToCompletion(transform)); + assertTrue(thrown.getMessage().contains("set Ascending to N for key"), thrown.getMessage()); + } + @Test void processRowFailsWhenSortKeyIsMissing() { IRowMeta rowMeta = stringKeyMeta(); @@ -128,6 +192,8 @@ void processRowFailsWhenCompareThrowsHopValueException() throws Exception { doThrow(new HopValueException("compare failed")) .when(rowMeta) .compare(any(Object[].class), any(Object[].class), any(int[].class)); + // The merge compares with its own copy of the input's metadata + doReturn(rowMeta).when(rowMeta).clone(); SortedMerge transform = createTransform(rowMeta, new Object[][] {{"left"}}, new Object[][] {{"right"}}); @@ -179,6 +245,12 @@ private SortedMerge createTransform( return transform; } + private static SortedMergeMeta descendingKey() { + SortedMergeMeta meta = new SortedMergeMeta(); + meta.getMergeFields().add(new SortedMergeMeta.MergeField("key", false)); + return meta; + } + private static IRowMeta stringKeyMeta() { RowMeta rowMeta = new RowMeta(); rowMeta.addValueMeta(new ValueMetaString("key"));