The fetch fields class is momentarily not ready to handle
to-many relationships, so skip them.

@todo: Enhance the fetch fields class to handle many relationships aswel

@param array $fetchFields
@param FullyQualifiedClassName $section
@return bool
965750
private function fetchFieldsContainsMany(array $fetchFields, FullyQualifiedClassName $section): bool
    {
        $sectionClass = (string) $section;
        $fields = $sectionClass::fieldInfo();
        foreach ($fetchFields as $fetchField) {
            if (!is_null($this->isManyRelationship($fetchField, $fields))) {
                return true;
            }
        }

        return false;
    }
537347
private function getRelationships(FullyQualifiedClassName $fullyQualifiedClassName): array
    {
        $fields = (string)$fullyQualifiedClassName;
        if (!is_subclass_of($fields, CommonSectionInterface::class)) {
            throw new NotASexyFieldEntityException;
        }
        /** @var CommonSectionInterface $fields */
        $relationships = [];
        foreach ($fields::fieldInfo() as $field) {
            if (!is_null($field['relationship'])) {
                $relationships[] = $field['relationship']['class'];
            }
        }
        return $relationships;
    }
1099010
public function detailsValidateSections(Model $Model, $sections = array()) {
		$DetailModel = ClassRegistry::init($this->settings[$Model->alias]['alias']);

		if (empty($Model->detailsValidate)) {
			return true;
		} else if (empty($Model->data[$DetailModel->alias])) {
			return false;
		} else if (empty($sections)) {
			$sections = array_keys($Model->detailsValidate);
		}

		$validationErrors = array();

		foreach ((array) $sections as $section) {
			if (empty($Model->data[$DetailModel->alias][$section])) {
				continue;
			}

			$DetailModel->validationErrors = array();
			$DetailModel->set($Model->data[$DetailModel->alias][$section]);
			$DetailModel->validate = $Model->detailsValidate[$section];
			if (!$DetailModel->validates()) {
				$validationErrors[$section] = $DetailModel->validationErrors;
			}

		}

		$DetailModel->validationErrors = $validationErrors;

		return empty($DetailModel->validationErrors);
	}
563837
public function section(string $title, array $fields)
    {
        $fields = $this->buildAllFields($fields);

        foreach ($fields as $field) {
            $fieldName = $field->getName();

            if (isset($this->fields[$fieldName])) {
                throw new ConflictingFieldNameException($fieldName);
            } else {
                $this->fields[$fieldName] = $field;
            }
        }

        $this->sections[] = new FormSection($title, $fields);

        return $this;
    }
1212835
public function setMultiple(string $section, $values) : bool
    {
        $concatted = [];
        foreach ($values as $key => $value) {
            $concatted[$section . $this->sectionKeyDelimiter . $key] = $value;
        }
        return $this->cacheStore->setMultiple($concatted);
    }
754938
protected function isSectionExcluded(string $sectionName, array $sectionDefinition): bool
    {
        if ($this->isExcludedByName($sectionName)) {
            return true;
        }

        if ($this->isExcludedByDefinition($sectionDefinition) && !$this->shouldBeIncluded($sectionName)) {
            return true;
        }

        return false;
    }
293773
public function addFetchFields($field) {
    if (!is_array($field)) {
      if (!in_array($field, $this->fetches)) {
        $this->fetches[] = $field;
      }
    } else {
      $this->fetches = $field;
    }
  }
144308
public <R, RK> List<R> fetch(Collection<DBRef<R, RK>> collection, DBObject fields) {
        Map<JacksonCollectionKey, List<Object>> collectionsToIds = new HashMap<JacksonCollectionKey, List<Object>>();
        for (DBRef<R, RK> ref : collection) {
            if (ref instanceof FetchableDBRef) {
                JacksonCollectionKey key = ((FetchableDBRef) ref).getCollectionKey();
                List<Object> ids = collectionsToIds.get(key);
                if (ids == null) {
                    ids = new ArrayList<Object>();
                    collectionsToIds.put(key, ids);
                }
                ids.add(getReferenceCollection(key).convertToDbId(ref.getId()));
            }
        }
        List<R> results = new ArrayList<R>();
        for (Map.Entry<JacksonCollectionKey, List<Object>> entry : collectionsToIds.entrySet()) {
            for (R result : this.<R, RK>getReferenceCollection(entry.getKey()).find(
                    new QueryBuilder().put("_id").in(entry.getValue()).get(), fields)) {
                results.add(result);
            }
        }
        return results;
    }
363503
public function hasRelation(string $type, string $section = self::SCHEMA_CLASS): bool
    {
        return isset($this->config[$type][$section]);
    }
613140
public function setFetchMode($class, $assocName, $fetchMode)
    {
        if ($fetchMode !== Mapping\ClassMetadata::FETCH_EAGER) {
            $fetchMode = Mapping\ClassMetadata::FETCH_LAZY;
        }

        $this->_hints['fetchMode'][$class][$assocName] = $fetchMode;

        return $this;
    }
551104
public function fetch($fetchType = 'assoc')
    {
        if ($fetchType === 'num') {
            return $this->statement->fetch(\PDO::FETCH_NUM);
        } elseif ($fetchType === 'assoc') {
            return $this->statement->fetch(\PDO::FETCH_ASSOC);
        } elseif ($fetchType === 'obj') {
            return $this->statement->fetch(\PDO::FETCH_OBJ);
        }
    }
663511
function _fetch($ignore_fields=false)
   {
      $this->fields = array();
      $fields = @sqlite_fetch_array($this->_queryID,$this->fetchMode);
      if(is_array($fields))
         foreach($fields as $n => $v)
         {
            if(($p = strpos($n, ".")) !== false)
               $n = substr($n, $p+1);
            $this->fields[$n] = $v;
         }

      return !empty($this->fields);
   }
643219
public function validateSections(ElementInterface $element)
	{
		$value = $element->getFieldValue($this->handle);

		if (!is_array($value)) {
			$value = [$value];
		}

		$sections = $this->getSections();

		foreach ($value as $section) {
			if (!isset($sections[$section])) {
				$element->addError($this->handle, Craft::t('section-field', 'Invalid section selected.'));
			}
		}
	}
366077
private function FetchFields($parent)
    {
        $child= $this->tree->FirstChildOf($parent);
        while ($child)
        {
            $this->HandleField($child);
            $this->FetchFields($child);
            $child = $this->tree->NextOf($child);   
        }
    }
484165
protected function endSection()
    {
        if (empty($this->scope->sectionStack)) {
            throw new InvalidArgumentException('Cannot end a section without first starting one.');
        }

        $last = array_pop($this->scope->sectionStack);
        $this->storeSection($last, ob_get_clean());
    }
463982
protected function shouldSectionBeAdded(string $sectionName, array $sectionDefinition): bool
    {
        if ($this->containsRequestedGroup($sectionDefinition)) {
            return true;
        }

        if ($this->onlyRunSelected()) {
            return $this->isSectionRequested($sectionName);
        }

        if (!$this->isSectionExcluded($sectionName, $sectionDefinition)) {
            return true;
        }

        return false;
    }
45715
public function isConfigured(array $keys, string $section): bool
    {
        if (!array_key_exists($section, $this->configuration)) {
            return false;
        }

        return !array_diff_key(array_flip($keys), $this->configuration[$section]);
    }