Subversion-Projekte lars-tiefland.laravel_shop

<?php

namespace Illuminate\Database\Schema\Grammars;

use Illuminate\Database\Connection;

use Illuminate\Database\Schema\Blueprint;

use Illuminate\Support\Fluent;

class PostgresGrammar extends Grammar

{

    /**

     * If this Grammar supports schema changes wrapped in a transaction.

     *

     * @var bool

     */

    protected $transactions = true;

    /**

     * The possible column modifiers.

     *

     * @var string[]

     */

    protected $modifiers = ['Collate', 'Increment', 'Nullable', 'Default', 'VirtualAs', 'StoredAs'];

    /**

     * The columns available as serials.

     *

     * @var string[]

     */

    protected $serials = ['bigInteger', 'integer', 'mediumInteger', 'smallInteger', 'tinyInteger'];

    /**

     * The commands to be executed outside of create or alter command.

     *

     * @var string[]

     */

    protected $fluentCommands = ['Comment'];

    /**

     * Compile a create database command.

     *

     * @param  string  $name

     * @param  \Illuminate\Database\Connection  $connection

     * @return string

     */

    public function compileCreateDatabase($name, $connection)

    {

        return sprintf(

            'create database %s encoding %s',

            $this->wrapValue($name),

            $this->wrapValue($connection->getConfig('charset')),

        );

    }

    /**

     * Compile a drop database if exists command.

     *

     * @param  string  $name

     * @return string

     */

    public function compileDropDatabaseIfExists($name)

    {

        return sprintf(

            'drop database if exists %s',

            $this->wrapValue($name)

        );

    }

    /**

     * Compile the query to determine if a table exists.

     *

     * @return string

     */

    public function compileTableExists()

    {

        return "select * from information_schema.tables where table_catalog = ? and table_schema = ? and table_name = ? and table_type = 'BASE TABLE'";

    }

    /**

     * Compile the query to determine the list of columns.

     *

     * @return string

     */

    public function compileColumnListing()

    {

        return 'select column_name from information_schema.columns where table_catalog = ? and table_schema = ? and table_name = ?';

    }

    /**

     * Compile a create table command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return array

     */

    public function compileCreate(Blueprint $blueprint, Fluent $command)

    {

        return array_values(array_filter(array_merge([sprintf('%s table %s (%s)',

            $blueprint->temporary ? 'create temporary' : 'create',

            $this->wrapTable($blueprint),

            implode(', ', $this->getColumns($blueprint))

        )], $this->compileAutoIncrementStartingValues($blueprint))));

    }

    /**

     * Compile a column addition command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileAdd(Blueprint $blueprint, Fluent $command)

    {

        return array_values(array_filter(array_merge([sprintf('alter table %s %s',

            $this->wrapTable($blueprint),

            implode(', ', $this->prefixArray('add column', $this->getColumns($blueprint)))

        )], $this->compileAutoIncrementStartingValues($blueprint))));

    }

    /**

     * Compile the auto-incrementing column starting values.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @return array

     */

    public function compileAutoIncrementStartingValues(Blueprint $blueprint)

    {

        return collect($blueprint->autoIncrementingStartingValues())->map(function ($value, $column) use ($blueprint) {

            return 'alter sequence '.$blueprint->getTable().'_'.$column.'_seq restart with '.$value;

        })->all();

    }

    /**

     * Compile a rename column command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @param  \Illuminate\Database\Connection  $connection

     * @return array|string

     */

    public function compileRenameColumn(Blueprint $blueprint, Fluent $command, Connection $connection)

    {

        return $connection->usingNativeSchemaOperations()

            ? sprintf('alter table %s rename column %s to %s',

                $this->wrapTable($blueprint),

                $this->wrap($command->from),

                $this->wrap($command->to)

            )

            : parent::compileRenameColumn($blueprint, $command, $connection);

    }

    /**

     * Compile a primary key command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compilePrimary(Blueprint $blueprint, Fluent $command)

    {

        $columns = $this->columnize($command->columns);

        return 'alter table '.$this->wrapTable($blueprint)." add primary key ({$columns})";

    }

    /**

     * Compile a unique key command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileUnique(Blueprint $blueprint, Fluent $command)

    {

        $sql = sprintf('alter table %s add constraint %s unique (%s)',

            $this->wrapTable($blueprint),

            $this->wrap($command->index),

            $this->columnize($command->columns)

        );

        if (! is_null($command->deferrable)) {

            $sql .= $command->deferrable ? ' deferrable' : ' not deferrable';

        }

        if ($command->deferrable && ! is_null($command->initiallyImmediate)) {

            $sql .= $command->initiallyImmediate ? ' initially immediate' : ' initially deferred';

        }

        return $sql;

    }

    /**

     * Compile a plain index key command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileIndex(Blueprint $blueprint, Fluent $command)

    {

        return sprintf('create index %s on %s%s (%s)',

            $this->wrap($command->index),

            $this->wrapTable($blueprint),

            $command->algorithm ? ' using '.$command->algorithm : '',

            $this->columnize($command->columns)

        );

    }

    /**

     * Compile a fulltext index key command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     *

     * @throws \RuntimeException

     */

