@param \Doctrine\DBAL\Schema\Column $column

@return string
970935
private static function generateFloatInput($column)
    {
        $fieldInput = $column->getName().':float,'.$column->getPrecision().','.$column->getScale();

        return $fieldInput;
    }
298368
protected function formatName($column)
    {
        if (is_string($column)) {
            $name = explode('.', $column);

            if (1 === count($name)) {
                return $name[0];
            }

            $html = array_shift($name);
            foreach ($name as $piece) {
                $html .= "[$piece]";
            }

            return $html;
        }

        if (is_array($this->column)) {
            $names = [];
            foreach ($this->column as $key => $name) {
                $names[$key] = $this->formatName($name);
            }

            return $names;
        }

        return '';
    }
288186
protected function getColumnSqlDefinition(Column $column)
    {
        $buffer = [];
        if ($column->isIdentity()) {
            $buffer[] = $column->getType() === 'biginteger' ? 'BIGSERIAL' : 'SERIAL';
        } else {
            $sqlType = $this->getSqlType($column->getType(), $column->getLimit());
            $buffer[] = \strtoupper($sqlType['name']);
            // integers cant have limits in postgres
            if (static::PHINX_TYPE_DECIMAL === $sqlType['name'] && ($column->getPrecision() || $column->getScale())) {
                $buffer[] = \sprintf(
                    '(%s, %s)',
                    $column->getPrecision() ?: $sqlType['precision'],
                    $column->getScale() ?: $sqlType['scale']
                );
            } elseif ($sqlType['name'] === 'geography') {
                // geography type must be written with geometry type and srid, like this: geography(POLYGON,4326)
                $buffer[] = \sprintf(
                    '(%s,%s)',
                    \strtoupper($sqlType['type']),
                    $sqlType['srid']
                );
            } elseif (!\in_array($sqlType['name'], ['integer', 'smallint', 'bigint'], true)) {
                if ($column->getLimit() || isset($sqlType['limit'])) {
                    $buffer[] = sprintf('(%s)', $column->getLimit() ?: $sqlType['limit']);
                }
            }

            $timeTypes = [
                'time',
                'timestamp',
            ];
            if (in_array($sqlType['name'], $timeTypes) && $column->isTimezone()) {
                $buffer[] = strtoupper('with time zone');
            }
        }

        $buffer[] = $column->isNull() ? 'NULL' : 'NOT NULL';

        if (null !== $column->getDefault()) {
            $buffer[] = $this->getDefaultValueDefinition($column->getDefault());
        }

        return implode(' ', $buffer);
    }
466435
protected function stripTableForPluck(string $column): ?string
    {
        return \is_null($column) ? $column : \last(\preg_split('~\.| ~', $column));
    }
947840
public function getColumn(string $column)
    {
        return isset($this->columnData[$column]) ? $this->columnData[$column] : null;
    }
645856
public function getColumnName( $column )
    {
        if ( $this->getColumnsUseTranslation() )
        {
            $column = $this->view->translate(
                $this->getColumnId( $column ),
                $this->getColumnTranslateTextDomain()
            );
        }

        return $column;
    }
276349
protected function stripTableForPluck($column)
    {
        if ($column !== null) {
            $column = preg_split('~\.| ~', $column);
            $column = end($column);
        }
        return $column ;
    }
37358
public function renderColumnLabel(Column $column): string
    {
        $label = $column->getLabel();
        if (!$label) {
            $key = "datagrid.{$column->getDataGrid()->getCode()}.{$column->getCode()}";
            if ($this->translator instanceof TranslatorBagInterface
                && $this->translator->getCatalogue()
                && $this->translator->getCatalogue()->has($key)
            ) {
                $label = $key;
            } else {
                $label = ucfirst(
                    strtolower(trim(preg_replace(['/([A-Z])/', '/[_\s]+/'], ['_$1', ' '], $column->getCode())))
                );
            }
        }

        return $this->translator->trans($label);
    }
1239951
private function columnToArray(Column $column)
    {
        return array_filter([
            'columnName' => $column->name,
            'length' => $column->length,
            'nullable' => $column->nullable,
            'unique' => $column->unique,
            'options' => $column->options,
            'precision' => $column->precision,
            'scale' => $column->scale,
            'columnDefinition' => $column->columnDefinition,
        ]);
    }
199861
protected function resolveRelationColumn($column)
    {
        $parts      = explode('.', $column);
        $columnName = array_pop($parts);
        $relation   = implode('.', $parts);

        if ($this->isNotEagerLoaded($relation)) {
            return $column;
        }

        return $this->joinEagerLoadedColumn($relation, $columnName);
    }
8642
private function columnName($column)
    {
        // Select all
        if ($column == '*') {
            return "`{$this->query['table']}`.*";
        }

        if (strpos($column, '.') === false) {
            $column = $this->query['table'] . ".{$column}";
        }

        // Regular column name
        if (strpos($column, '(') === false) {
            return str_replace(array('.'), array('`.`'), "`{$column}`");
        } else {
            return trim(str_replace(array('(', ')', '.'), array('(`', '`)', '`.`'), $column), '`');
        }
    }
283560
protected function _getTextColumn(Column\Text $column)
    {
        $type = 'TEXT';

        return sprintf(
            '%s %s%s',
            $column->getName(),
            $type,
            $this->_nullableColumn($column)
        );
    }
731584
public function column($column = null)
    {
        $result = array();

        while ($record = $this->next()) {
            if ($column) {
                $result[] = $record[$column];
            } else {
                $result[] = $record[key($record)];
            }
        }

        return $result;
    }
684268
public function getCol($column = 0)
    {
        $sql = $this->toSQL();
        return $this->table->getCol($sql, $this->getParams(), $column);
    }
171070
private function prepareColumn(array $column)
    {
        if ($column['sql'] instanceof self) {
            [$sql, $params] = $column['sql']->toSql();

            $column['sql'] = '(' . $sql . ')';

            $column['params'] = $params;
        }

        return $column;
    }
1211234
protected function mapColumnTypeToFieldType(Column $column)
    {
        foreach ($this->typesMap as $type => $classes) {
            if (in_array($typeClass = $this->columnType($column), $classes, true)) {
                if ('StringType' === $typeClass) {
                    if (connection('mysql') && null === $column->getLength()) {
                        return 'radio';
                    }
                }

                return $type;
            }
        }

        return 'text';
    }
189186
public static function doctrineLengthToMigrationLength($column)
    {
        $typeName = $column->getType()->getName();
        $migrationTypeName = self::toMigrationMethodName($typeName, $column->getName());

        if (in_array($migrationTypeName, self::getDecimalTypes())) {
            return $column->getPrecision().','.$column->getScale();
        }

        if (in_array($migrationTypeName, self::getIntegerTypes())) {
            return $column->getPrecision();
        }

        return $column->getLength();
    }