1222 lines
34 KiB
PHP
Executable File
1222 lines
34 KiB
PHP
Executable File
<?php
|
|
|
|
namespace Illuminate\Database\Schema\Grammars;
|
|
|
|
use Illuminate\Database\Connection;
|
|
use Illuminate\Database\Schema\Blueprint;
|
|
use Illuminate\Support\Fluent;
|
|
use RuntimeException;
|
|
|
|
class MySqlGrammar extends Grammar
|
|
{
|
|
/**
|
|
* The possible column modifiers.
|
|
*
|
|
* @var string[]
|
|
*/
|
|
protected $modifiers = [
|
|
'Unsigned', 'Charset', 'Collate', 'VirtualAs', 'StoredAs', 'Nullable', 'Invisible',
|
|
'Srid', 'Default', 'Increment', 'Comment', 'After', 'First',
|
|
];
|
|
|
|
/**
|
|
* The possible column serials.
|
|
*
|
|
* @var string[]
|
|
*/
|
|
protected $serials = ['bigInteger', 'integer', 'mediumInteger', 'smallInteger', 'tinyInteger'];
|
|
|
|
/**
|
|
* 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 default character set %s default collate %s',
|
|
$this->wrapValue($name),
|
|
$this->wrapValue($connection->getConfig('charset')),
|
|
$this->wrapValue($connection->getConfig('collation')),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* 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 the list of tables.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function compileTableExists()
|
|
{
|
|
return "select * from information_schema.tables where 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 as `column_name` from information_schema.columns where table_schema = ? and table_name = ?';
|
|
}
|
|
|
|
/**
|
|
* Compile a create table command.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $command
|
|
* @param \Illuminate\Database\Connection $connection
|
|
* @return array
|
|
*/
|
|
public function compileCreate(Blueprint $blueprint, Fluent $command, Connection $connection)
|
|
{
|
|
$sql = $this->compileCreateTable(
|
|
$blueprint, $command, $connection
|
|
);
|
|
|
|
// Once we have the primary SQL, we can add the encoding option to the SQL for
|
|
// the table. Then, we can check if a storage engine has been supplied for
|
|
// the table. If so, we will add the engine declaration to the SQL query.
|
|
$sql = $this->compileCreateEncoding(
|
|
$sql, $connection, $blueprint
|
|
);
|
|
|
|
// Finally, we will append the engine configuration onto this SQL statement as
|
|
// the final thing we do before returning this finished SQL. Once this gets
|
|
// added the query will be ready to execute against the real connections.
|
|
return array_values(array_filter(array_merge([$this->compileCreateEngine(
|
|
$sql, $connection, $blueprint
|
|
)], $this->compileAutoIncrementStartingValues($blueprint))));
|
|
}
|
|
|
|
/**
|
|
* Create the main create table clause.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $command
|
|
* @param \Illuminate\Database\Connection $connection
|
|
* @return array
|
|
*/
|
|
protected function compileCreateTable($blueprint, $command, $connection)
|
|
{
|
|
return trim(sprintf('%s table %s (%s)',
|
|
$blueprint->temporary ? 'create temporary' : 'create',
|
|
$this->wrapTable($blueprint),
|
|
implode(', ', $this->getColumns($blueprint))
|
|
));
|
|
}
|
|
|
|
/**
|
|
* Append the character set specifications to a command.
|
|
*
|
|
* @param string $sql
|
|
* @param \Illuminate\Database\Connection $connection
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @return string
|
|
*/
|
|
protected function compileCreateEncoding($sql, Connection $connection, Blueprint $blueprint)
|
|
{
|
|
// First we will set the character set if one has been set on either the create
|
|
// blueprint itself or on the root configuration for the connection that the
|
|
// table is being created on. We will add these to the create table query.
|
|
if (isset($blueprint->charset)) {
|
|
$sql .= ' default character set '.$blueprint->charset;
|
|
} elseif (! is_null($charset = $connection->getConfig('charset'))) {
|
|
$sql .= ' default character set '.$charset;
|
|
}
|
|
|
|
// Next we will add the collation to the create table statement if one has been
|
|
// added to either this create table blueprint or the configuration for this
|
|
// connection that the query is targeting. We'll add it to this SQL query.
|
|
if (isset($blueprint->collation)) {
|
|
$sql .= " collate '{$blueprint->collation}'";
|
|
} elseif (! is_null($collation = $connection->getConfig('collation'))) {
|
|
$sql .= " collate '{$collation}'";
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Append the engine specifications to a command.
|
|
*
|
|
* @param string $sql
|
|
* @param \Illuminate\Database\Connection $connection
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @return string
|
|
*/
|
|
protected function compileCreateEngine($sql, Connection $connection, Blueprint $blueprint)
|
|
{
|
|
if (isset($blueprint->engine)) {
|
|
return $sql.' engine = '.$blueprint->engine;
|
|
} elseif (! is_null($engine = $connection->getConfig('engine'))) {
|
|
return $sql.' engine = '.$engine;
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Compile an add column command.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $command
|
|
* @return array
|
|
*/
|
|
public function compileAdd(Blueprint $blueprint, Fluent $command)
|
|
{
|
|
$columns = $this->prefixArray('add', $this->getColumns($blueprint));
|
|
|
|
return array_values(array_merge(
|
|
['alter table '.$this->wrapTable($blueprint).' '.implode(', ', $columns)],
|
|
$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 table '.$this->wrapTable($blueprint->getTable()).' auto_increment = '.$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)
|
|
{
|
|
return sprintf('alter table %s add primary key %s(%s)',
|
|
$this->wrapTable($blueprint),
|
|
$command->algorithm ? 'using '.$command->algorithm : '',
|
|
$this->columnize($command->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)
|
|
{
|
|
return $this->compileKey($blueprint, $command, 'unique');
|
|
}
|
|
|
|
/**
|
|
* 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 $this->compileKey($blueprint, $command, 'index');
|
|
}
|
|
|
|
/**
|
|
* Compile a fulltext index key command.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $command
|
|
* @return string
|
|
*/
|
|
public function compileFullText(Blueprint $blueprint, Fluent $command)
|
|
{
|
|
return $this->compileKey($blueprint, $command, 'fulltext');
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
return $this->compileKey($blueprint, $command, 'spatial index');
|
|
}
|
|
|
|
/**
|
|
* Compile an index creation command.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $command
|
|
* @param string $type
|
|
* @return string
|
|
*/
|
|
protected function compileKey(Blueprint $blueprint, Fluent $command, $type)
|
|
{
|
|
return sprintf('alter table %s add %s %s%s(%s)',
|
|
$this->wrapTable($blueprint),
|
|
$type,
|
|
$this->wrap($command->index),
|
|
$command->algorithm ? ' using '.$command->algorithm : '',
|
|
$this->columnize($command->columns)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* 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 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', $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)
|
|
{
|
|
return 'alter table '.$this->wrapTable($blueprint).' drop primary key';
|
|
}
|
|
|
|
/**
|
|
* 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 index {$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)
|
|
{
|
|
$index = $this->wrap($command->index);
|
|
|
|
return "alter table {$this->wrapTable($blueprint)} drop index {$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 foreign key {$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 "rename table {$from} 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 table %s rename index %s to %s',
|
|
$this->wrapTable($blueprint),
|
|
$this->wrap($command->from),
|
|
$this->wrap($command->to)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Compile the SQL needed to drop all tables.
|
|
*
|
|
* @param array $tables
|
|
* @return string
|
|
*/
|
|
public function compileDropAllTables($tables)
|
|
{
|
|
return 'drop table '.implode(',', $this->wrapArray($tables));
|
|
}
|
|
|
|
/**
|
|
* Compile the SQL needed to drop all views.
|
|
*
|
|
* @param array $views
|
|
* @return string
|
|
*/
|
|
public function compileDropAllViews($views)
|
|
{
|
|
return 'drop view '.implode(',', $this->wrapArray($views));
|
|
}
|
|
|
|
/**
|
|
* Compile the SQL needed to retrieve all table names.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function compileGetAllTables()
|
|
{
|
|
return 'SHOW FULL TABLES WHERE table_type = \'BASE TABLE\'';
|
|
}
|
|
|
|
/**
|
|
* Compile the SQL needed to retrieve all view names.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function compileGetAllViews()
|
|
{
|
|
return 'SHOW FULL TABLES WHERE table_type = \'VIEW\'';
|
|
}
|
|
|
|
/**
|
|
* Compile the command to enable foreign key constraints.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function compileEnableForeignKeyConstraints()
|
|
{
|
|
return 'SET FOREIGN_KEY_CHECKS=1;';
|
|
}
|
|
|
|
/**
|
|
* Compile the command to disable foreign key constraints.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function compileDisableForeignKeyConstraints()
|
|
{
|
|
return 'SET FOREIGN_KEY_CHECKS=0;';
|
|
}
|
|
|
|
/**
|
|
* 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('alter table %s comment = %s',
|
|
$this->wrapTable($blueprint),
|
|
"'".str_replace("'", "''", $command->comment)."'"
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a char type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeChar(Fluent $column)
|
|
{
|
|
return "char({$column->length})";
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a string type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeString(Fluent $column)
|
|
{
|
|
return "varchar({$column->length})";
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a tiny text type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeTinyText(Fluent $column)
|
|
{
|
|
return 'tinytext';
|
|
}
|
|
|
|
/**
|
|
* 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 'mediumtext';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a long text type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeLongText(Fluent $column)
|
|
{
|
|
return 'longtext';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a big integer type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeBigInteger(Fluent $column)
|
|
{
|
|
return 'bigint';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for an integer type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeInteger(Fluent $column)
|
|
{
|
|
return 'int';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a medium integer type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeMediumInteger(Fluent $column)
|
|
{
|
|
return 'mediumint';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a tiny integer type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeTinyInteger(Fluent $column)
|
|
{
|
|
return 'tinyint';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a small integer type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeSmallInteger(Fluent $column)
|
|
{
|
|
return 'smallint';
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
if ($column->total && $column->places) {
|
|
return "double({$column->total}, {$column->places})";
|
|
}
|
|
|
|
return 'double';
|
|
}
|
|
|
|
/**
|
|
* 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 'tinyint(1)';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for an enumeration type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeEnum(Fluent $column)
|
|
{
|
|
return sprintf('enum(%s)', $this->quoteString($column->allowed));
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a set enumeration type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeSet(Fluent $column)
|
|
{
|
|
return sprintf('set(%s)', $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 'json';
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
$columnType = $column->precision ? "datetime($column->precision)" : 'datetime';
|
|
|
|
$current = $column->precision ? "CURRENT_TIMESTAMP($column->precision)" : 'CURRENT_TIMESTAMP';
|
|
|
|
$columnType = $column->useCurrent ? "$columnType default $current" : $columnType;
|
|
|
|
return $column->useCurrentOnUpdate ? "$columnType on update $current" : $columnType;
|
|
}
|
|
|
|
/**
|
|
* 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->typeDateTime($column);
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a time type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeTime(Fluent $column)
|
|
{
|
|
return $column->precision ? "time($column->precision)" : 'time';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a time (with time zone) type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeTimeTz(Fluent $column)
|
|
{
|
|
return $this->typeTime($column);
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a timestamp type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeTimestamp(Fluent $column)
|
|
{
|
|
$columnType = $column->precision ? "timestamp($column->precision)" : 'timestamp';
|
|
|
|
$current = $column->precision ? "CURRENT_TIMESTAMP($column->precision)" : 'CURRENT_TIMESTAMP';
|
|
|
|
$columnType = $column->useCurrent ? "$columnType default $current" : $columnType;
|
|
|
|
return $column->useCurrentOnUpdate ? "$columnType on update $current" : $columnType;
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a timestamp (with time zone) type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeTimestampTz(Fluent $column)
|
|
{
|
|
return $this->typeTimestamp($column);
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a year type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeYear(Fluent $column)
|
|
{
|
|
return 'year';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a binary type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeBinary(Fluent $column)
|
|
{
|
|
return 'blob';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a uuid type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeUuid(Fluent $column)
|
|
{
|
|
return 'char(36)';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for an IP address type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeIpAddress(Fluent $column)
|
|
{
|
|
return 'varchar(45)';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a MAC address type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
protected function typeMacAddress(Fluent $column)
|
|
{
|
|
return 'varchar(17)';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a spatial Geometry type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
public function typeGeometry(Fluent $column)
|
|
{
|
|
return 'geometry';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a spatial Point type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
public function typePoint(Fluent $column)
|
|
{
|
|
return 'point';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a spatial LineString type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
public function typeLineString(Fluent $column)
|
|
{
|
|
return 'linestring';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a spatial Polygon type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
public function typePolygon(Fluent $column)
|
|
{
|
|
return 'polygon';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a spatial GeometryCollection type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
public function typeGeometryCollection(Fluent $column)
|
|
{
|
|
return 'geometrycollection';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a spatial MultiPoint type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
public function typeMultiPoint(Fluent $column)
|
|
{
|
|
return 'multipoint';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a spatial MultiLineString type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
public function typeMultiLineString(Fluent $column)
|
|
{
|
|
return 'multilinestring';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a spatial MultiPolygon type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string
|
|
*/
|
|
public function typeMultiPolygon(Fluent $column)
|
|
{
|
|
return 'multipolygon';
|
|
}
|
|
|
|
/**
|
|
* Create the column definition for a generated, computed column type.
|
|
*
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return void
|
|
*
|
|
* @throws \RuntimeException
|
|
*/
|
|
protected function typeComputed(Fluent $column)
|
|
{
|
|
throw new RuntimeException('This database driver requires a type, see the virtualAs / storedAs modifiers.');
|
|
}
|
|
|
|
/**
|
|
* 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 (! is_null($virtualAs = $column->virtualAsJson)) {
|
|
if ($this->isJsonSelector($virtualAs)) {
|
|
$virtualAs = $this->wrapJsonSelector($virtualAs);
|
|
}
|
|
|
|
return " as ({$virtualAs})";
|
|
}
|
|
|
|
if (! is_null($virtualAs = $column->virtualAs)) {
|
|
return " as ({$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 (! is_null($storedAs = $column->storedAsJson)) {
|
|
if ($this->isJsonSelector($storedAs)) {
|
|
$storedAs = $this->wrapJsonSelector($storedAs);
|
|
}
|
|
|
|
return " as ({$storedAs}) stored";
|
|
}
|
|
|
|
if (! is_null($storedAs = $column->storedAs)) {
|
|
return " as ({$storedAs}) stored";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the SQL for an unsigned column modifier.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string|null
|
|
*/
|
|
protected function modifyUnsigned(Blueprint $blueprint, Fluent $column)
|
|
{
|
|
if ($column->unsigned) {
|
|
return ' unsigned';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the SQL for a character set column modifier.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string|null
|
|
*/
|
|
protected function modifyCharset(Blueprint $blueprint, Fluent $column)
|
|
{
|
|
if (! is_null($column->charset)) {
|
|
return ' character set '.$column->charset;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 '{$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 (is_null($column->virtualAs) &&
|
|
is_null($column->virtualAsJson) &&
|
|
is_null($column->storedAs) &&
|
|
is_null($column->storedAsJson)) {
|
|
return $column->nullable ? ' null' : ' not null';
|
|
}
|
|
|
|
if ($column->nullable === false) {
|
|
return ' not null';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the SQL for an invisible column modifier.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string|null
|
|
*/
|
|
protected function modifyInvisible(Blueprint $blueprint, Fluent $column)
|
|
{
|
|
if (! is_null($column->invisible)) {
|
|
return ' invisible';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 (! 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 (in_array($column->type, $this->serials) && $column->autoIncrement) {
|
|
return ' auto_increment primary key';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the SQL for a "first" column modifier.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string|null
|
|
*/
|
|
protected function modifyFirst(Blueprint $blueprint, Fluent $column)
|
|
{
|
|
if (! is_null($column->first)) {
|
|
return ' first';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the SQL for an "after" column modifier.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string|null
|
|
*/
|
|
protected function modifyAfter(Blueprint $blueprint, Fluent $column)
|
|
{
|
|
if (! is_null($column->after)) {
|
|
return ' after '.$this->wrap($column->after);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the SQL for a "comment" column modifier.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string|null
|
|
*/
|
|
protected function modifyComment(Blueprint $blueprint, Fluent $column)
|
|
{
|
|
if (! is_null($column->comment)) {
|
|
return " comment '".addslashes($column->comment)."'";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the SQL for a SRID column modifier.
|
|
*
|
|
* @param \Illuminate\Database\Schema\Blueprint $blueprint
|
|
* @param \Illuminate\Support\Fluent $column
|
|
* @return string|null
|
|
*/
|
|
protected function modifySrid(Blueprint $blueprint, Fluent $column)
|
|
{
|
|
if (is_int($column->srid) && $column->srid > 0) {
|
|
return ' srid '.$column->srid;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Wrap a single string in keyword identifiers.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected function wrapValue($value)
|
|
{
|
|
if ($value !== '*') {
|
|
return '`'.str_replace('`', '``', $value).'`';
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Wrap the given JSON selector.
|
|
*
|
|
* @param string $value
|
|
* @return string
|
|
*/
|
|
protected function wrapJsonSelector($value)
|
|
{
|
|
[$field, $path] = $this->wrapJsonFieldAndPath($value);
|
|
|
|
return 'json_unquote(json_extract('.$field.$path.'))';
|
|
}
|
|
}
|