    public function compileFulltext(Blueprint $blueprint, Fluent $command)

    {

        $language = $command->language ?: 'english';

        $columns = array_map(function ($column) use ($language) {

            return "to_tsvector({$this->quoteString($language)}, {$this->wrap($column)})";

        }, $command->columns);

        return sprintf('create index %s on %s using gin ((%s))',

            $this->wrap($command->index),

            $this->wrapTable($blueprint),

            implode(' || ', $columns)

        );

    }

    /**

     * Compile a spatial index key command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileSpatialIndex(Blueprint $blueprint, Fluent $command)

    {

        $command->algorithm = 'gist';

        return $this->compileIndex($blueprint, $command);

    }

    /**

     * Compile a foreign key command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileForeign(Blueprint $blueprint, Fluent $command)

    {

        $sql = parent::compileForeign($blueprint, $command);

        if (! is_null($command->deferrable)) {

            $sql .= $command->deferrable ? ' deferrable' : ' not deferrable';

        }

        if ($command->deferrable && ! is_null($command->initiallyImmediate)) {

            $sql .= $command->initiallyImmediate ? ' initially immediate' : ' initially deferred';

        }

        if (! is_null($command->notValid)) {

            $sql .= ' not valid';

        }

        return $sql;

    }

    /**

     * Compile a drop table command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileDrop(Blueprint $blueprint, Fluent $command)

    {

        return 'drop table '.$this->wrapTable($blueprint);

    }

    /**

     * Compile a drop table (if exists) command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileDropIfExists(Blueprint $blueprint, Fluent $command)

    {

        return 'drop table if exists '.$this->wrapTable($blueprint);

    }

    /**

     * Compile the SQL needed to drop all tables.

     *

     * @param  array  $tables

     * @return string

     */

    public function compileDropAllTables($tables)

    {

        return 'drop table '.implode(',', $this->escapeNames($tables)).' cascade';

    }

    /**

     * Compile the SQL needed to drop all views.

     *

     * @param  array  $views

     * @return string

     */

    public function compileDropAllViews($views)

    {

        return 'drop view '.implode(',', $this->escapeNames($views)).' cascade';

    }

    /**

     * Compile the SQL needed to drop all types.

     *

     * @param  array  $types

     * @return string

     */

    public function compileDropAllTypes($types)

    {

        return 'drop type '.implode(',', $this->escapeNames($types)).' cascade';

    }

    /**

     * Compile the SQL needed to retrieve all table names.

     *

     * @param  string|array  $searchPath

     * @return string

     */

    public function compileGetAllTables($searchPath)

    {

        return "select tablename, concat('\"', schemaname, '\".\"', tablename, '\"') as qualifiedname from pg_catalog.pg_tables where schemaname in ('".implode("','", (array) $searchPath)."')";

    }

    /**

     * Compile the SQL needed to retrieve all view names.

     *

     * @param  string|array  $searchPath

     * @return string

     */

    public function compileGetAllViews($searchPath)

    {

        return "select viewname, concat('\"', schemaname, '\".\"', viewname, '\"') as qualifiedname from pg_catalog.pg_views where schemaname in ('".implode("','", (array) $searchPath)."')";

    }

    /**

     * Compile the SQL needed to retrieve all type names.

     *

     * @return string

     */

    public function compileGetAllTypes()

    {

        return 'select distinct pg_type.typname from pg_type inner join pg_enum on pg_enum.enumtypid = pg_type.oid';

    }

