Returns whether this collection has defined a given
filterable field.

@param fieldName {string} querystring parameter name for the
filterable field
@return {boolean} Returns true if this collection has the specified field.
336038
function(fieldName) {
                return _.has(this.filterableFields, fieldName) &&
                    !_.isUndefined(this.filterableFields[fieldName].displayName);
            }
121533
function hasField(selection, fieldNames) {
  if (!selection || selection.type === 'empty') {
    return false;
  }
  const fieldsToLookup = [].concat(fieldNames);

  if (selection.type === 'range') {
    const fields = Object.keys(selection.range.variables);
    const match = intersect(fieldsToLookup, fields);
    return match.length > 0;
  }
  if (selection.type === 'partition') {
    return fieldsToLookup.indexOf(selection.partition.variable) !== -1;
  }

  console.log(
    'SelectionBuilder::hasField does not handle selection of type',
    selection.type
  );

  return false;
}
569174
public static String getQuery(String clazzFieldName, String clazzName, String idFieldName, String idFieldValue)
    {
        StringBuffer sb = new StringBuffer("+");
        sb.append(clazzFieldName);
        sb.append(":");
        sb.append(clazzName);
        sb.append(" AND ");
        sb.append("+");
        sb.append(idFieldName);
        sb.append(":");
        sb.append(idFieldValue);
        return sb.toString();
    }
526048
public boolean hasColumnName(String columnName) {
		for (FieldType fieldType : fieldTypes) {
			if (fieldType.getColumnName().equals(columnName)) {
				return true;
			}
		}
		return false;
	}
246035
def parse_querystring(self, req: Request, name: str, field: Field) -> typing.Any:
        """"""
        return core.get_value(req.query, name, field)
1040869
public TResult queryForLike(String fieldName, ColumnValue value) {
		String where = buildWhereLike(fieldName, value);
		String[] whereArgs = buildWhereArgs(value);
		TResult result = userDb.query(getTableName(), table.getColumnNames(),
				where, whereArgs, null, null, null);
		prepareResult(result);
		return result;
	}
665743
function mustBeScalar(filter, keyword, field) {
  if (filter[field] instanceof Object || filter[field] === undefined) {
    return Bluebird.reject(new BadRequestError(`"${field}" in "${keyword}" must be either a string, a number, a boolean or null`));
  }

  return Bluebird.resolve();
}
799963
public boolean containsBeforeSchemaOrder(String field) {
    if (schemaOrderIndex == null) {
      return containsFieldName(field);
    }
    for (int i = 0; i < schemaOrderIndex; i++) {
      if (elements.get(i).getName().equals(field)) {
        return true;
      }
    }
    return false;
  }
853726
public function canFilterBy($fieldName)
    {
        $model = singleton($this->dataClass);
        $relations = explode(".", $fieldName);
        // First validate the relationships
        $fieldName = array_pop($relations);
        foreach ($relations as $r) {
            $relationClass = $model->getRelationClass($r);
            if (!$relationClass) {
                return false;
            }
            $model = singleton($relationClass);
            if (!$model) {
                return false;
            }
        }
        // Then check field
        if ($model->hasDatabaseField($fieldName)) {
            return true;
        }
        return false;
    }
1223297
def hasField(cls, fieldName) :
        """"""
        path = fieldName.split(".")
        v = cls._fields
        for k in path :
            try :
                v = v[k]
            except KeyError :
                return False
        return True
746302
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case SESSION_HANDLE:
      return isSetSessionHandle();
    case CATALOG_NAME:
      return isSetCatalogName();
    case SCHEMA_NAME:
      return isSetSchemaName();
    case TABLE_NAME:
      return isSetTableName();
    case COLUMN_NAME:
      return isSetColumnName();
    }
    throw new IllegalStateException();
  }
305006
public void setSearchString(String queryString)
    {
        this.searchString = queryString;
        if (this.textFilterField != null)
        {
            this.textFilterField.setText(this.searchString);
        }
    }
452078
public IDocumentQuery<T> whereLessThanOrEqual(String fieldName, Object value) {
        return whereLessThanOrEqual(fieldName, value, false);
    }
431702
public boolean isField(final String fieldName) {
    if (fieldName != null) {
        return (KEYWORD_LIST.contains(
                fieldName.toUpperCase(Locale.US))
                || fieldName.toUpperCase().startsWith(PROP_FIELD));
    }
    return false;
  }
343830
function(field) {
    if (this._template) {
      var match = field.match(this.fieldRegex);
      return match && this.vars.hasOwnProperty(match[1]);
    }
    return false;
  }
1152714
protected boolean hasFieldError(String fieldname) {
		if ( StringUtils.isEmpty(fieldname)) {
			return false;
		}

		Object action = ActionContext.getContext().getActionInvocation().getAction();
		// check action instance 'ActionSupport'.
		if (!(action instanceof ActionSupport)) {
			return false;
		}

		ActionSupport asupport = (ActionSupport) action;
		Map<String, List<String>> fieldErrors = asupport.getFieldErrors();
		if (CollectionUtils.isEmpty(fieldErrors)) {
			return false;
		}
		List<String> targetFieldErrors = fieldErrors.get(fieldname);
		if (CollectionUtils.isEmpty(targetFieldErrors)) {
			return false;
		}

		return true;
	}
645329
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case FUNC_ARGS:
      return is_set_func_args();
    case REQUEST_ID:
      return is_set_request_id();
    }
    throw new IllegalStateException();
  }