Returns an implementation of RowFieldNormalizerInterface
@param string $field
@return RowFieldNormalizerInterface
@throws NotFoundFieldException
326230
public static function create($field): RowFieldNormalizerInterface
    {
        switch ($field) {
            case Quotation::ACTIVE:
                return new ActiveNormalizer();
            case Quotation::ASSISTS_MAGIC_POINTS:
                return new AssistsMagicPointsNormalizer();
            case Quotation::ASSISTS:
                return new AssistsNormalizer();
            case Quotation::AUTO_GOALS_MAGIC_POINTS:
                return new AutoGoalsMagicPointsNormalizer();
            case Quotation::AUTO_GOALS:
                return new AutoGoalsNormalizer();
            case Quotation::CODE:
                return new CodeNormalizer();
            case Quotation::GOALS_MAGIC_POINTS:
                return new GoalsMagicPointsNormalizer();
            case Quotation::GOALS:
                return new GoalsNormalizer();
            case Quotation::MAGIC_POINTS:
                return new MagicPointsNormalizer();
            case Quotation::ORIGINAL_MAGIC_POINTS:
                return new OriginalMagicPointsNormalizer();
            case Quotation::PENALTIES_MAGIC_POINTS:
                return new PenaltiesMagicPointsNormalizer();
            case Quotation::PENALTIES:
                return new PenaltiesNormalizer();
            case Quotation::PLAYER:
                return new PlayerNormalizer();
            case Quotation::QUOTATION:
                return new QuotationNormalizer();
            case Quotation::RED_CARDS_MAGIC_POINTS:
                return new RedCardsMagicPointsNormalizer();
            case Quotation::RED_CARDS:
                return new RedCardsNormalizer();
            case Quotation::ROLE:
                return new RoleNormalizer();
            case Quotation::SECONDARY_ROLE:
                return new SecondaryRoleNormalizer();
            case Quotation::TEAM:
                return new TeamNormalizer();
            case Quotation::VOTE:
                return new VoteNormalizer();
            case Quotation::YELLOW_CARDS_MAGIC_POINTS:
                return new YellowCardsMagicPointsNormalizer();
            case Quotation::YELLOW_CARDS:
                return new YellowCardsNormalizer();
            default:
                throw new NotFoundFieldException('Field not found: ' . $field);
        }
    }
457929
public function findColumn($field) {
        $rows = $this->select($field)->findAll();

        //false or null
        if (!$rows) {
            return $rows;
        }

        $columnValues = [];
        foreach ($rows as $row) {
            $columnValues[] = $row[$field];
        }
        return $columnValues;
    }
1278870
public function getField($field)
    {
        // If we already have a value in $this->record, then we should just return that
        if (isset($this->record[$field])) {
            return $this->record[$field];
        }

        // Do we have a field that needs to be lazy loaded?
        if (isset($this->record[$field . '_Lazy'])) {
            $tableClass = $this->record[$field . '_Lazy'];
            $this->loadLazyFields($tableClass);
        }
        $schema = static::getSchema();

        // Support unary relations as fields
        if ($schema->unaryComponent(static::class, $field)) {
            return $this->getComponent($field);
        }

        // In case of complex fields, return the DBField object
        if ($schema->compositeField(static::class, $field)) {
            $this->record[$field] = $this->dbObject($field);
        }

        return isset($this->record[$field]) ? $this->record[$field] : null;
    }
414810
public function getScalar($field = null)
	{
		$option = $this->operationOption;
		$this->__getScalarBefore($option);
		if(null !== $field)
		{
			$this->operationOption['field'] = array($field);
		}
		$this->db->operationOption = $this->getOption();
		$result = $this->db->getScalar();
		$this->__getScalarAfter($result,$option);
		return $result;
	}
1277202
public function get($model, $field, $row)
    {
        $value = $model->getFieldValue($field);
        return $this->parse($value, $row);
    }
916644
protected function getHeaderFieldModel($field)
    {
        if ($this->headers->has($field)) {
            return $this->headers->get($field)->getFieldBodyModel();
        }
    }
1123178
public function setField($field)
    {
        if(is_string($field)) {
            $field = new FieldIdentifier($field);
        }
        $this->field = $field;
        return $this;
    }