    /**

     * Compile a drop column command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileDropColumn(Blueprint $blueprint, Fluent $command)

    {

        $columns = $this->prefixArray('drop column', $this->wrapArray($command->columns));

        return 'alter table '.$this->wrapTable($blueprint).' '.implode(', ', $columns);

    }

    /**

     * Compile a drop primary key command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileDropPrimary(Blueprint $blueprint, Fluent $command)

    {

        $index = $this->wrap("{$blueprint->getTable()}_pkey");

        return 'alter table '.$this->wrapTable($blueprint)." drop constraint {$index}";

    }

    /**

     * Compile a drop unique key command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileDropUnique(Blueprint $blueprint, Fluent $command)

    {

        $index = $this->wrap($command->index);

        return "alter table {$this->wrapTable($blueprint)} drop constraint {$index}";

    }

    /**

     * Compile a drop index command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileDropIndex(Blueprint $blueprint, Fluent $command)

    {

        return "drop index {$this->wrap($command->index)}";

    }

    /**

     * Compile a drop fulltext index command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileDropFullText(Blueprint $blueprint, Fluent $command)

    {

        return $this->compileDropIndex($blueprint, $command);

    }

    /**

     * Compile a drop spatial index command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileDropSpatialIndex(Blueprint $blueprint, Fluent $command)

    {

        return $this->compileDropIndex($blueprint, $command);

    }

    /**

     * Compile a drop foreign key command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileDropForeign(Blueprint $blueprint, Fluent $command)

    {

        $index = $this->wrap($command->index);

        return "alter table {$this->wrapTable($blueprint)} drop constraint {$index}";

    }

    /**

     * Compile a rename table command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileRename(Blueprint $blueprint, Fluent $command)

    {

        $from = $this->wrapTable($blueprint);

        return "alter table {$from} rename to ".$this->wrapTable($command->to);

    }

    /**

     * Compile a rename index command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileRenameIndex(Blueprint $blueprint, Fluent $command)

    {

        return sprintf('alter index %s rename to %s',

            $this->wrap($command->from),

            $this->wrap($command->to)

        );

    }

    /**

     * Compile the command to enable foreign key constraints.

     *

     * @return string

     */

    public function compileEnableForeignKeyConstraints()

    {

        return 'SET CONSTRAINTS ALL IMMEDIATE;';

    }

    /**

     * Compile the command to disable foreign key constraints.

     *

     * @return string

     */

    public function compileDisableForeignKeyConstraints()

    {

        return 'SET CONSTRAINTS ALL DEFERRED;';

    }

    /**

     * Compile a comment command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileComment(Blueprint $blueprint, Fluent $command)

    {

        return sprintf('comment on column %s.%s is %s',

            $this->wrapTable($blueprint),

            $this->wrap($command->column->name),

            "'".str_replace("'", "''", $command->value)."'"

        );

    }

    /**

     * Compile a table comment command.

     *

     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint

     * @param  \Illuminate\Support\Fluent  $command

     * @return string

     */

    public function compileTableComment(Blueprint $blueprint, Fluent $command)

    {

        return sprintf('comment on table %s is %s',

            $this->wrapTable($blueprint),

            "'".str_replace("'", "''", $command->comment)."'"

        );

    }

    /**

     * Quote-escape the given tables, views, or types.

     *

     * @param  array  $names

     * @return array

     */

    public function escapeNames($names)

    {

        return array_map(static function ($name) {

            return '"'.collect(explode('.', $name))

                ->map(fn ($segment) => trim($segment, '\'"'))

                ->implode('"."').'"';

        }, $names);

    }

