Gets the field.

@param fieldName the field name
@param where     the where
@return the field
194512
private static Field getField(String fieldName, Class<?> where) {
        if (where == null) {
            throw new IllegalArgumentException("where cannot be null");
        }

        Field field = null;
        try {
            field = where.getDeclaredField(fieldName);
            field.setAccessible(true);
        } catch (NoSuchFieldException e) {
            throw new FieldNotFoundException("Field '" + fieldName + "' was not found in class " + where.getName()
                                                     + ".");
        }
        return field;
    }
1161776
public function find(array $where = [], array $field = [])
    {
        return $this
            ->createQuery(
                $this->getQueryBuilder()
                    ->select(array() === $field ? $this->getAlias() : $field)
                    ->from($this->getTable())
                    ->where($where)
            )
            ->execute()
            ->getOne()
            ;
    }
1252667
def wheregreater(self, fieldname, value):
        
        return self.mask([elem > value for elem in self[fieldname]])
913183
static Field getField(Class<?> targetClass, String fieldName) {
		while (targetClass != null) {
			try {
				Field field = targetClass.getDeclaredField(fieldName);
				logger.debug("Found field {} in class {}", fieldName, targetClass.getName());
				return field;
			} catch (NoSuchFieldException e) {
				logger.debug("Failed to find field {} in class {}", fieldName, targetClass.getName());
			}
			targetClass = targetClass.getSuperclass();
		}

		return null;
	}
192819
@Override
    public Optional<FieldTypes> get(final String fieldName) {
        return Optional.ofNullable(get(ImmutableSet.of(fieldName)).get(fieldName));
    }
554811
public FieldNode getField(String name) {
        ClassNode node = this;
        while (node != null) {
            FieldNode fn = node.getDeclaredField(name);
            if (fn != null) return fn;
            node = node.getSuperClass();
        }
        return null;
    }
440558
public <T> T getField(String fieldName, Class<T> clazz) {
        return DPathUtils.getValue(fieldData, fieldName, clazz);
    }
459395
public BaseField getField(String strFieldName)    // Lookup this field
    {
        int iDotIndex = strFieldName.indexOf('.');
        if (iDotIndex != -1)    // Is Field formated as: RecordName.FieldName?
            return this.getField(strFieldName.substring(0, iDotIndex), strFieldName.substring(iDotIndex+1, strFieldName.length()));
        else
            return (BaseField)super.getField(strFieldName);
    }
107377
@SuppressWarnings("unchecked")
  public static <T, O> O getFieldValue(Class<T> clz, T t, String fieldName) throws NoSuchFieldException {
    Field field = clz.getDeclaredField(fieldName);
    field.setAccessible(true);
    try {
      return (O) field.get(t);
    } catch (IllegalAccessException e) {
      throw new IllegalStateException(e);
    }
  }
987879
public static Field getField(String fieldName, Object object) {
    return getField(fieldName, object.getClass());
  }
836838
public static <T> T getFieldValue(Object target, String fieldName) {
        try {
            Field field = target.getClass().getDeclaredField(fieldName);
            field.setAccessible(true);
            @SuppressWarnings("unchecked")
            T returnValue = (T) field.get(target);
            return returnValue;
        } catch (NoSuchFieldException e) {
            throw handleException(fieldName, e);
        } catch (IllegalAccessException e) {
            throw handleException(fieldName, e);
        }
    }
881767
public static String getFieldValue(ODocument document, String fieldname) {
        return (String) document.field(fieldname);
    }
80577
protected function getTableFieldInformationWhere(Where $where)
    {
        $sql = <<<SQL
select
    att.attname      as "name",
    case
        when name.nspname = 'pg_catalog' then typ.typname
        else format('%s.%s', name.nspname, typ.typname)
    end as "type",
    def.adsrc        as "default",
    att.attnotnull   as "is_notnull",
    dsc.description  as "comment",
    att.attnum       as "position",
    att.attnum = any(ind.indkey) as "is_primary"
from
  pg_catalog.pg_attribute att
    join pg_catalog.pg_type  typ  on att.atttypid = typ.oid
    join pg_catalog.pg_class cla  on att.attrelid = cla.oid
    join pg_catalog.pg_namespace clns on cla.relnamespace = clns.oid
    left join pg_catalog.pg_description dsc on cla.oid = dsc.objoid and att.attnum = dsc.objsubid
    left join pg_catalog.pg_attrdef def     on att.attrelid = def.adrelid and att.attnum = def.adnum
    left join pg_catalog.pg_index ind       on cla.oid = ind.indrelid and ind.indisprimary
    left join pg_catalog.pg_namespace name  on typ.typnamespace = name.oid
where
{condition}
order by
    att.attnum
SQL;

        $where = $where
            ->andWhere('att.attnum > 0')
            ->andWhere('not att.attisdropped')
            ;

        return $this->executeSql($sql, $where);
    }
1351905
public String getHeaderField(String fieldName) {
        // headers map is null for all regular response calls except when made as a batch request
        if (this.headers == null) {
            if (this.connection != null) {
                return this.connection.getHeaderField(fieldName);
            } else {
                return null;
            }
        } else {
            return this.headers.get(fieldName);
        }
    }
1263726
public static final String getter(Field field, String fieldName)
    {
        Class<?> type = field.getType();
        if (type.isPrimitive() && "boolean".equals(type.getName()))
        {
            return isser(fieldName);
        }
        else
        {
            return getter(fieldName);
        }
    }
720298
public Method getGetter(String fieldName) {
		final PropDesc desc = this.propMap.get(fieldName);
		return null == desc ? null : desc.getGetter();
	}
1364545
@SuppressWarnings("RedundantTypeArguments")
    public <T> T get(String name) throws ReflectException {
        return field(name).<T>get();
    }