PostgresGrammar.php
TLDR
The file PostgresGrammar.php is a part of the Illuminate\Database\Schema\Grammars namespace and is a class that extends the Grammar class. It contains methods for compiling SQL statements specific to the PostgreSQL database.
Methods
compileCreateDatabase($name, $connection)
Compiles and returns the SQL statement for creating a database in PostgreSQL.
compileDropDatabaseIfExists($name)
Compiles and returns the SQL statement for dropping a database in PostgreSQL if it exists.
compileTableExists()
Compiles and returns the SQL statement for determining if a table exists in the PostgreSQL schema.
compileTables()
Compiles and returns the SQL statement for determining the tables in the PostgreSQL schema.
compileViews()
Compiles and returns the SQL statement for determining the views in the PostgreSQL schema.
compileTypes()
Compiles and returns the SQL statement for determining the user-defined types in the PostgreSQL schema.
compileGetAllTables($searchPath)
Compiles and returns the SQL statement for retrieving all table names in the PostgreSQL schema.
compileGetAllViews($searchPath)
Compiles and returns the SQL statement for retrieving all view names in the PostgreSQL schema.
compileColumnListing()
Compiles and returns the SQL statement for determining the list of columns in a table in the PostgreSQL schema.
compileColumns($schema, $table)
Compiles and returns the SQL statement for determining the columns in a table in the PostgreSQL schema.
compileIndexes($schema, $table)
Compiles and returns the SQL statement for determining the indexes in a table in the PostgreSQL schema.
compileForeignKeys($schema, $table)
Compiles and returns the SQL statement for determining the foreign keys in a table in the PostgreSQL schema.
compileCreate(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for creating a table in PostgreSQL.
compileAdd(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for adding columns to a table in PostgreSQL.
compileAutoIncrementStartingValues(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for setting the starting values of auto-incrementing columns in PostgreSQL.
compileRenameColumn(Blueprint $blueprint, Fluent $command, Connection $connection)
Compiles and returns the SQL statement for renaming a column in PostgreSQL.
compileChange(Blueprint $blueprint, Fluent $command, Connection $connection)
Compiles and returns the SQL statement for changing the columns of a table in PostgreSQL.
compilePrimary(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for adding a primary key constraint to a table in PostgreSQL.
compileUnique(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for adding a unique key constraint to a table in PostgreSQL.
compileIndex(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for creating an index on a table in PostgreSQL.
compileFulltext(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for creating a fulltext index on a table in PostgreSQL.
compileSpatialIndex(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for creating a spatial index on a table in PostgreSQL.
compileForeign(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for adding a foreign key constraint to a table in PostgreSQL.
compileDrop(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for dropping a table in PostgreSQL.
compileDropIfExists(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for dropping a table if it exists in PostgreSQL.
compileDropAllTables($tables)
Compiles and returns the SQL statement for dropping multiple tables in PostgreSQL.
compileDropAllViews($views)
Compiles and returns the SQL statement for dropping multiple views in PostgreSQL.
compileDropAllTypes($types)
Compiles and returns the SQL statement for dropping multiple user-defined types in PostgreSQL.
compileDropAllDomains($domains)
Compiles and returns the SQL statement for dropping multiple domains in PostgreSQL.
compileGetAllTypes()
Compiles and returns the SQL statement for retrieving all type names in PostgreSQL.
compileDropColumn(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for dropping a column from a table in PostgreSQL.
compileDropPrimary(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for dropping a primary key constraint from a table in PostgreSQL.
compileDropUnique(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for dropping a unique key constraint from a table in PostgreSQL.
compileDropIndex(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for dropping an index from a table in PostgreSQL.
compileDropFullText(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for dropping a fulltext index from a table in PostgreSQL.
compileDropSpatialIndex(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for dropping a spatial index from a table in PostgreSQL.
compileDropForeign(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for dropping a foreign key constraint from a table in PostgreSQL.
compileRename(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for renaming a table in PostgreSQL.
compileRenameIndex(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for renaming an index in PostgreSQL.
compileEnableForeignKeyConstraints()
Compiles and returns the SQL statement for enabling foreign key constraints in PostgreSQL.
compileDisableForeignKeyConstraints()
Compiles and returns the SQL statement for disabling foreign key constraints in PostgreSQL.
compileComment(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for adding a comment to a column in PostgreSQL.
compileTableComment(Blueprint $blueprint, Fluent $command)
Compiles and returns the SQL statement for adding a comment to a table in PostgreSQL.
END
<?php
namespace Illuminate\Database\Schema\Grammars;
use Illuminate\Database\Connection;
use Illuminate\Database\Query\Expression;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Fluent;
use LogicException;
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', 'Nullable', 'Default', 'VirtualAs', 'StoredAs', 'GeneratedAs', 'Increment'];
/**
* 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 = ['AutoIncrementStartingValues', '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.
*
* @deprecated Will be removed in a future Laravel version.
*
* @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 tables.
*
* @return string
*/
public function compileTables()
{
return 'select c.relname as name, n.nspname as schema, pg_total_relation_size(c.oid) as size, '
."obj_description(c.oid, 'pg_class') as comment from pg_class c, pg_namespace n "
."where c.relkind in ('r', 'p') and n.oid = c.relnamespace and n.nspname not in ('pg_catalog', 'information_schema')"
.'order by c.relname';
}
/**
* Compile the query to determine the views.
*
* @return string
*/
public function compileViews()
{
return "select viewname as name, schemaname as schema, definition from pg_views where schemaname not in ('pg_catalog', 'information_schema') order by viewname";
}
/**
* Compile the query to determine the user-defined types.
*
* @return string
*/
public function compileTypes()
{
return 'select t.typname as name, n.nspname as schema, t.typtype as type, t.typcategory as category, '
."((t.typinput = 'array_in'::regproc and t.typoutput = 'array_out'::regproc) or t.typtype = 'm') as implicit "
.'from pg_type t join pg_namespace n on n.oid = t.typnamespace '
.'left join pg_class c on c.oid = t.typrelid '
.'left join pg_type el on el.oid = t.typelem '
.'left join pg_class ce on ce.oid = el.typrelid '
."where ((t.typrelid = 0 and (ce.relkind = 'c' or ce.relkind is null)) or c.relkind = 'c') "
."and not exists (select 1 from pg_depend d where d.objid in (t.oid, t.typelem) and d.deptype = 'e') "
."and n.nspname not in ('pg_catalog', 'information_schema')";
}
/**
* Compile the SQL needed to retrieve all table names.
*
* @deprecated Will be removed in a future Laravel version.
*
* @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.
*
* @deprecated Will be removed in a future Laravel version.
*
* @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 query to determine the list of columns.
*
* @deprecated Will be removed in a future Laravel version.
*
* @return string
*/
public function compileColumnListing()
{
return 'select column_name from information_schema.columns where table_catalog = ? and table_schema = ? and table_name = ?';
}
/**
* Compile the query to determine the columns.
*
* @param string $schema
* @param string $table
* @return string
*/
public function compileColumns($schema, $table)
{
return sprintf(
'select a.attname as name, t.typname as type_name, format_type(a.atttypid, a.atttypmod) as type, '
.'(select tc.collcollate from pg_catalog.pg_collation tc where tc.oid = a.attcollation) as collation, '
.'not a.attnotnull as nullable, '
.'(select pg_get_expr(adbin, adrelid) from pg_attrdef where c.oid = pg_attrdef.adrelid and pg_attrdef.adnum = a.attnum) as default, '
.'col_description(c.oid, a.attnum) as comment '
.'from pg_attribute a, pg_class c, pg_type t, pg_namespace n '
.'where c.relname = %s and n.nspname = %s and a.attnum > 0 and a.attrelid = c.oid and a.atttypid = t.oid and n.oid = c.relnamespace '
.'order by a.attnum',
$this->quoteString($table),
$this->quoteString($schema)
);
}
/**
* Compile the query to determine the indexes.
*
* @param string $schema
* @param string $table
* @return string
*/
public function compileIndexes($schema, $table)
{
return sprintf(
"select ic.relname as name, string_agg(a.attname, ',' order by indseq.ord) as columns, "
.'am.amname as "type", i.indisunique as "unique", i.indisprimary as "primary" '
.'from pg_index i '
.'join pg_class tc on tc.oid = i.indrelid '
.'join pg_namespace tn on tn.oid = tc.relnamespace '
.'join pg_class ic on ic.oid = i.indexrelid '
.'join pg_am am on am.oid = ic.relam '
.'join lateral unnest(i.indkey) with ordinality as indseq(num, ord) on true '
.'left join pg_attribute a on a.attrelid = i.indrelid and a.attnum = indseq.num '
.'where tc.relname = %s and tn.nspname = %s '
.'group by ic.relname, am.amname, i.indisunique, i.indisprimary',
$this->quoteString($table),
$this->quoteString($schema)
);
}
/**
* Compile the query to determine the foreign keys.
*
* @param string $schema
* @param string $table
* @return string
*/
public function compileForeignKeys($schema, $table)
{
return sprintf(
'select c.conname as name, '
."string_agg(la.attname, ',' order by conseq.ord) as columns, "
.'fn.nspname as foreign_schema, fc.relname as foreign_table, '
."string_agg(fa.attname, ',' order by conseq.ord) as foreign_columns, "
.'c.confupdtype as on_update, c.confdeltype as on_delete '
.'from pg_constraint c '
.'join pg_class tc on c.conrelid = tc.oid '
.'join pg_namespace tn on tn.oid = tc.relnamespace '
.'join pg_class fc on c.confrelid = fc.oid '
.'join pg_namespace fn on fn.oid = fc.relnamespace '
.'join lateral unnest(c.conkey) with ordinality as conseq(num, ord) on true '
.'join pg_attribute la on la.attrelid = c.conrelid and la.attnum = conseq.num '
.'join pg_attribute fa on fa.attrelid = c.confrelid and fa.attnum = c.confkey[conseq.ord] '
."where c.contype = 'f' and tc.relname = %s and tn.nspname = %s "
.'group by c.conname, fn.nspname, fc.relname, c.confupdtype, c.confdeltype',
$this->quoteString($table),
$this->quoteString($schema)
);
}
/**
* Compile a create table command.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $command
* @return string
*/
public function compileCreate(Blueprint $blueprint, Fluent $command)
{
return sprintf('%s table %s (%s)',
$blueprint->temporary ? 'create temporary' : 'create',
$this->wrapTable($blueprint),
implode(', ', $this->getColumns($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 sprintf('alter table %s %s',
$this->wrapTable($blueprint),
implode(', ', $this->prefixArray('add column', $this->getColumns($blueprint)))
);
}
/**
* Compile the auto-incrementing column starting values.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $command
* @return string
*/
public function compileAutoIncrementStartingValues(Blueprint $blueprint, Fluent $command)
{
if ($command->column->autoIncrement
&& $value = $command->column->get('startingValue', $command->column->get('from'))) {
return 'alter sequence '.$blueprint->getTable().'_'.$command->column->name.'_seq restart with '.$value;
}
}
/**
* 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 change column command into a series of SQL statements.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $command
* @param \Illuminate\Database\Connection $connection
* @return array|string
*
* @throws \RuntimeException
*/
public function compileChange(Blueprint $blueprint, Fluent $command, Connection $connection)
{
if (! $connection->usingNativeSchemaOperations()) {
return parent::compileChange($blueprint, $command, $connection);
}
$columns = [];
foreach ($blueprint->getChangedColumns() as $column) {
$changes = ['type '.$this->getType($column).$this->modifyCollate($blueprint, $column)];
foreach ($this->modifiers as $modifier) {
if ($modifier === 'Collate') {
continue;
}
if (method_exists($this, $method = "modify{$modifier}")) {
$constraints = (array) $this->{$method}($blueprint, $column);
foreach ($constraints as $constraint) {
$changes[] = $constraint;
}
}
}
$columns[] = implode(', ', $this->prefixArray('alter column '.$this->wrap($column), $changes));
}
return 'alter table '.$this->wrapTable($blueprint).' '.implode(', ', $columns);
}
/**
* 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 drop all domains.
*
* @param array $domains
* @return string
*/
public function compileDropAllDomains($domains)
{
return 'drop domain '.implode(',', $this->escapeNames($domains)).' cascade';
}
/**
* Compile the SQL needed to retrieve all type names.
*
* @deprecated Will be removed in a future Laravel version.
*
* @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->getPrefix()}{$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)
{
if (! is_null($comment = $command->column->comment) || $command->column->change) {
return sprintf('comment on column %s.%s is %s',
$this->wrapTable($blueprint),
$this->wrap($command->column->name),
is_null($comment) ? 'NULL' : "'".str_replace("'", "''", $comment)."'"
);
}
}
/**
* 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 $column->autoIncrement && is_null($column->generatedAs) ? 'serial' : 'integer';
}
/**
* Create the column definition for a big integer type.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
protected function typeBigInteger(Fluent $column)
{
return $column->autoIncrement && is_null($column->generatedAs) ? 'bigserial' : 'bigint';
}
/**
* Create the column definition for a medium integer type.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
protected function typeMediumInteger(Fluent $column)
{
return $this->typeInteger($column);
}
/**
* Create the column definition for a tiny integer type.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
protected function typeTinyInteger(Fluent $column)
{
return $this->typeSmallInteger($column);
}
/**
* Create the column definition for a small integer type.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
protected function typeSmallInteger(Fluent $column)
{
return $column->autoIncrement && is_null($column->generatedAs) ? 'smallserial' : 'smallint';
}
/**
* Create the column definition for a float type.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
protected function typeFloat(Fluent $column)
{
if ($column->precision) {
return "float({$column->precision})";
}
return 'float';
}
/**
* 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)
{
if ($column->useCurrent) {
$column->default(new Expression('CURRENT_TIMESTAMP'));
}
return 'timestamp'.(is_null($column->precision) ? '' : "($column->precision)").' without time zone';
}
/**
* Create the column definition for a timestamp (with time zone) type.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
protected function typeTimestampTz(Fluent $column)
{
if ($column->useCurrent) {
$column->default(new Expression('CURRENT_TIMESTAMP'));
}
return 'timestamp'.(is_null($column->precision) ? '' : "($column->precision)").' with time zone';
}
/**
* 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.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
protected function typeMultiPoint(Fluent $column)
{
return $this->formatPostGisType('multipoint', $column);
}
/**
* Create the column definition for a spatial MultiLineString type.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
public function typeMultiLineString(Fluent $column)
{
return $this->formatPostGisType('multilinestring', $column);
}
/**
* Create the column definition for a spatial MultiPolygon type.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
protected function typeMultiPolygon(Fluent $column)
{
return $this->formatPostGisType('multipolygon', $column);
}
/**
* Create the column definition for a spatial MultiPolygonZ type.
*
* @param \Illuminate\Support\Fluent $column
* @return string
*/
protected function typeMultiPolygonZ(Fluent $column)
{
return $this->formatPostGisType('multipolygonz', $column);
}
/**
* Format the column definition for a PostGIS spatial type.
*
* @param string $type
* @param \Illuminate\Support\Fluent $column
* @return string
*/
private function formatPostGisType($type, Fluent $column)
{
if ($column->isGeometry === null) {
return sprintf('geography(%s, %s)', $type, $column->projection ?? '4326');
}
if ($column->projection !== null) {
return sprintf('geometry(%s, %s)', $type, $column->projection);
}
return "geometry({$type})";
}
/**
* Get the SQL for a collation column modifier.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $column
* @return string|null
*/
protected function modifyCollate(Blueprint $blueprint, Fluent $column)
{
if (! is_null($column->collation)) {
return ' collate '.$this->wrapValue($column->collation);
}
}
/**
* Get the SQL for a nullable column modifier.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $column
* @return string|null
*/
protected function modifyNullable(Blueprint $blueprint, Fluent $column)
{
if ($column->change) {
return $column->nullable ? 'drop not null' : 'set not null';
}
return $column->nullable ? ' null' : ' not null';
}
/**
* Get the SQL for a default column modifier.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $column
* @return string|null
*/
protected function modifyDefault(Blueprint $blueprint, Fluent $column)
{
if ($column->change) {
return is_null($column->default) ? 'drop default' : 'set default '.$this->getDefaultValue($column->default);
}
if (! is_null($column->default)) {
return ' default '.$this->getDefaultValue($column->default);
}
}
/**
* Get the SQL for an auto-increment column modifier.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $column
* @return string|null
*/
protected function modifyIncrement(Blueprint $blueprint, Fluent $column)
{
if (! $column->change
&& (in_array($column->type, $this->serials) || ($column->generatedAs !== null))
&& $column->autoIncrement) {
return ' primary key';
}
}
/**
* Get the SQL for a generated virtual column modifier.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $column
* @return string|null
*/
protected function modifyVirtualAs(Blueprint $blueprint, Fluent $column)
{
if ($column->change) {
if (array_key_exists('virtualAs', $column->getAttributes())) {
return is_null($column->virtualAs)
? 'drop expression if exists'
: throw new LogicException('This database driver does not support modifying generated columns.');
}
return null;
}
if (! is_null($column->virtualAs)) {
return " generated always as ({$this->getValue($column->virtualAs)})";
}
}
/**
* Get the SQL for a generated stored column modifier.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $column
* @return string|null
*/
protected function modifyStoredAs(Blueprint $blueprint, Fluent $column)
{
if ($column->change) {
if (array_key_exists('storedAs', $column->getAttributes())) {
return is_null($column->storedAs)
? 'drop expression if exists'
: throw new LogicException('This database driver does not support modifying generated columns.');
}
return null;
}
if (! is_null($column->storedAs)) {
return " generated always as ({$this->getValue($column->storedAs)}) stored";
}
}
/**
* Get the SQL for an identity column modifier.
*
* @param \Illuminate\Database\Schema\Blueprint $blueprint
* @param \Illuminate\Support\Fluent $column
* @return string|array|null
*/
protected function modifyGeneratedAs(Blueprint $blueprint, Fluent $column)
{
$sql = null;
if (! is_null($column->generatedAs)) {
$sql = sprintf(
' generated %s as identity%s',
$column->always ? 'always' : 'by default',
! is_bool($column->generatedAs) && ! empty($column->generatedAs) ? " ({$column->generatedAs})" : ''
);
}
if ($column->change) {
$changes = ['drop identity if exists'];
if (! is_null($sql)) {
$changes[] = 'add '.$sql;
}
return $changes;
}
return $sql;
}
}