docs: private void fillColumnValuesMap(List<Map<String, Object>> results, Map<String, List<String>> columnValuesMap) {
          for (Map<String, Object> row : results) {
              for (Entry<String, Object> column : row.entrySet()) {
                  String columnValue;
                  String columnName = column.getKey();
                  if (!columnValuesMap.containsKey(columnName)) {
                      columnValuesMap.put(columnName, new ArrayList<String>());
                  }
  
                  if (column.getValue() instanceof byte[]) {
                      columnValue = Base64.encodeBase64String((byte[]) column.getValue());
                  } else {
                      columnValue = column.getValue() == null ? null : column.getValue().toString();
                  }
  
                  columnValuesMap.get(columnName).add((columnValue));
              }
          }
      }
  
      /**
       * Gets the script validator implementation either autowired from application context
       * or if not set here a default implementation.
       */
      private SqlResultSetScriptValidator getScriptValidator() {
          if (validator != null) {
              return validator;
          } else {
              return new GroovySqlResultSetValidator();
          }
      }
  
      /**
       * Constructs a delimited string from multiple row values in result set in order to
       * set this expression as variable value.
       *
       * @param rowValues the list of values representing the allResultRows for a column in the result set.
       * @return the variable value as delimited string or single value.
       */
      private String constructVariableValue(List<String> rowValues) {
          if (CollectionUtils.isEmpty(rowValues)) {
              return "";
          } else if (rowValues.size() == 1) {
              return rowValues.get(0) == null ? NULL_VALUE : rowValues.get(0);
          } else {
              StringBuilder result = new StringBuilder();
  
              Iterator<String> it = rowValues.iterator();
  
              result.append(it.next());
              while (it.hasNext()) {
                  String nextValue = it.next();
                  result.append(";" + (nextValue == null ? NULL_VALUE : nextValue));
              }
  
              return result.toString();
          }
      }
  
      /**
       * Validates the database result set. At first script validation is done (if any was given).
       * Afterwards the control result set validation is performed.
       *
       * @param columnValuesMap map containing column names as keys and list of string as retrieved values from db
       * @param allResultRows list of all result rows retrieved from database
       * @return success flag
       * @throws UnknownElementException
       * @throws ValidationException
       */
      private void performValidation(final Map<String, List<String>> columnValuesMap,
              List<Map<String, Object>> allResultRows, TestContext context)
              throws UnknownElementException, ValidationException {
          // apply script validation if specified
          if (scriptValidationContext != null) {
              getScriptValidator().validateSqlResultSet(allResultRows, scriptValidationContext, context);
          }
  
          //now apply control set validation if specified
          if (CollectionUtils.isEmpty(controlResultSet)) {
              return;
          }
          performControlResultSetValidation(columnValuesMap, context);
          log.info("SQL query validation successful: All values OK");
      }
  
      private void performControlResultSetValidation(final Map<String, List<String>> columnValuesMap, TestContext context)
              throws CitrusRuntimeException {
          for (Entry<String, List<String>> controlEntry : controlResultSet.entrySet()) {
              String columnName = controlEntry.getKey();
  
              if (columnValuesMap.containsKey(columnName.toLowerCase())) {
                  columnName = columnName.toLowerCase();
              } else if (columnValuesMap.containsKey(columnName.toUpperCase())) {
                  columnName = columnName.toUpperCase();
              } else if (!columnValuesMap.containsKey(columnName)) {
                  throw new CitrusRuntimeException("Could not find column '" + columnName + "' in SQL result set");
              }
  
              List<String> resultColumnValues = columnValuesMap.get(columnName);
              List<String> controlColumnValues = controlEntry.getValue();
  
              // first check size of column values (representing number of allResultRows in result set)
              if (resultColumnValues.size() != controlColumnValues.size()) {
                  throw new CitrusRuntimeException("Validation failed for column: '" +  columnName + "' " +
                          "expected rows count: " + controlColumnValues.size() + " but was " + resultColumnValues.size());
              }
  
              Iterator<String> it = resultColumnValues.iterator();
              for (String controlValue : controlColumnValues) {
                  String resultValue = it.next();
                  //check if controlValue is variable or function (and resolve it)
                  controlValue = context.replaceDynamicContentInString(controlValue);
  
                  validateSingleValue(columnName, controlValue, resultValue, context);
              }
          }
      }
  
      /**
       * Does some simple validation on the SQL statement.
       * @param stmt The statement which is to be validated.
       */
      protected void validateSqlStatement(String stmt) {
          if (!stmt.toLowerCase().startsWith("select")) {
              throw new CitrusRuntimeException("Missing keyword SELECT in statement: " + stmt);
          }
      }
  
      protected void validateSingleValue(String columnName, String controlValue, String resultValue, TestContext context) {
          // check if value is ignored
          if (controlValue.equals(Citrus.IGNORE_PLACEHOLDER)) {
              if (log.isDebugEnabled()) {
                  log.debug("Ignoring column value '" + columnName + "(resultValue)'");
              }
              return;
          }
          
          if (ValidationMatcherUtils.isValidationMatcherExpression(controlValue)) {
              ValidationMatcherUtils.resolveValidationMatcher(columnName, resultValue, controlValue, context);
              return;
          }
          
          if (resultValue == null) {
              if (isCitrusNullValue(controlValue)) {
                  if (log.isDebugEnabled()) {
                      log.debug("Validating database value for column: ''" +
                              columnName + "'' value as expected: NULL - value OK");
                  }
                  return;
              } else {
                  throw new ValidationException("Validation failed for column: '" +  columnName + "'"
                          + "found value: NULL expected value: " + controlValue);
              }
          }
  
          if (resultValue.equals(controlValue)) {
              if (log.isDebugEnabled()) {
                  log.debug("Validation successful for column: '" + columnName +
                          "' expected value: " + controlValue + " - value OK");
              }
          } else {
              throw new ValidationException("Validation failed for column: '" +  columnName + "'"
                      + " found value: '"
                      + resultValue
                      + "' expected value: "
                      + ((controlValue.length()==0) ? NULL_VALUE : controlValue));
          }
      }