802333
function GetFieldInfo($table, $field)
    {
        $isUnique = false;
        $isPrimary = false;
        $isNullable = false;
        $defaultValue = null;
        $fullName = '';
        if (!$this->GetBasicFieldInfo($table, $field, $fullName, $defaultValue, $isPrimary, $isUnique, $isNullable))
        {
            return null;
        }
        $typeDef = TypeDef::ParseFullName($fullName);
        if (!$typeDef)
        {
            return null;
        }
        $keyName = $this->GetKeyName($table, $field);
        if (!$keyName)
        {
            return new FieldInfo($field, $typeDef, $defaultValue, $isNullable, null, null, null);
        }
        $keyInfo = new KeyInfo($keyName, $isPrimary, $isUnique);
        $constraintName = '';
        $refTable = '';
        $refField = '';
        if (!$this->GetForeignKey($table, $field, $constraintName, $refTable, $refField))
        {
            return new FieldInfo($field, $typeDef, $defaultValue, $isNullable, $keyInfo, null, null);
        }
        
        $onUpdate = null;
        $onDelete = null;
        $this->GetConstraintRules($constraintName, $onUpdate, $onDelete);
        $foreignKey = new ForeignKey($refTable, $refField);
        $constraint = new Constraint($constraintName, $onUpdate, $onDelete);
        return new FieldInfo($field, $typeDef, $defaultValue, $isNullable, $keyInfo, $foreignKey, $constraint);
    }
1137440
public function getRaw($field)
    {
        if (!array_key_exists($field, $this->entity)) {
            return null;
        }
        return $this->entity[$field];
    }
1366958
public function castingHelper($field)
    {
        $copy = $this->CopyContentFrom();
        if ($copy && $copy->exists() && ($helper = $copy->castingHelper($field))) {
            return $helper;
        }
        return parent::castingHelper($field);
    }
470262
private function getPlainField($field)
    {
        if (!isset($this->fields[$field['name']])) {                     
			$this->fields[$field['name']] = $this->getDbConnection()->fetchColumn('SELECT `'.$field['name'].'` FROM '.$this->table.' WHERE id='.(int)$this->fields['id']);
		}
        return $this->fields[$field['name']];
    }
542165
private function mapObjectField(Field $field)
    {
        $value = $field->getValue();
        $getter = $field->getGetterName();
        if (empty($getter)) {
            throw new SolrMappingException(sprintf('Please configure a getter for property "%s" in class "%s"', $field->name, get_class($value)));
        }
        
        $getterReturnValue = $this->callGetterMethod($value, $getter);

        if (is_object($getterReturnValue)) {
            throw new SolrMappingException(sprintf('The configured getter "%s" in "%s" must return a string or array, got object', $getter, get_class($value)));
        }

        return $getterReturnValue;
    }
562226
protected function getField($field)
    {
        if ($this->isFieldSupported($field) && isset($this->fields[ $field ])) {
            return $this->fields[ $field ];
        }

        return null;
    }
710209
private function get($field)
    {
        $this->initializeDoctrine();

        $property = $this->cm->getProperty($field);

        if (! $property) {
            throw new BadMethodCallException("no field with name '" . $field . "' exists on '" . $this->cm->getClassName() . "'");
        }

        return $this->{$field};
    }
207848
private function getFieldsNormalizer()
    {
        return function(Options $options, $fields) {
            $normalizedFields = [];

            foreach ($fields as $name => $field) {
                if (null === $field) {
                    $field = [];
                }

                $normalizedFields[$name] = $field;
            }

            return $normalizedFields;
        };
    }
289540
private function getValue(
        string $path,
        $object,
        NormalizerContextInterface $context,
        NormalizerInterface $normalizer = null
    ) {
        if (null !== $this->accessor) {
            return $this->accessor->getValue($object);
        }

        return $this->fieldNormalizer->normalizeField($path, $object, $context, $normalizer);
    }
287187
public function readdField($field)
    {
        $this->checkValidLoader();

        foreach ($this->loaders as $loader => $fields) {
            if (in_array($field, $this->loaders[ $loader ])) {
                array_splice($this->loaders[ $loader ], array_search($field, $this->loaders[ $loader ]), 1);
            }
        }

        $this->addField($field);

        return $this;
    }