    /**

     * Create the column definition for a char type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeChar(Fluent $column)

    {

        if ($column->length) {

            return "char({$column->length})";

        }

        return 'char';

    }

    /**

     * Create the column definition for a string type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeString(Fluent $column)

    {

        if ($column->length) {

            return "varchar({$column->length})";

        }

        return 'varchar';

    }

    /**

     * Create the column definition for a tiny text type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeTinyText(Fluent $column)

    {

        return 'varchar(255)';

    }

    /**

     * Create the column definition for a text type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeText(Fluent $column)

    {

        return 'text';

    }

    /**

     * Create the column definition for a medium text type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeMediumText(Fluent $column)

    {

        return 'text';

    }

    /**

     * Create the column definition for a long text type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeLongText(Fluent $column)

    {

        return 'text';

    }

    /**

     * Create the column definition for an integer type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeInteger(Fluent $column)

    {

        return $this->generatableColumn('integer', $column);

    }

    /**

     * Create the column definition for a big integer type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeBigInteger(Fluent $column)

    {

        return $this->generatableColumn('bigint', $column);

    }

    /**

     * Create the column definition for a medium integer type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeMediumInteger(Fluent $column)

    {

        return $this->generatableColumn('integer', $column);

    }

    /**

     * Create the column definition for a tiny integer type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeTinyInteger(Fluent $column)

    {

        return $this->generatableColumn('smallint', $column);

    }

    /**

     * Create the column definition for a small integer type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeSmallInteger(Fluent $column)

    {

        return $this->generatableColumn('smallint', $column);

    }

    /**

     * Create the column definition for a generatable column.

     *

     * @param  string  $type

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function generatableColumn($type, Fluent $column)

    {

        if (! $column->autoIncrement && is_null($column->generatedAs)) {

            return $type;

        }

        if ($column->autoIncrement && is_null($column->generatedAs)) {

            return with([

                'integer' => 'serial',

                'bigint' => 'bigserial',

                'smallint' => 'smallserial',

            ])[$type];

        }

        $options = '';

        if (! is_bool($column->generatedAs) && ! empty($column->generatedAs)) {

            $options = sprintf(' (%s)', $column->generatedAs);

        }

        return sprintf(

            '%s generated %s as identity%s',

            $type,

            $column->always ? 'always' : 'by default',

            $options

        );

    }

    /**

     * Create the column definition for a float type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeFloat(Fluent $column)

    {

        return $this->typeDouble($column);

    }

    /**

     * Create the column definition for a double type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeDouble(Fluent $column)

    {

        return 'double precision';

    }

    /**

     * Create the column definition for a real type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeReal(Fluent $column)

    {

        return 'real';

    }

    /**

     * Create the column definition for a decimal type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeDecimal(Fluent $column)

    {

        return "decimal({$column->total}, {$column->places})";

    }

    /**

     * Create the column definition for a boolean type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeBoolean(Fluent $column)

    {

        return 'boolean';

    }

    /**

     * Create the column definition for an enumeration type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeEnum(Fluent $column)

    {

        return sprintf(

            'varchar(255) check ("%s" in (%s))',

            $column->name,

            $this->quoteString($column->allowed)

        );

    }

    /**

     * Create the column definition for a json type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeJson(Fluent $column)

    {

        return 'json';

    }

    /**

     * Create the column definition for a jsonb type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeJsonb(Fluent $column)

    {

        return 'jsonb';

    }

    /**

     * Create the column definition for a date type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeDate(Fluent $column)

    {

        return 'date';

    }

    /**

     * Create the column definition for a date-time type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeDateTime(Fluent $column)

    {

        return $this->typeTimestamp($column);

    }

    /**

     * Create the column definition for a date-time (with time zone) type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeDateTimeTz(Fluent $column)

    {

        return $this->typeTimestampTz($column);

    }

    /**

     * Create the column definition for a time type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeTime(Fluent $column)

    {

        return 'time'.(is_null($column->precision) ? '' : "($column->precision)").' without time zone';

    }

    /**

     * Create the column definition for a time (with time zone) type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeTimeTz(Fluent $column)

    {

        return 'time'.(is_null($column->precision) ? '' : "($column->precision)").' with time zone';

    }

    /**

     * Create the column definition for a timestamp type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeTimestamp(Fluent $column)

    {

        $columnType = 'timestamp'.(is_null($column->precision) ? '' : "($column->precision)").' without time zone';

        return $column->useCurrent ? "$columnType default CURRENT_TIMESTAMP" : $columnType;

    }

    /**

     * Create the column definition for a timestamp (with time zone) type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeTimestampTz(Fluent $column)

    {

        $columnType = 'timestamp'.(is_null($column->precision) ? '' : "($column->precision)").' with time zone';

        return $column->useCurrent ? "$columnType default CURRENT_TIMESTAMP" : $columnType;

    }

    /**

     * Create the column definition for a year type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeYear(Fluent $column)

    {

        return $this->typeInteger($column);

    }

    /**

     * Create the column definition for a binary type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeBinary(Fluent $column)

    {

        return 'bytea';

    }

    /**

     * Create the column definition for a uuid type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeUuid(Fluent $column)

    {

        return 'uuid';

    }

    /**

     * Create the column definition for an IP address type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeIpAddress(Fluent $column)

    {

        return 'inet';

    }

    /**

     * Create the column definition for a MAC address type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeMacAddress(Fluent $column)

    {

        return 'macaddr';

    }

    /**

     * Create the column definition for a spatial Geometry type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeGeometry(Fluent $column)

    {

        return $this->formatPostGisType('geometry', $column);

    }

    /**

     * Create the column definition for a spatial Point type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typePoint(Fluent $column)

    {

        return $this->formatPostGisType('point', $column);

    }

    /**

     * Create the column definition for a spatial LineString type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeLineString(Fluent $column)

    {

        return $this->formatPostGisType('linestring', $column);

    }

    /**

     * Create the column definition for a spatial Polygon type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typePolygon(Fluent $column)

    {

        return $this->formatPostGisType('polygon', $column);

    }

    /**

     * Create the column definition for a spatial GeometryCollection type.

     *

     * @param  \Illuminate\Support\Fluent  $column

     * @return string

     */

    protected function typeGeometryCollection(Fluent $column)

    {

        return $this->formatPostGisType('geometrycollection', $column);

    }

    /**

     * Create the column definition for a spatial MultiPoint type.

     *