Loads the supplied column.

@param string $columnName

@return static
320939
public function load(string $columnName)
    {
        $this->columnsToLoad[$columnName] = $this->structure->getColumn($columnName);

        return $this;
    }
1244392
public function remove($columnName)
    {
        if (isset($this->filterDefinitions[$columnName])) {
            unset($this->filterDefinitions[$columnName]);
        }

        return $this;
    }
801562
public static function getCurrent($columnName = '')
    {
        if ($columnName) {
            if (isset(self::$currentMenuLink->$columnName)) {
                return self::$currentMenuLink->$columnName;
            }
            return;
        }
        return self::$currentMenuLink;
    }
399265
public function addColumn(Column $column)
    {
        $this->columns[] = $column;

        if ($column instanceof ColumnInterface) {
            $column->initialize($this);
        }

        return $this;
    }
335456
public function getColumnType($tableName, $columnName) {
        $columns = $this->getTableColumns($tableName);
        foreach ($columns as $column) {
            if ($column['Field'] != $columnName)
                continue;
            $type = explode('(', $column['Type'], 2);
            return $type[0];
        }
        throw new \Exception("Column `$columnName` not found in table `$tableName`!");
    }
1189387
public function load($filename)
    {
        $json = file_get_contents($filename);
        if (false === $json) {
            // @codeCoverageIgnoreStart
            throw new \RuntimeException("Unable to load file {$filename}");
            // @codeCoverageIgnoreEnd
        }

        $data = Utils::jsonDecode($json, true);
        if (is_array($data)) {
            foreach (Utils::jsonDecode($json, true) as $cookie) {
                $this->setCookie(new SetCookie($cookie));
            }
        } elseif (strlen($data)) {
            throw new \RuntimeException("Invalid cookie file: {$filename}");
        }
    }
1305076
public function bigIncrements($columnName)
    {
        $column = $this->bigInteger($columnName, true, true);
        $this->primary($columnName);

        return $column;
    }
512410
public function isNull(string $columnName)
    {
        $this->addCondition('AND', $this->dialect()->quoteName($columnName) . ' IS NULL');

        return $this;
    }
923987
public function column(string $name, ?string $key = null): self
    {
        return new static(array_column($this->storage, $name, $key));
    }
1119315
public function orIsNotNull(string $columnName)
    {
        $this->addCondition('OR', $this->dialect()->quoteName($columnName) . ' IS NOT NULL');

        return $this;
    }
259293
public function to(string $columnName) : ColumnTypeDefinerWithVersioning
    {
        return new ColumnTypeDefinerWithVersioning(
                $this->definition,
                $this->callback,
                $this->phpToDbConverter,
                $this->dbToPhpConverter,
                $this->propertyName,
                $columnName,
                $this->ignoreNullabilityTypeMismatch
        );
    }
793860
public function addColumn($columnName, $typeName, array $options = [])
    {
        $column = new Column($columnName, Type::getType($typeName), $options);

        $this->_addColumn($column);

        return $column;
    }
173010
public function primaryKey(string $columnName)
    {
        $this->primaryKey = $this->buildPrimaryKeyColumn($columnName);
        $this->columns    = [$columnName => $this->primaryKey] + $this->columns;
    }
727214
public function getFieldName($columnName)
    {
        return isset($this->fieldNames[$columnName]) ?
                $this->fieldNames[$columnName] : $columnName;
    }
557782
public function withParentIdAs(string $columnName)
    {
        call_user_func($this->callback, function ($idString, Table $parentTable) use ($columnName) {
            /** @var IEntityMapper $mapper */
            $mapper = call_user_func($this->mapperLoader);
            $mapper->addForeignKey(ForeignKey::createWithNamingConvention(
                $mapper->getPrimaryTableName(),
                [$columnName],
                $parentTable->getName(),
                [$parentTable->getPrimaryKeyColumnName()],
                $this->identifying
                    ? ForeignKeyMode::CASCADE
                    : ForeignKeyMode::SET_NULL,
                ForeignKeyMode::CASCADE
            ));

            if ($this->orderPersistColumn) {
                $persistHook = new OrderIndexPropertyLoaderHook(
                    $mapper->getObjectType(),
                    $mapper->getPrimaryTable(),
                    $this->orderPersistColumn,
                    $columnName,
                    $mapper->getDefinition()->getPropertyLinkedToColumn($this->orderPersistColumn)
                );

                $mapper->addPersistHook($persistHook);
                $persistHookId = $persistHook->getIdString();
            } else {
                $persistHookId = null;
            }

            return new ToManyRelation(
                $idString,
                $this->loadIds
                    ? new ToManyRelationIdentityReference($mapper, $this->bidirectionalRelationProperty)
                    : new ToManyRelationObjectReference($mapper, $this->bidirectionalRelationProperty, $persistHookId),
                $columnName,
                $this->identifying
                    ? new IdentifyingRelationMode()
                    : new NonIdentifyingRelationMode(),
                $this->orderByColumnNameDirectionMap,
                $this->orderPersistColumn
            );
        });
    }
31428
public function load($fileName) {
		if (!file_exists($fileName)) {
			throw new \InvalidArgumentException('File ' . $fileName . ' does not exist');
		}

		$lines = $this->readLinesFromFile($fileName);

		return $this->getArrayFromLines($lines);
	}
330981
public function getFieldForColumn($columnName)
    {
        if (isset($this->fieldNames[$columnName])) {
            return $this->fieldNames[$columnName];
        } else {
            foreach ($this->associationMappings as $assocName => $mapping) {
                if ($this->isAssociationWithSingleJoinColumn($assocName) &&
                    $this->associationMappings[$assocName]['joinColumns'][0]['name'] == $columnName) {

                    return $assocName;
                }
            }

            throw MappingException::noFieldNameFoundForColumn($this->name, $columnName);
        }
    }