Is search column.

@param AbstractColumn $column

@return bool
359190
private function isSearchColumn(AbstractColumn $column)
    {
        if (false === $this->configs['search_on_non_visible_columns']) {
            if (null !== $column->getDql() && true === $column->getSearchable() && true === $column->getVisible()) {
                return true;
            }
        } else {
            if (null !== $column->getDql() && true === $column->getSearchable()) {
                return true;
            }
        }

        return false;
    }
90362
protected function isValid($column) {
        return in_array(strtoupper($column->geomtype), PostgisGrammar::$allowed_geom_types) && is_int((int) $column->srid);
    }
869181
public function whereIsNotNull(string $column)
    {
        $instance = $this->whereStrategyInstance();

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

        return $instance;
    }
295630
public function has($primaryKey, $column = null)
    {
        if (null === $column) {
            $column = $this->getPrimaryKey();
        }

        return (boolean)$this->app['db']->fetchColumn(
            'SELECT COUNT(:column) FROM ' . $this->getTable() . ' WHERE '.$this->getPrimaryKey().' = :pk',
            [
                'column' => $column,
                'pk' => $primaryKey
            ]
        );
    }
1257833
public function findForeignKey(string $column): ?AbstractForeignKey
    {
        foreach ($this->foreignKeys as $reference) {
            if ($reference->getColumn() == $column) {
                return $reference;
            }
        }

        return null;
    }
153402
public function changedColumnIs($column)
	{
		if( !$this->recordExists() )
		{
			return true;
		}
		elseif( $this->_recordAccess($column) && $this->_changedColumnAccess($column) )
		{
			return $this->recordColumnGet($column) != $this->changeRecordData[$column];
		}
		else
		{
			return true;
		}
	}
1180944
public function isHidden($column)
    {
        $attributes = $this->config('hidden', []);

        if (! is_array($attributes)) {
            throw new \RuntimeException('Config field [hidden] must be an array of attributes to hide from array or json.');
        }

        foreach ($attributes as $pattern) {
            if (Str::is($pattern, $column)) {
                return true;
            }
        }

        return false;
    }
702615
public function canSortBy($column)
    {
        return array_key_exists($column, $this->sortable) || in_array($column, $this->sortable, true);
    }
648974
public function findIndex(array $columns): ?AbstractIndex
    {
        foreach ($this->indexes as $index) {
            if ($index->getColumns() == $columns) {
                return $index;
            }
        }

        return null;
    }
869206
public function is($value, bool $is_column = false): WhereStatement
    {
        return $this->addCondition($value, '=', $is_column);
    }
874951
public static function hasColumn($column)
    {
        $cls  = get_called_class();
        $key  = null;
        $keys = self::$_columns[$cls];

        foreach ($keys as $ckey) {
            $col1 = self::isIgnoringCase() ? strtolower($ckey)   : $ckey;
            $col2 = self::isIgnoringCase() ? strtolower($column) : $column;
            if ($col1==$col2) {
                $key = $ckey;
                break;
            }
        }
        return $key;
    }
952763
protected function checkColumnsValidity(): void
    {
        $this->getAttribute('columns')->map(function (TableListColumn $column) {
            $this->checkSortableColumnHasAttribute($column);
            $isSearchable = in_array(
                $column->getAttribute('attribute'),
                $this->getAttribute('searchableColumns')->pluck('attribute')->toArray()
            );
            if ($isSearchable) {
                $this->checkSearchableColumnHasAttribute($column);
                $this->checkSearchedAttributeDoesExistInRelatedTable($column);
            }
        });
    }
88131
public boolean hasTableOrColumn(String table, String column) {

        String tableName, columnName;
        boolean result;

        tableName = table == null ? null : table.toUpperCase();
        columnName = column == null ? null : column.toUpperCase();
        result = hasTableOrColumnCaseSensitive(tableName, columnName);

        if (!result) {
            tableName = table == null ? null : table.toLowerCase();
            columnName = column == null ? null : column.toLowerCase();
            result = result || hasTableOrColumnCaseSensitive(tableName, columnName);
        }

        return result;
    }
507524
private function isScalar(\ColumnMap $column)
    {
        return in_array($column->getPdoType(), array(
            \PDO::PARAM_BOOL,
            \PDO::PARAM_INT,
            \PDO::PARAM_STR,
        ));
    }
908603
public function isSinglePrimaryKeyColumn(Table $table, Column $column)
    {
        $options = $table->getOptions();

        if (! $options && $column->getName() === 'id') return true;
        if (isset($options['id']) && $options['id'] == $column->getName()) return true;

        return false;
    }
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'];
    }
928246
public function addColumn($col)
    {
        if (!$col instanceof Column\AbstractColumn) {
            $col = $this->createColumn($col);
        }

        if (null === $col->getPosition()) {
            $col->setPosition(self::DEFAULT_POSITION);
        }

        $this->columns[$col->getUniqueId()] = $col;
        $this->positions[$col->getPosition()][$col->getUniqueId()] = $col;
    }