This is an automated email from the ASF dual-hosted git repository.
hansva pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/hop.git
The following commit(s) were added to refs/heads/main by this push:
new 9cd80b2eb7 Fix regression and workarounds that were only in the
validator, fixes #8125 (#8126)
9cd80b2eb7 is described below
commit 9cd80b2eb72450e24673547f0569c74d69f697e6
Author: Hans Van Akelyen <[email protected]>
AuthorDate: Thu Aug 27 15:30:14 2026 +0200
Fix regression and workarounds that were only in the validator, fixes #8125
(#8126)
---
.../ROOT/pages/pipeline/transforms/validator.adoc | 5 +-
.../hop/pipeline/transform/BaseTransform.java | 21 ++----
.../hop/pipeline/transform/BaseTransformTest.java | 52 +++++++++++++++
.../transforms/databaselookup/DatabaseLookup.java | 49 +++++++++++++-
.../databaselookup/DatabaseLookupUTest.java | 77 ++++++++++++++++++++++
.../pipeline/transforms/validator/Validator.java | 10 ---
.../transforms/validator/ValidatorDialog.java | 19 +-----
.../transforms/validator/ValidatorMeta.java | 10 ---
.../validator/messages/messages_en_US.properties | 3 -
.../validator/messages/messages_pt_BR.properties | 3 -
.../transforms/validator/ValidatorTest.java | 14 +---
11 files changed, 185 insertions(+), 78 deletions(-)
diff --git
a/docs/hop-user-manual/modules/ROOT/pages/pipeline/transforms/validator.adoc
b/docs/hop-user-manual/modules/ROOT/pages/pipeline/transforms/validator.adoc
index d7d8fecd88..6d9de8a3b9 100644
--- a/docs/hop-user-manual/modules/ROOT/pages/pipeline/transforms/validator.adoc
+++ b/docs/hop-user-manual/modules/ROOT/pages/pipeline/transforms/validator.adoc
@@ -61,10 +61,7 @@ Once you select a validation on the left hand side of the
dialog you can specify
|If this is enabled error codes and descriptions are concatenated with the
specified separator string.
|Do not log failed validation data
-|When enabled, the failed field and row values are left out of the validation
error messages and shown as `?` instead. The error messages themselves are
still logged and error rows are still sent to the error handling hop.
-
-|Do not log a line for every rejected row
-|When enabled, the transform no longer writes an error line to the log for
every row it rejects. Error rows are still sent to the error handling hop. On
streams where a large share of the rows is rejected, writing that log line
costs considerably more than the validation itself, so enabling this option can
speed up such pipelines by an order of magnitude.
+|When enabled, the failed field and row values are left out of the validation
error messages and shown as `?` instead. Use this to keep sensitive values out
of the log and out of the error stream. Error rows are still sent to the error
handling hop.
|Validation description
|Optionally you can describe what you're testing for here.
diff --git
a/engine/src/main/java/org/apache/hop/pipeline/transform/BaseTransform.java
b/engine/src/main/java/org/apache/hop/pipeline/transform/BaseTransform.java
index 541aba2300..4811264789 100644
--- a/engine/src/main/java/org/apache/hop/pipeline/transform/BaseTransform.java
+++ b/engine/src/main/java/org/apache/hop/pipeline/transform/BaseTransform.java
@@ -1540,10 +1540,12 @@ public class BaseTransform<Meta extends ITransformMeta,
Data extends ITransformD
break;
}
}
+ // Nothing is logged here on purpose. The row was handled: it went down
the error handling
+ // hop that is by definition connected in this branch, carrying the
description as a field,
+ // so anyone who wants it in the log routes that hop to a "Write to log"
transform. An error
+ // hop is a hop, and the engine does not log the rows travelling down an
ordinary one either.
+ // The unhandled case below is the one that is genuinely an error.
incrementLinesRejected();
- if (isLoggingErrorDescriptions() && !Utils.isEmpty(errorDescriptions)) {
- logError(errorDescriptions);
- }
} else if (transformErrorMeta.isEnabled()) {
String name =
Objects.nonNull(transformErrorMeta.getTargetTransform())
@@ -2741,19 +2743,6 @@ public class BaseTransform<Meta extends ITransformMeta,
Data extends ITransformD
log.logRowlevel(message, arguments);
}
- /**
- * Whether rejected-row error descriptions should be written to the log.
- *
- * <p>Transforms that can produce a very large number of
validation/rejection errors may override
- * this to reduce log volume. Error rows are still sent to the error
handling hop when configured.
- *
- * @return true when error descriptions should be logged (default)
- * @since 2.19.0
- */
- protected boolean isLoggingErrorDescriptions() {
- return true;
- }
-
/**
* Log error.
*
diff --git
a/engine/src/test/java/org/apache/hop/pipeline/transform/BaseTransformTest.java
b/engine/src/test/java/org/apache/hop/pipeline/transform/BaseTransformTest.java
index 0a1a19a057..9945778eb0 100644
---
a/engine/src/test/java/org/apache/hop/pipeline/transform/BaseTransformTest.java
+++
b/engine/src/test/java/org/apache/hop/pipeline/transform/BaseTransformTest.java
@@ -26,6 +26,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
@@ -37,6 +38,7 @@ import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
@@ -362,6 +364,56 @@ class BaseTransformTest {
verify(base).stopAll();
assertTrue(base.getErrors() > 0);
+ // the rejected row went nowhere, so this one really is an error: it has
to stay visible
+ verify(mockHelper.iLogChannel).logError(anyString());
+ }
+
+ /**
+ * A row that reaches the error handling hop was handled, not lost, and its
description travels
+ * with it as a field on the error stream. Logging that description wrote
one line to the log for
+ * every rejected row of a pipeline that was doing exactly what it was built
to do (issue #8125),
+ * so the engine writes nothing here at any level.
+ */
+ @Test
+ void putErrorLogsNothingWhenTheRowReachesTheErrorHop() throws HopException {
+ TransformMeta targetMeta = mock(TransformMeta.class);
+ when(targetMeta.getName()).thenReturn("Error handler");
+ TransformErrorMeta errorMeta = new
TransformErrorMeta(mockHelper.transformMeta, targetMeta);
+ errorMeta.setEnabled(true);
+ errorMeta.setErrorDescriptionsValueName("errorDescription");
+
when(mockHelper.transformMeta.getTransformErrorMeta()).thenReturn(errorMeta);
+ when(mockHelper.transformMeta.isDoingErrorHandling()).thenReturn(true);
+
+ BaseTransform<ITransformMeta, ITransformData> base =
+ spy(
+ new BaseTransform<>(
+ mockHelper.transformMeta,
+ mockHelper.iTransformMeta,
+ mockHelper.iTransformData,
+ 0,
+ mockHelper.pipelineMeta,
+ mockHelper.pipeline));
+
+ IRowSet errorRowSet = new QueueRowSet();
+ errorRowSet.setThreadNameFromToCopy("BASE TRANSFORM", 0, "Error handler",
0);
+ base.setOutputRowSets(new ArrayList<>(List.of(errorRowSet)));
+ base.identifyErrorOutput();
+
+ IRowMeta iRowMeta = new RowMeta();
+ iRowMeta.addValueMeta(new ValueMetaString("name"));
+ base.putError(iRowMeta, new Object[] {"Bob"}, 1L, "No lookup found", null,
"DBL001");
+
+ // the error row still carries the description down the error hop
+ Object[] rejected = errorRowSet.getRow();
+ assertNotNull(rejected);
+ assertEquals("No lookup found", rejected[1]);
+ assertEquals(1L, base.getLinesRejected());
+
+ // ... and the pipeline neither fails nor writes a log line over it, at
any level
+ assertEquals(0L, base.getErrors());
+ verify(base, never()).stopAll();
+ verify(mockHelper.iLogChannel, never()).logError(anyString());
+ verify(mockHelper.iLogChannel, never()).logDebug(anyString());
}
@Test
diff --git
a/plugins/transforms/databaselookup/src/main/java/org/apache/hop/pipeline/transforms/databaselookup/DatabaseLookup.java
b/plugins/transforms/databaselookup/src/main/java/org/apache/hop/pipeline/transforms/databaselookup/DatabaseLookup.java
index 80d1b0044e..f6514ea321 100644
---
a/plugins/transforms/databaselookup/src/main/java/org/apache/hop/pipeline/transforms/databaselookup/DatabaseLookup.java
+++
b/plugins/transforms/databaselookup/src/main/java/org/apache/hop/pipeline/transforms/databaselookup/DatabaseLookup.java
@@ -28,6 +28,7 @@ import org.apache.hop.core.database.DatabaseMeta;
import org.apache.hop.core.exception.HopDatabaseException;
import org.apache.hop.core.exception.HopException;
import org.apache.hop.core.exception.HopTransformException;
+import org.apache.hop.core.exception.HopValueException;
import org.apache.hop.core.row.IRowMeta;
import org.apache.hop.core.row.IValueMeta;
import org.apache.hop.core.row.RowDataUtil;
@@ -139,7 +140,13 @@ public class DatabaseLookup extends
BaseTransform<DatabaseLookupMeta, DatabaseLo
return null;
}
if (getTransformMeta().isDoingErrorHandling()) {
- putError(getInputRowMeta(), row, 1L, "No lookup found", null,
"DBL001");
+ putError(
+ getInputRowMeta(),
+ row,
+ 1L,
+ buildLookupFailureDescription(lookupRow),
+ String.join(", ", data.lookupMeta.getFieldNames()),
+ "DBL001");
// return false else we would still be processed.
return null;
@@ -264,6 +271,46 @@ public class DatabaseLookup extends
BaseTransform<DatabaseLookupMeta, DatabaseLo
}
}
+ /**
+ * Describes a lookup that found nothing. The description ends up both on
the error stream, as the
+ * error description field, and in the log at debug level, so it has to name
the table that was
+ * queried and the key values that missed - a bare "No lookup found"
repeated per row says
+ * nothing. It is deliberately not translated: it is a value on the error
stream that pipelines
+ * filter on, so it has to read the same in every locale.
+ */
+ private String buildLookupFailureDescription(Object[] lookupRow) {
+ StringBuilder description = new StringBuilder("No lookup found");
+
+ String table = resolve(meta.getTableName());
+ if (!Utils.isEmpty(table)) {
+ description.append(" in ");
+ String schema = resolve(meta.getSchemaName());
+ if (!Utils.isEmpty(schema)) {
+ description.append(schema).append('.');
+ }
+ description.append(table);
+ }
+
+ if (!data.lookupMeta.isEmpty()) {
+ description.append(" for ");
+ for (int i = 0; i < data.lookupMeta.size(); i++) {
+ IValueMeta valueMeta = data.lookupMeta.getValueMeta(i);
+ if (i > 0) {
+ description.append(", ");
+ }
+ description.append(valueMeta.getName()).append('=');
+ try {
+ description.append(valueMeta.getString(lookupRow[i]));
+ } catch (HopValueException e) {
+ // a key we cannot render is no reason to fail the row: it is
already being rejected
+ description.append('?');
+ }
+ }
+ }
+
+ return description.toString();
+ }
+
private void initLookupMeta() throws HopException {
// Count the number of values in the lookup as well as the metadata to
send along with it.
//
diff --git
a/plugins/transforms/databaselookup/src/test/java/org/apache/hop/pipeline/transforms/databaselookup/DatabaseLookupUTest.java
b/plugins/transforms/databaselookup/src/test/java/org/apache/hop/pipeline/transforms/databaselookup/DatabaseLookupUTest.java
index 13bf628aa9..6188ec2625 100644
---
a/plugins/transforms/databaselookup/src/test/java/org/apache/hop/pipeline/transforms/databaselookup/DatabaseLookupUTest.java
+++
b/plugins/transforms/databaselookup/src/test/java/org/apache/hop/pipeline/transforms/databaselookup/DatabaseLookupUTest.java
@@ -32,6 +32,7 @@ import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doNothing;
@@ -80,6 +81,7 @@ import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
+import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito;
@@ -576,6 +578,81 @@ class DatabaseLookupUTest {
assertNull(transform.lookupValues(input, new Object[] {1L}));
}
+ /**
+ * The description of a rejected row is a field on the error stream and is
written to the log at
+ * debug level, so a bare "No lookup found" repeated per row carries no
information. It has to
+ * name the table and the key values that missed, and the error-fields
column has to be filled in
+ * rather than left null.
+ */
+ @Test
+ void lookupValues_ErrorDescriptionNamesTheTableAndTheKeysThatMissed() throws
Exception {
+ DatabaseLookupMeta meta = new DatabaseLookupMeta();
+ meta.setCached(false);
+ meta.getLookup().setSchemaName("public");
+ meta.getLookup().setTableName("customers");
+ meta.getLookup().getKeyFields().add(new KeyField("id", "", "=", "ID"));
+ meta.getLookup()
+ .getReturnValues()
+ .add(
+ new ReturnValue(
+ "name",
+ "",
+ "",
+ "String",
+ ValueMetaString.getTrimTypeCode(IValueMeta.TRIM_TYPE_NONE)));
+
+ DatabaseLookupData data = new DatabaseLookupData();
+ Database db = mock(Database.class);
+ when(db.getLookup(anyBoolean())).thenReturn(null);
+
+ DatabaseLookup transform = spyLookup(mockHelper, meta, data, db,
createNoneDbMeta());
+ doReturn(false).when(transform).isRowLevel();
+ when(mockHelper.transformMeta.isDoingErrorHandling()).thenReturn(true);
+ doNothing()
+ .when(transform)
+ .putError(
+ any(IRowMeta.class),
+ any(Object[].class),
+ anyLong(),
+ anyString(),
+ anyString(),
+ anyString());
+
+ RowMeta input = new RowMeta();
+ input.addValueMeta(new ValueMetaInteger("id"));
+ transform.setInputRowMeta(input);
+
+ data.db = db;
+ data.keynrs = new int[] {0};
+ data.keynrs2 = new int[] {-1};
+ data.lookupMeta = new RowMeta();
+ data.lookupMeta.addValueMeta(new ValueMetaInteger("id"));
+ data.returnMeta = new RowMeta();
+ data.returnMeta.addValueMeta(new ValueMetaString("name"));
+ data.outputRowMeta = input.clone();
+ data.outputRowMeta.addValueMeta(new ValueMetaString("name"));
+ data.returnValueTypes = new int[] {IValueMeta.TYPE_STRING};
+ data.nullif = new Object[] {null};
+ data.trimIndexes = new ArrayList<>();
+
+ // the row is rejected, not passed on
+ assertNull(transform.lookupValues(input, new Object[] {1L}));
+
+ ArgumentCaptor<String> description = ArgumentCaptor.forClass(String.class);
+ ArgumentCaptor<String> fieldNames = ArgumentCaptor.forClass(String.class);
+ verify(transform)
+ .putError(
+ any(IRowMeta.class),
+ any(Object[].class),
+ anyLong(),
+ description.capture(),
+ fieldNames.capture(),
+ eq("DBL001"));
+
+ assertEquals("No lookup found in public.customers for id=1",
description.getValue());
+ assertEquals("id", fieldNames.getValue());
+ }
+
@Test
void lookupValues_StoresInCacheOnDbHitWhenCached() throws Exception {
DatabaseLookupMeta meta = new DatabaseLookupMeta();
diff --git
a/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/Validator.java
b/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/Validator.java
index 4d1028375f..5cde229056 100644
---
a/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/Validator.java
+++
b/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/Validator.java
@@ -777,16 +777,6 @@ public class Validator extends
BaseTransform<ValidatorMeta, ValidatorData> imple
return false;
}
- /**
- * The engine writes a log line for every rejected row. On a transform whose
job is to reject rows
- * that log line costs far more than the validation itself, so it can be
switched off while error
- * rows keep flowing to the error handling hop.
- */
- @Override
- protected boolean isLoggingErrorDescriptions() {
- return !meta.isSuppressingErrorLog();
- }
-
/**
* Returns the field value for inclusion in validation messages, or a
placeholder when logging of
* failed data is suppressed.
diff --git
a/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/ValidatorDialog.java
b/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/ValidatorDialog.java
index 57d6b076ce..861318cb15 100644
---
a/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/ValidatorDialog.java
+++
b/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/ValidatorDialog.java
@@ -114,7 +114,6 @@ public class ValidatorDialog extends BaseTransformDialog {
private Button wConcatErrors;
private TextVar wConcatSeparator;
private Button wSuppressLogFailedData;
- private Button wSuppressErrorLog;
public ValidatorDialog(
Shell parent, IVariables variables, ValidatorMeta transformMeta,
PipelineMeta pipelineMeta) {
@@ -223,20 +222,6 @@ public class ValidatorDialog extends BaseTransformDialog {
fdSuppressLogFailedData.top = new FormAttachment(wConcatErrors, margin);
wSuppressLogFailedData.setLayoutData(fdSuppressLogFailedData);
- // Optionally suppress the log line the engine writes for every rejected
row
- //
- wSuppressErrorLog = new Button(shell, SWT.CHECK);
- wSuppressErrorLog.setText(
- BaseMessages.getString(PKG, "ValidatorDialog.SuppressErrorLog.Label"));
- wSuppressErrorLog.setToolTipText(
- BaseMessages.getString(PKG,
"ValidatorDialog.SuppressErrorLog.Tooltip"));
- PropsUi.setLook(wSuppressErrorLog);
- FormData fdSuppressErrorLog = new FormData();
- fdSuppressErrorLog.left = new FormAttachment(middle, 0);
- fdSuppressErrorLog.right = new FormAttachment(100, 0);
- fdSuppressErrorLog.top = new FormAttachment(wSuppressLogFailedData,
margin);
- wSuppressErrorLog.setLayoutData(fdSuppressErrorLog);
-
// Create a scrolled composite on the right side...
//
ScrolledComposite wSComp = new ScrolledComposite(shell, SWT.H_SCROLL |
SWT.V_SCROLL);
@@ -244,7 +229,7 @@ public class ValidatorDialog extends BaseTransformDialog {
wSComp.setLayout(new FillLayout());
FormData fdComp = new FormData();
fdComp.left = new FormAttachment(middle / 2, margin);
- fdComp.top = new FormAttachment(wSuppressErrorLog, margin);
+ fdComp.top = new FormAttachment(wSuppressLogFailedData, margin);
fdComp.right = new FormAttachment(100, -margin);
fdComp.bottom = new FormAttachment(wOk, -margin);
// Limit viewport size so the dialog opens at a reasonable size; content
scrolls inside.
@@ -1071,7 +1056,6 @@ public class ValidatorDialog extends BaseTransformDialog {
wConcatErrors.setSelection(input.isConcatenatingErrors());
wConcatSeparator.setText(Const.NVL(input.getConcatenationSeparator(), ""));
wSuppressLogFailedData.setSelection(input.isSuppressingLogFailedData());
- wSuppressErrorLog.setSelection(input.isSuppressingErrorLog());
// Select the first available field...
//
@@ -1114,7 +1098,6 @@ public class ValidatorDialog extends BaseTransformDialog {
input.setConcatenatingErrors(wConcatErrors.getSelection());
input.setConcatenationSeparator(wConcatSeparator.getText());
input.setSuppressingLogFailedData(wSuppressLogFailedData.getSelection());
- input.setSuppressingErrorLog(wSuppressErrorLog.getSelection());
input.setValidations(selectionList);
diff --git
a/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/ValidatorMeta.java
b/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/ValidatorMeta.java
index 014b15a59c..b85e9543d0 100644
---
a/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/ValidatorMeta.java
+++
b/plugins/transforms/validator/src/main/java/org/apache/hop/pipeline/transforms/validator/ValidatorMeta.java
@@ -92,16 +92,6 @@ public class ValidatorMeta extends
BaseTransformMeta<Validator, ValidatorData> {
injectionKeyDescription = "Validator.Injection.SUPPRESS_LOG_FAILED_DATA")
private boolean suppressingLogFailedData;
- /**
- * When true, no log line is written for every rejected row. Error rows are
still sent to the
- * error handling hop. Defaults to false so existing pipelines keep logging
every rejected row.
- */
- @HopMetadataProperty(
- key = "suppress_error_log",
- injectionKey = "SUPPRESS_ERROR_LOG",
- injectionKeyDescription = "Validator.Injection.SUPPRESS_ERROR_LOG")
- private boolean suppressingErrorLog;
-
/** The standard new validation stream */
@Getter @Setter
private static IStream newValidation =
diff --git
a/plugins/transforms/validator/src/main/resources/org/apache/hop/pipeline/transforms/validator/messages/messages_en_US.properties
b/plugins/transforms/validator/src/main/resources/org/apache/hop/pipeline/transforms/validator/messages/messages_en_US.properties
index 3d873d8f7d..aba25a95da 100644
---
a/plugins/transforms/validator/src/main/resources/org/apache/hop/pipeline/transforms/validator/messages/messages_en_US.properties
+++
b/plugins/transforms/validator/src/main/resources/org/apache/hop/pipeline/transforms/validator/messages/messages_en_US.properties
@@ -40,7 +40,6 @@ Validator.Exception.UnexpectedDataType=During validation of
field ''{0}'' we fou
Validator.Injection.CONCATENATE_ERRORS=This option causes all errors to be
combined into a single output row.
Validator.Injection.CONCATENATION_SEPARATOR=Specify the error separator when
the errors are in one output row.
Validator.Injection.SUPPRESS_LOG_FAILED_DATA=When enabled, failed field/row
values are omitted from validation error messages written to the log. Error
rows are still sent to the error handling hop.
-Validator.Injection.SUPPRESS_ERROR_LOG=When enabled, no log line is written
for every rejected row. Error rows are still sent to the error handling hop.
Validator.Injection.CONVERSION_MASK=Specify the mask to use to convert the
data specified in this validation rule.
Validator.Injection.DATA_TYPE=Specify the data type to verify.
Validator.Injection.DATA_TYPE_VERIFIED=This option causes the specified data
type to be verified.
@@ -75,8 +74,6 @@ ValidatorDialog.ClearButton.Label=Remove validation
ValidatorDialog.ConcatErrors.Label=Output one row, concatenate errors with
separator
ValidatorDialog.SuppressLogFailedData.Label=Do not log failed validation data
ValidatorDialog.SuppressLogFailedData.Tooltip=When enabled, failed field/row
values are omitted from validation error messages (shown as "?"). Error
messages are still logged. Error rows are still sent to the error handling hop
when configured.
-ValidatorDialog.SuppressErrorLog.Label=Do not log a line for every rejected row
-ValidatorDialog.SuppressErrorLog.Tooltip=When enabled, the transform no longer
writes an error line to the log for every row it rejects. Error rows are still
sent to the error handling hop when configured. On streams where many rows are
rejected this log line costs far more than the validation itself.
ValidatorDialog.ConversionMask.Label=Conversion mask
ValidatorDialog.DataGroup.Label=Data
ValidatorDialog.DataType.Label=Data type
diff --git
a/plugins/transforms/validator/src/main/resources/org/apache/hop/pipeline/transforms/validator/messages/messages_pt_BR.properties
b/plugins/transforms/validator/src/main/resources/org/apache/hop/pipeline/transforms/validator/messages/messages_pt_BR.properties
index 4e18a6c2e1..ea66a1b830 100644
---
a/plugins/transforms/validator/src/main/resources/org/apache/hop/pipeline/transforms/validator/messages/messages_pt_BR.properties
+++
b/plugins/transforms/validator/src/main/resources/org/apache/hop/pipeline/transforms/validator/messages/messages_pt_BR.properties
@@ -123,8 +123,5 @@ ValidatorMeta.InfoStream.ValidationInput.Description=Dados
de referência opcion
ValidatorMeta.NewValidation.Description=Criar uma nova validação usando dados
de referência.
Validator.Exception.InfoTransformIsDistributing=Transformar entrega os valores
permitidos para validação mas distribui suas linhas sobre as cópias da
transformação. Toda cópia precisa de todos os valores permitidos, então isso
faria as linhas válidas falharem. Ou executar [{1}] em uma única cópia, ou
definir o movimento de dados de [{0}] para "Copiar dados para todas as
transformações".
Validator.Injection.SUPPRESS_LOG_FAILED_DATA=Quando ativado, os valores de
campo/linha são omitidos das mensagens de erro de validação escritas no log. As
linhas de erro ainda são enviadas para o hop de manipulação de erros.
-Validator.Injection.SUPPRESS_ERROR_LOG=Quando ativado, nenhuma linha de
registro é escrita para cada linha rejeitada. As linhas de erro ainda são
enviadas para o hop de manipulação de erros.
ValidatorDialog.SuppressLogFailedData.Label=Não registre dados de validação
falhando
ValidatorDialog.SuppressLogFailedData.Tooltip=Quando ativado, os valores de
campo/linha falhadas são omitidos das mensagens de erro de validação (mostradas
como "?"). As mensagens de erro ainda estão registradas. As linhas de erro
ainda são enviadas para o hop quando configurado.
-ValidatorDialog.SuppressErrorLog.Label=Não registre uma linha para cada linha
rejeitada.
-ValidatorDialog.SuppressErrorLog.Tooltip=Quando habilitado, a transformação
não escreve mais uma linha de erro para o registro para cada linha que rejeita.
As linhas de erro ainda são enviadas para o hop quando configurado. Em córregos
onde muitas linhas são rejeitadas esta linha de log custa muito mais do que a
própria validação.
diff --git
a/plugins/transforms/validator/src/test/java/org/apache/hop/pipeline/transforms/validator/ValidatorTest.java
b/plugins/transforms/validator/src/test/java/org/apache/hop/pipeline/transforms/validator/ValidatorTest.java
index c862ed9289..411d9fc4e0 100644
---
a/plugins/transforms/validator/src/test/java/org/apache/hop/pipeline/transforms/validator/ValidatorTest.java
+++
b/plugins/transforms/validator/src/test/java/org/apache/hop/pipeline/transforms/validator/ValidatorTest.java
@@ -902,22 +902,10 @@ class ValidatorTest {
}
@Test
- void testErrorDescriptionsAreLoggedByDefault() throws Exception {
+ void testRejectedRowReachesTheErrorHandlingHop() throws Exception {
ValidatorMeta meta = createMeta(nullNotAllowed());
Validator validator = createInitializedValidator(meta, stringRowMeta(),
true);
- assertTrue(validator.isLoggingErrorDescriptions());
- }
-
- @Test
- void testSuppressErrorLogStopsTheLogLinePerRejectedRow() throws Exception {
- ValidatorMeta meta = createMeta(nullNotAllowed());
- meta.setSuppressingErrorLog(true);
- Validator validator = createInitializedValidator(meta, stringRowMeta(),
true);
-
- assertFalse(validator.isLoggingErrorDescriptions());
-
- // the error row itself still has to reach the error handling hop
doReturn(new Object[] {null}).doReturn(null).when(validator).getRow();
stubPutError(validator);
