Only include rows which are missing this field, this was the only possible
way to do it.

@param fieldName
The field which should be missing
@return ScannerBuilder
2065
public EntityScannerBuilder<E> addIsMissingFilter(String fieldName) {
    SingleFieldEntityFilter singleFieldEntityFilter = new SingleFieldEntityFilter(
        entityMapper.getEntitySchema(), entityMapper.getEntitySerDe(),
        fieldName, "++++NON_SHALL_PASS++++", CompareFilter.CompareOp.EQUAL);
    SingleColumnValueFilter filter = (SingleColumnValueFilter) singleFieldEntityFilter
        .getFilter();
    filter.setFilterIfMissing(false);
    filterList.add(filter);
    return this;
  }
1233620
private void addFieldsToBuilder(String[] fieldsToSelect, Class clazz, MetamodelImpl metaModel,
            SearchRequestBuilder builder)
    {
        if (fieldsToSelect != null && fieldsToSelect.length > 1 && !(fieldsToSelect[1] == null))
        {
            logger.debug("Fields added in query are: ");
            for (int i = 1; i < fieldsToSelect.length; i++)
            {
                logger.debug(i + " : " + fieldsToSelect[i]);
                builder = builder.addField(((AbstractAttribute) metaModel.entity(clazz).getAttribute(fieldsToSelect[i]))
                        .getJPAColumnName());
            }
        }
    }
408597
public static Field getField(Object source, String fieldName) {
        if (source == null) {
            return null;
        }
        return getField(source.getClass(), fieldName);
    }
823373
@Override public final String getHeaderField(String fieldName) {
    try {
      return fieldName == null
          ? StatusLine.get(getResponse().getResponse()).toString()
          : getHeaders().get(fieldName);
    } catch (IOException e) {
      return null;
    }
  }
1190471
public ReflectionToStringBuilder setExcludeFieldNames(final String... excludeFieldNamesParam) {
        if (excludeFieldNamesParam == null) {
            this.excludeFieldNames = null;
        } else {
            //clone and remove nulls
            this.excludeFieldNames = toNoNullStringArray(excludeFieldNamesParam);
            Arrays.sort(this.excludeFieldNames);
        }
        return this;
    }
900862
private static String buildDescription(final List<String> missingFields) {
    final StringBuilder description =
      new StringBuilder("Message missing required fields: ");
    boolean first = true;
    for (final String field : missingFields) {
      if (first) {
        first = false;
      } else {
        description.append(", ");
      }
      description.append(field);
    }
    return description.toString();
  }
1373096
public MapBuilder add(String fieldName, boolean include, @Nullable Map<String, ?> mapValue) {
        if (include && mapValue != null && !mapValue.isEmpty()) {
            map.put(getFieldName(fieldName), mapValue);
        }
        return this;
    }
472997
public static String toStringExclude(final Object object, final String... excludeFieldNames) {
        return new ReflectionToStringBuilder(object).setExcludeFieldNames(excludeFieldNames).toString();
    }
692333
public Field getField(String fieldName) {
		final PropDesc desc = this.propMap.get(fieldName);
		return null == desc ? null : desc.getField();
	}
1176128
public function selectElemMatch($fieldName, $expression)
    {
        if ($expression instanceof Expr) {
            $expression = $expression->getQuery();
        }
        $this->query['select'][$fieldName] = array('$elemMatch' => $expression);
        return $this;
    }
218291
public function getInclude($fieldName)
    {
        if ($this->isInclude($fieldName) === false) {
            return false;
        }

        return $this->mapping[$fieldName]['include'];
    }
1085905
public HighlightOptions addField(String fieldname) {
		Assert.hasText(fieldname, "Fieldname must not be null nor empty!");
		return addField(new SimpleField(fieldname));
	}
722108
public MapBuilder addNumber(String fieldName, boolean include, Supplier<Number> supplier) {
        if (include) {
            Number value = supplier.get();
            if (value != null) {
                map.put(getFieldName(fieldName), value);
            }
        }
        return this;
    }
494165
public EntityScannerBuilder<E> addEqualFilter(String fieldName,
      Object filterValue) {
    SingleFieldEntityFilter singleFieldEntityFilter = new SingleFieldEntityFilter(
        entityMapper.getEntitySchema(), entityMapper.getEntitySerDe(),
        fieldName, filterValue, CompareFilter.CompareOp.EQUAL);
    filterList.add(singleFieldEntityFilter.getFilter());
    return this;
  }
1164927
public void selectFields(String[] fieldNames) {
		checkNotNull(fieldNames, "fieldNames");
		this.fieldNames = fieldNames;
		RowTypeInfo rowTypeInfo = (RowTypeInfo) ParquetSchemaConverter.fromParquetType(expectedFileSchema);
		TypeInformation[] selectFieldTypes = new TypeInformation[fieldNames.length];
		for (int i = 0; i < fieldNames.length; i++) {
			try {
				selectFieldTypes[i] = rowTypeInfo.getTypeAt(fieldNames[i]);
			} catch (IndexOutOfBoundsException e) {
				throw new IllegalArgumentException(String.format("Fail to access Field %s , "
						+ "which is not contained in the file schema", fieldNames[i]), e);
			}
		}
		this.fieldTypes = selectFieldTypes;
	}
632057
public @CheckForNull
    SourceLineRange getFieldLine(String className, String fieldName) {
        return fieldLineMap.get(new FieldDescriptor(className, fieldName));
    }
1155741
public boolean hasField(final String fieldName) {
        for (final ClassInfo ci : getOverrideOrder()) {
            if (ci.hasDeclaredField(fieldName)) {
                return true;
            }
        }
        return false;
    }