@param Column $column

@return bool

@throws PropelException
16073
protected function isColumnForeignKeyOrDuplicated(Column $column)
    {
        $delegateTable = $column->getTable();
        $table = $this->getTable();
        $fks = [];

        if (!isset($this->double_defined)) {
            $this->double_defined = [];

            foreach ($this->delegates+[$table->getName() => 1] as $key => $value) {
                $delegateTable = $this->getDelegateTable($key);
                foreach ($delegateTable->getColumns() as $columnDelegated) {
                    if (isset($this->double_defined[$columnDelegated->getName()])) {
                        $this->double_defined[$columnDelegated->getName()]++;
                    } else {
                        $this->double_defined[$columnDelegated->getName()] = 1;
                    }
                }
            }
        }

        if (1<$this->double_defined[$column->getName()]) {
            return true;
        }

        foreach ($delegateTable->getForeignKeysReferencingTable($table->getName()) as $fk) {
            /** @var \Propel\Generator\Model\ForeignKey $fk */
            $fks[] = $fk->getForeignColumnName();
        }

        foreach ($table->getForeignKeysReferencingTable($delegateTable->getName()) as $fk) {
            $fks[] = $fk->getForeignColumnName();
        }

        if (in_array($column->getName(), $fks) || $table->hasColumn($column->getName())) {
            return true;
        }

        return false;
    }
128292
public function orWhereIs(string $column)
    {
        $instance = $this->whereStrategyInstance();

        $instance->whereStrategy()->orWhereIs($column);

        return $instance;
    }
196993
public function handleShowColumn($column)
	{
		$columns = $this->getSessionData('_grid_hidden_columns');

		if (!empty($columns)) {
			$pos = array_search($column, $columns, true);

			if ($pos !== false) {
				unset($columns[$pos]);
			}
		}

		$this->saveSessionData('_grid_hidden_columns', $columns);
		$this->saveSessionData('_grid_hidden_columns_manipulated', true);

		$this->redrawControl();

		$this->onRedraw();
	}
1277800
public function column_check( $id = false, $column = false )
	{
		$sql = "SELECT COLUMN_CHECK($column) FROM `{$this->table}` WHERE id = :id";
		$params = [ ':id' => $id ];

		return $this->select_one( $sql, $params );
	}
568491
function is_sortable($column = null) {
        if (empty($column)) {
            return $this->is_sortable;
        }
        if (!$this->is_sortable) {
            return false;
        }
        return !in_array($column, $this->column_nosort);
    }
920894
protected function _isDirty($column = null)
    {
        if ($column) {
            return array_key_exists($column, $this->_cleanData);
        }
        return !empty($this->_cleanData);
    }
916940
public static function hasColumn(\Illuminate\Database\Eloquent\Model $model, string $column): bool
    {
        $table = $model->getTable();
        $columns = app('cache')->remember('amigrid.columns.' . $table, 60, function () use ($table) {
            return \Schema::getColumnListing($table);
        });
        return array_search($column, $columns) !== false;
    }
1271255
protected function isSortable($column = null)
    {
        if ($column === null) {
            return (count($this->getSortableColumns()) > 0);
        }

        return array_key_exists($column, $this->getSortableColumns());
    }
1112848
public function addColumn(Column $column)
    {
        $columns = func_get_args();

        foreach ($columns as $column) {
            $this->columns[$column->columnName] = $column;

            if ($column instanceof AutoIncrementColumn) {
                $this->uniqueIdentifierColumnName = $column->columnName;
            }
        }
    }
598510
public function exists(string $column): bool
    {
        if (trim($column) === '') {
            throw new Exception\InvalidArgumentException(__METHOD__ . ' Column name cannot be empty');
        }

        return $this->columns->offsetExists($column);
    }
349549
public function setSortColumn($column)
    {
        $this->sortColumn = null;

        $found = false;
        foreach ($this->getColumns() as $id => $params) {
            if ($id == $column) {
                $found = ($params['sortable'] === true);
                break;
            }
        }

        if ($found)
            $this->sortColumn = $column;

        return $this;
    }
206165
protected function prepareBindingColumn($column)
    {
        $count = $this->columnCountForWhereClause($column);
        return ($count > 0) ? $column .'_'. ($count + 1) : $column;
    }
11718
protected function prepareColumn(Column $column)
    {
        /** @var PostgresqlType $typeMapper */
        $typeMapper = $this->getDataType();

        $type = $typeMapper::getType($column->getType());

        $length = $typeMapper::noLength($type) ? null : $column->getLength();

        $column->length($length);

        if ($column->getAutoIncrement()) {
            $column->type(PostgresqlType::SERIAL);
            $options['sequences'][$column->getName()] = $this->getName() . '_' . $column->getName() . '_seq';
        }

        return parent::prepareColumn($column);
    }
1152883
protected function column(Column $column) : ColumnExpr
    {
        return Expr::column($this->relatedTable->getName(), $column);
    }
705795
public function isIdentity($column)
    {
        $this->_setupPrimaryKey();

        if (!isset($this->_metadata[$column])) {
            /**
             * @see Zend_Db_Table_Exception
             */
            // require_once 'Zend/Db/Table/Exception.php';

            throw new Zend_Db_Table_Exception('Column "' . $column . '" not found in table.');
        }

        return (bool) $this->_metadata[$column]['IDENTITY'];
    }
400238
public function havingIsNot(string $column)
    {
        $instance = $this->havingStrategyInstance();

        $instance->havingStrategy()->havingIsNot($column);

        return $instance;
    }
733124
public function orHavingIsNot(string $column)
    {
        $instance = $this->havingStrategyInstance();

        $instance->havingStrategy()->orHavingIsNot($column);

        return $instance;
    }