merged skunkworks into develop.
This commit is contained in:
Taylor Otwell
38
laravel/database/schema/grammars/grammar.php
Normal file
38
laravel/database/schema/grammars/grammar.php
Normal file
@@ -0,0 +1,38 @@
|
||||
<?php namespace Laravel\Database\Schema\Grammars;
|
||||
|
||||
use Laravel\Fluent;
|
||||
use Laravel\Database\Schema\Table;
|
||||
|
||||
abstract class Grammar extends \Laravel\Database\Grammar {
|
||||
|
||||
/**
|
||||
* Get the appropriate data type definition for the column.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type(Fluent $column)
|
||||
{
|
||||
return $this->{'type_'.$column->type}($column);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap a value in keyword identifiers.
|
||||
*
|
||||
* @param Table|string $value
|
||||
* @return string
|
||||
*/
|
||||
public function wrap($value)
|
||||
{
|
||||
// This method is primarily for convenience so we can just pass a
|
||||
// column or table instance into the wrap method without sending
|
||||
// in the name each time we need to wrap one of these objects.
|
||||
if ($value instanceof Table or $value instanceof Fluent)
|
||||
{
|
||||
$value = $value->name;
|
||||
}
|
||||
|
||||
return parent::wrap($value);
|
||||
}
|
||||
|
||||
}
|
||||
386
laravel/database/schema/grammars/mysql.php
Normal file
386
laravel/database/schema/grammars/mysql.php
Normal file
@@ -0,0 +1,386 @@
|
||||
<?php namespace Laravel\Database\Schema\Grammars;
|
||||
|
||||
use Laravel\Fluent;
|
||||
use Laravel\Database\Schema\Table;
|
||||
|
||||
class MySQL extends Grammar {
|
||||
|
||||
/**
|
||||
* The keyword identifier for the database system.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $wrapper = '`%s`';
|
||||
|
||||
/**
|
||||
* Generate the SQL statements for a table creation command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return array
|
||||
*/
|
||||
public function create(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = implode(', ', $this->columns($table));
|
||||
|
||||
// First we will generate the base table creation statement. Other than
|
||||
// auto-incrementing keys, no indexes will be created during the first
|
||||
// creation of the table. They will be added in separate commands.
|
||||
$sql = 'CREATE TABLE '.$this->wrap($table).' ('.$columns.')';
|
||||
|
||||
// MySQL supports various "engines" for database tables. If an engine
|
||||
// was specified by the developer, we will set it after adding the
|
||||
// columns the table creation statement.
|
||||
if ( ! is_null($table->engine))
|
||||
{
|
||||
$sql .= ' ENGINE = '.$table->engine;
|
||||
}
|
||||
|
||||
return $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Geenrate the SQL statements for a table modification command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return array
|
||||
*/
|
||||
public function add(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = $this->columns($table);
|
||||
|
||||
// Once we the array of column definitions, we need to add "add"
|
||||
// to the front of each definition, then we'll concatenate the
|
||||
// definitions using commas like normal and generate the SQL.
|
||||
$columns = implode(', ', array_map(function($column)
|
||||
{
|
||||
return 'ADD '.$column;
|
||||
|
||||
}, $columns));
|
||||
|
||||
return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create the individual column definitions for the table.
|
||||
*
|
||||
* @param Table $table
|
||||
* @return array
|
||||
*/
|
||||
protected function columns(Table $table)
|
||||
{
|
||||
$columns = array();
|
||||
|
||||
foreach ($table->columns as $column)
|
||||
{
|
||||
// Each of the data type's have their own definition creation method,
|
||||
// which is responsible for creating the SQL for the type. This lets
|
||||
// us to keep the syntax easy and fluent, while translating the
|
||||
// types to the types used by the database.
|
||||
$sql = $this->wrap($column).' '.$this->type($column);
|
||||
|
||||
$elements = array('nullable', 'defaults', 'incrementer');
|
||||
|
||||
foreach ($elements as $element)
|
||||
{
|
||||
$sql .= $this->$element($table, $column);
|
||||
}
|
||||
|
||||
$columns[] = $sql;
|
||||
}
|
||||
|
||||
return $columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for indicating if a column is nullable.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function nullable(Table $table, Fluent $column)
|
||||
{
|
||||
return ($column->nullable) ? ' NULL' : ' NOT NULL';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for specifying a default value on a column.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function defaults(Table $table, Fluent $column)
|
||||
{
|
||||
if ( ! is_null($column->default))
|
||||
{
|
||||
return " DEFAULT '".$column->default."'";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for defining an auto-incrementing column.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function incrementer(Table $table, Fluent $column)
|
||||
{
|
||||
if ($column->type == 'integer' and $column->increment)
|
||||
{
|
||||
return ' AUTO_INCREMENT PRIMARY KEY';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a primary key.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function primary(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command, 'PRIMARY KEY');
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a unique index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function unique(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command, 'UNIQUE');
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a full-text index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function fulltext(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command, 'FULLTEXT');
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a regular index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function index(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command, 'INDEX');
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a new index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @param string $type
|
||||
* @return string
|
||||
*/
|
||||
protected function key(Table $table, Fluent $command, $type)
|
||||
{
|
||||
$keys = $this->columnize($command->columns);
|
||||
|
||||
$name = $command->name;
|
||||
|
||||
return 'ALTER TABLE '.$this->wrap($table)." ADD {$type} {$name}({$keys})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop table command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop(Table $table, Fluent $command)
|
||||
{
|
||||
return 'DROP TABLE '.$this->wrap($table);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop column command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_column(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = array_map(array($this, 'wrap'), $command->columns);
|
||||
|
||||
// Once we the array of column names, we need to add "drop" to the
|
||||
// front of each column, then we'll concatenate the columns using
|
||||
// commas and generate the alter statement SQL.
|
||||
$columns = implode(', ', array_map(function($column)
|
||||
{
|
||||
return 'DROP '.$column;
|
||||
|
||||
}, $columns));
|
||||
|
||||
return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop primary key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_primary(Table $table, Fluent $command)
|
||||
{
|
||||
return 'ALTER TABLE '.$this->wrap($table).' DROP PRIMARY KEY';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop unqique key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_unique(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop full-text key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_fulltext(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop unqique key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_index(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
protected function drop_key(Table $table, Fluent $command)
|
||||
{
|
||||
return 'ALTER TABLE '.$this->wrap($table)." DROP INDEX {$command->name}";
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a string.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_string(Fluent $column)
|
||||
{
|
||||
return 'VARCHAR('.$column->length.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for an integer.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_integer(Fluent $column)
|
||||
{
|
||||
return 'INT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for an integer.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_float(Fluent $column)
|
||||
{
|
||||
return 'FLOAT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a boolean.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_boolean(Fluent $column)
|
||||
{
|
||||
return 'TINYINT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a date.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_date(Fluent $column)
|
||||
{
|
||||
return 'DATETIME';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a timestamp.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_timestamp(Fluent $column)
|
||||
{
|
||||
return 'TIMESTAMP';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a text column.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_text(Fluent $column)
|
||||
{
|
||||
return 'TEXT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a blob.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_blob(Fluent $column)
|
||||
{
|
||||
return 'BLOB';
|
||||
}
|
||||
|
||||
}
|
||||
381
laravel/database/schema/grammars/postgres.php
Normal file
381
laravel/database/schema/grammars/postgres.php
Normal file
@@ -0,0 +1,381 @@
|
||||
<?php namespace Laravel\Database\Schema\Grammars;
|
||||
|
||||
use Laravel\Fluent;
|
||||
use Laravel\Database\Schema\Table;
|
||||
|
||||
class Postgres extends Grammar {
|
||||
|
||||
/**
|
||||
* Generate the SQL statements for a table creation command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return array
|
||||
*/
|
||||
public function create(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = implode(', ', $this->columns($table));
|
||||
|
||||
// First we will generate the base table creation statement. Other than
|
||||
// auto-incrementing keys, no indexes will be created during the first
|
||||
// creation of the table. They will be added in separate commands.
|
||||
$sql = 'CREATE TABLE '.$this->wrap($table).' ('.$columns.')';
|
||||
|
||||
return $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Geenrate the SQL statements for a table modification command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return array
|
||||
*/
|
||||
public function add(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = $this->columns($table);
|
||||
|
||||
// Once we the array of column definitions, we'll add "add column"
|
||||
// to the front of each definition, then we'll concatenate the
|
||||
// definitions using commas like normal and generate the SQL.
|
||||
$columns = implode(', ', array_map(function($column)
|
||||
{
|
||||
return 'ADD COLUMN '.$column;
|
||||
|
||||
}, $columns));
|
||||
|
||||
return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create the individual column definitions for the table.
|
||||
*
|
||||
* @param Table $table
|
||||
* @return array
|
||||
*/
|
||||
protected function columns(Table $table)
|
||||
{
|
||||
$columns = array();
|
||||
|
||||
foreach ($table->columns as $column)
|
||||
{
|
||||
// Each of the data type's have their own definition creation method,
|
||||
// which is responsible for creating the SQL for the type. This lets
|
||||
// us to keep the syntax easy and fluent, while translating the
|
||||
// types to the types used by the database.
|
||||
$sql = $this->wrap($column).' '.$this->type($column);
|
||||
|
||||
$elements = array('incrementer', 'nullable', 'defaults');
|
||||
|
||||
foreach ($elements as $element)
|
||||
{
|
||||
$sql .= $this->$element($table, $column);
|
||||
}
|
||||
|
||||
$columns[] = $sql;
|
||||
}
|
||||
|
||||
return $columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for indicating if a column is nullable.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function nullable(Table $table, Fluent $column)
|
||||
{
|
||||
return ($column->nullable) ? ' NULL' : ' NOT NULL';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for specifying a default value on a column.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function defaults(Table $table, Fluent $column)
|
||||
{
|
||||
if ( ! is_null($column->default))
|
||||
{
|
||||
return " DEFAULT '".$column->default."'";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for defining an auto-incrementing column.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function incrementer(Table $table, Fluent $column)
|
||||
{
|
||||
// We don't actually need to specify an "auto_increment" keyword since
|
||||
// we handle the auto-increment definition in the type definition for
|
||||
// integers by changing the type to "serial", which is a convenient
|
||||
// notational short-cut provided by Postgres.
|
||||
if ($column->type == 'integer' and $column->increment)
|
||||
{
|
||||
return ' PRIMARY KEY';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a primary key.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function primary(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = $this->columnize($command->columns);
|
||||
|
||||
return 'ALTER TABLE '.$this->wrap($table)." ADD PRIMARY KEY ({$columns})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a unique index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function unique(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a full-text index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function fulltext(Table $table, Fluent $command)
|
||||
{
|
||||
$name = $command->name;
|
||||
|
||||
$columns = $this->columnize($command->columns);
|
||||
|
||||
return "CREATE INDEX {$name} ON ".$this->wrap($table)." USING gin({$columns})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a regular index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function index(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a new index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @param bool $unique
|
||||
* @return string
|
||||
*/
|
||||
protected function key(Table $table, Fluent $command, $unique = false)
|
||||
{
|
||||
$columns = $this->columnize($command->columns);
|
||||
|
||||
$create = ($unique) ? 'CREATE UNIQUE' : 'CREATE';
|
||||
|
||||
return $create." INDEX {$command->name} ON ".$this->wrap($table)." ({$columns})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop table command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop(Table $table, Fluent $command)
|
||||
{
|
||||
return 'DROP TABLE '.$this->wrap($table);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop column command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_column(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = array_map(array($this, 'wrap'), $command->columns);
|
||||
|
||||
// Once we the array of column names, we need to add "drop" to the
|
||||
// front of each column, then we'll concatenate the columns using
|
||||
// commas and generate the alter statement SQL.
|
||||
$columns = implode(', ', array_map(function($column)
|
||||
{
|
||||
return 'DROP COLUMN '.$column;
|
||||
|
||||
}, $columns));
|
||||
|
||||
return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop primary key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_primary(Table $table, Fluent $command)
|
||||
{
|
||||
return 'ALTER TABLE '.$this->wrap($table).' DROP CONSTRAINT '.$table->name.'_pkey';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop unqique key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_unique(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop full-text key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_fulltext(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop index command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_index(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
protected function drop_key(Table $table, Fluent $command)
|
||||
{
|
||||
return 'DROP INDEX '.$command->name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a string.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_string(Fluent $column)
|
||||
{
|
||||
return 'VARCHAR('.$column->length.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for an integer.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_integer(Fluent $column)
|
||||
{
|
||||
return ($column->increment) ? 'SERIAL' : 'INTEGER';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for an integer.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_float(Fluent $column)
|
||||
{
|
||||
return 'REAL';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a boolean.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_boolean(Fluent $column)
|
||||
{
|
||||
return 'SMALLINT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a date.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_date(Fluent $column)
|
||||
{
|
||||
return 'TIMESTAMP';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a timestamp.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_timestamp(Fluent $column)
|
||||
{
|
||||
return 'TIMESTAMP';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a text column.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_text(Fluent $column)
|
||||
{
|
||||
return 'TEXT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a blob.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_blob(Fluent $column)
|
||||
{
|
||||
return 'BYTEA';
|
||||
}
|
||||
|
||||
}
|
||||
344
laravel/database/schema/grammars/sqlite.php
Normal file
344
laravel/database/schema/grammars/sqlite.php
Normal file
@@ -0,0 +1,344 @@
|
||||
<?php namespace Laravel\Database\Schema\Grammars;
|
||||
|
||||
use Laravel\Fluent;
|
||||
use Laravel\Database\Schema\Table;
|
||||
|
||||
class SQLite extends Grammar {
|
||||
|
||||
/**
|
||||
* Generate the SQL statements for a table creation command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return array
|
||||
*/
|
||||
public function create(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = implode(', ', $this->columns($table));
|
||||
|
||||
// First we will generate the base table creation statement. Other than
|
||||
// auto-incrementing keys, no indexes will be created during the first
|
||||
// creation of the table. They will be added in separate commands.
|
||||
$sql = 'CREATE TABLE '.$this->wrap($table).' ('.$columns;
|
||||
|
||||
// SQLite does not allow adding a primary key as a command apart from
|
||||
// when the table is initially created, so we'll need to sniff out
|
||||
// any primary keys here and add them to the table.
|
||||
//
|
||||
// Because of this, this class does not have the typical "primary"
|
||||
// method as it would be pointless since the primary keys can't
|
||||
// be set on anything but the table creation statement.
|
||||
$primary = array_first($table->commands, function($key, $value)
|
||||
{
|
||||
return $value->type == 'primary';
|
||||
});
|
||||
|
||||
// If we found primary key in the array of commands, we'll create
|
||||
// the SQL for the key addition and append it to the SQL table
|
||||
// creation statement for the schema table.
|
||||
if ( ! is_null($primary))
|
||||
{
|
||||
$columns = $this->columnize($primary->columns);
|
||||
|
||||
$sql .= ", PRIMARY KEY ({$columns})";
|
||||
}
|
||||
|
||||
return $sql .= ')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Geenrate the SQL statements for a table modification command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return array
|
||||
*/
|
||||
public function add(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = $this->columns($table);
|
||||
|
||||
// Once we have an array of all of the column definitions, we need to
|
||||
// spin through each one and prepend "ADD COLUMN" to each of them,
|
||||
// which is the syntax used by SQLite when adding columns.
|
||||
$columns = array_map(function($column)
|
||||
{
|
||||
return 'ADD COLUMN '.$column;
|
||||
|
||||
}, $columns);
|
||||
|
||||
// SQLite only allows one column to be added in an ALTER statement,
|
||||
// so we will create an array of statements and return them all to
|
||||
// the schema manager, which will execute each one.
|
||||
foreach ($columns as $column)
|
||||
{
|
||||
$sql[] = 'ALTER TABLE '.$this->wrap($table).' '.$column;
|
||||
}
|
||||
|
||||
return (array) $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create the individual column definitions for the table.
|
||||
*
|
||||
* @param Table $table
|
||||
* @return array
|
||||
*/
|
||||
protected function columns(Table $table)
|
||||
{
|
||||
$columns = array();
|
||||
|
||||
foreach ($table->columns as $column)
|
||||
{
|
||||
// Each of the data type's have their own definition creation method
|
||||
// which is responsible for creating the SQL for the type. This lets
|
||||
// us to keep the syntax easy and fluent, while translating the
|
||||
// types to the types used by the database.
|
||||
$sql = $this->wrap($column).' '.$this->type($column);
|
||||
|
||||
$elements = array('nullable', 'defaults', 'incrementer');
|
||||
|
||||
foreach ($elements as $element)
|
||||
{
|
||||
$sql .= $this->$element($table, $column);
|
||||
}
|
||||
|
||||
$columns[] = $sql;
|
||||
}
|
||||
|
||||
return $columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for indicating if a column is nullable.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function nullable(Table $table, Fluent $column)
|
||||
{
|
||||
return ($column->nullable) ? ' NULL' : ' NOT NULL';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for specifying a default value on a column.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function defaults(Table $table, Fluent $column)
|
||||
{
|
||||
if ( ! is_null($column->default))
|
||||
{
|
||||
return ' DEFAULT '.$this->wrap($column->default);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for defining an auto-incrementing column.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function incrementer(Table $table, Fluent $column)
|
||||
{
|
||||
if ($column->type == 'integer' and $column->increment)
|
||||
{
|
||||
return ' PRIMARY KEY AUTOINCREMENT';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a unique index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function unique(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a full-text index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function fulltext(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = $this->columnize($command->columns);
|
||||
|
||||
return 'CREATE VIRTUAL TABLE '.$this->wrap($table)." USING fts4({$columns})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a regular index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function index(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a new index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @param bool $unique
|
||||
* @return string
|
||||
*/
|
||||
protected function key(Table $table, Fluent $command, $unique = false)
|
||||
{
|
||||
$columns = $this->columnize($command->columns);
|
||||
|
||||
$create = ($unique) ? 'CREATE UNIQUE' : 'CREATE';
|
||||
|
||||
return $create." INDEX {$command->name} ON ".$this->wrap($table)." ({$columns})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop table command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop(Table $table, Fluent $command)
|
||||
{
|
||||
return 'DROP TABLE '.$this->wrap($table);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop unqique key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_unique(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop unqique key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_index(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
protected function drop_key(Table $table, Fluent $command)
|
||||
{
|
||||
return 'DROP INDEX '.$this->wrap($command->name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a string.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_string(Fluent $column)
|
||||
{
|
||||
return 'VARCHAR';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for an integer.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_integer(Fluent $column)
|
||||
{
|
||||
return 'INTEGER';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for an integer.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_float(Fluent $column)
|
||||
{
|
||||
return 'FLOAT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a boolean.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_boolean(Fluent $column)
|
||||
{
|
||||
return 'INTEGER';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a date.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_date(Fluent $column)
|
||||
{
|
||||
return 'DATETIME';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a timestamp.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_timestamp(Fluent $column)
|
||||
{
|
||||
return 'DATETIME';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a text column.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_text(Fluent $column)
|
||||
{
|
||||
return 'TEXT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a blob.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_blob(Fluent $column)
|
||||
{
|
||||
return 'BLOB';
|
||||
}
|
||||
|
||||
}
|
||||
402
laravel/database/schema/grammars/sqlserver.php
Normal file
402
laravel/database/schema/grammars/sqlserver.php
Normal file
@@ -0,0 +1,402 @@
|
||||
<?php namespace Laravel\Database\Schema\Grammars;
|
||||
|
||||
use Laravel\Fluent;
|
||||
use Laravel\Database\Schema\Table;
|
||||
|
||||
class SQLServer extends Grammar {
|
||||
|
||||
/**
|
||||
* The keyword identifier for the database system.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $wrapper = '[%s]';
|
||||
|
||||
/**
|
||||
* Generate the SQL statements for a table creation command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return array
|
||||
*/
|
||||
public function create(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = implode(', ', $this->columns($table));
|
||||
|
||||
// First we will generate the base table creation statement. Other than
|
||||
// auto-incrementing keys, no indexes will be created during the first
|
||||
// creation of the table. They will be added in separate commands.
|
||||
$sql = 'CREATE TABLE '.$this->wrap($table).' ('.$columns.')';
|
||||
|
||||
return $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Geenrate the SQL statements for a table modification command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return array
|
||||
*/
|
||||
public function add(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = $this->columns($table);
|
||||
|
||||
// Once we the array of column definitions, we need to add "add"
|
||||
// to the front of each definition, then we'll concatenate the
|
||||
// definitions using commas like normal and generate the SQL.
|
||||
$columns = implode(', ', array_map(function($column)
|
||||
{
|
||||
return 'ADD '.$column;
|
||||
|
||||
}, $columns));
|
||||
|
||||
return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create the individual column definitions for the table.
|
||||
*
|
||||
* @param Table $table
|
||||
* @return array
|
||||
*/
|
||||
protected function columns(Table $table)
|
||||
{
|
||||
$columns = array();
|
||||
|
||||
foreach ($table->columns as $column)
|
||||
{
|
||||
// Each of the data type's have their own definition creation method,
|
||||
// which is responsible for creating the SQL for the type. This lets
|
||||
// us to keep the syntax easy and fluent, while translating the
|
||||
// types to the types used by the database.
|
||||
$sql = $this->wrap($column).' '.$this->type($column);
|
||||
|
||||
$elements = array('incrementer', 'nullable', 'defaults');
|
||||
|
||||
foreach ($elements as $element)
|
||||
{
|
||||
$sql .= $this->$element($table, $column);
|
||||
}
|
||||
|
||||
$columns[] = $sql;
|
||||
}
|
||||
|
||||
return $columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for indicating if a column is nullable.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function nullable(Table $table, Fluent $column)
|
||||
{
|
||||
return ($column->nullable) ? ' NULL' : ' NOT NULL';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for specifying a default value on a column.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function defaults(Table $table, Fluent $column)
|
||||
{
|
||||
if ( ! is_null($column->default))
|
||||
{
|
||||
return " DEFAULT '".$column->default."'";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the SQL syntax for defining an auto-incrementing column.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function incrementer(Table $table, Fluent $column)
|
||||
{
|
||||
if ($column->type == 'integer' and $column->increment)
|
||||
{
|
||||
return ' IDENTITY PRIMARY KEY';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a primary key.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function primary(Table $table, Fluent $command)
|
||||
{
|
||||
$name = $command->name;
|
||||
|
||||
$columns = $this->columnize($columns);
|
||||
|
||||
return 'ALTER TABLE '.$this->wrap($table)." ADD CONSTRAINT {$name} PRIMARY KEY ({$columns})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a unique index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function unique(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a full-text index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function fulltext(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = $this->columnize($command->columns);
|
||||
|
||||
// SQL Server requires the creation of a full-text "catalog" before
|
||||
// creating a full-text index, so we'll first create the catalog
|
||||
// then add another statement for the index. The catalog will
|
||||
// be updated automatically by the server.
|
||||
$sql[] = "CREATE FULLTEXT CATALOG {$command->catalog}";
|
||||
|
||||
$create = "CREATE FULLTEXT INDEX ON ".$this->wrap($table)." ({$columns}) ";
|
||||
|
||||
// Full-text indexes must specify a unique, non-nullable column as
|
||||
// the index "key" and this should have been created manually by
|
||||
// the developer in a separate column addition command, so we
|
||||
// can just specify it in this statement.
|
||||
$sql[] = $create .= "KEY INDEX {$command->key} ON {$command->catalog}";
|
||||
|
||||
return $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a regular index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function index(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for creating a new index.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @param bool $unique
|
||||
* @return string
|
||||
*/
|
||||
protected function key(Table $table, Fluent $command, $unique = false)
|
||||
{
|
||||
$columns = $this->columnize($command->columns);
|
||||
|
||||
$create = ($unique) ? 'CREATE UNIQUE' : 'CREATE';
|
||||
|
||||
return $create." INDEX {$command->name} ON ".$this->wrap($table)." ({$columns})";
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop table command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop(Table $table, Fluent $command)
|
||||
{
|
||||
return 'DROP TABLE '.$this->wrap($table);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop column command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_column(Table $table, Fluent $command)
|
||||
{
|
||||
$columns = array_map(array($this, 'wrap'), $command->columns);
|
||||
|
||||
// Once we the array of column names, we need to add "drop" to the
|
||||
// front of each column, then we'll concatenate the columns using
|
||||
// commas and generate the alter statement SQL.
|
||||
$columns = implode(', ', array_map(function($column)
|
||||
{
|
||||
return 'DROP '.$column;
|
||||
|
||||
}, $columns));
|
||||
|
||||
return 'ALTER TABLE '.$this->wrap($table).' '.$columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop primary key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_primary(Table $table, Fluent $command)
|
||||
{
|
||||
return 'ALTER TABLE '.$this->wrap($table).' DROP CONSTRAINT '.$command->name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop unqiue key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_unique(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop full-text key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_fulltext(Table $table, Fluent $command)
|
||||
{
|
||||
$sql[] = "DROP FULLTEXT INDEX ".$command->name;
|
||||
|
||||
$sql[] = "DROP FULLTEXT CATALOG ".$command->catalog;
|
||||
|
||||
return $sql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop index command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
public function drop_index(Table $table, Fluent $command)
|
||||
{
|
||||
return $this->drop_key($table, $command);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the SQL statement for a drop key command.
|
||||
*
|
||||
* @param Table $table
|
||||
* @param Fluent $command
|
||||
* @return string
|
||||
*/
|
||||
protected function drop_key(Table $table, Fluent $command)
|
||||
{
|
||||
return "DROP INDEX {$command->name} ON ".$this->wrap($table);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a string.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_string(Fluent $column)
|
||||
{
|
||||
return 'NVARCHAR('.$column->length.')';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for an integer.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_integer(Fluent $column)
|
||||
{
|
||||
return 'INT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for an integer.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_float(Fluent $column)
|
||||
{
|
||||
return 'FLOAT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a boolean.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_boolean(Fluent $column)
|
||||
{
|
||||
return 'TINYINT';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a date.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_date(Fluent $column)
|
||||
{
|
||||
return 'DATETIME';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a timestamp.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_timestamp(Fluent $column)
|
||||
{
|
||||
return 'TIMESTAMP';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a text column.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_text(Fluent $column)
|
||||
{
|
||||
return 'NVARCHAR(MAX)';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the data-type definition for a blob.
|
||||
*
|
||||
* @param Fluent $column
|
||||
* @return string
|
||||
*/
|
||||
protected function type_blob(Fluent $column)
|
||||
{
|
||||
return 'VARBINARY(MAX)';
|
||||
}
|
||||
|
||||
}
|
||||
371
laravel/database/schema/table.php
Normal file
371
laravel/database/schema/table.php
Normal file
@@ -0,0 +1,371 @@
|
||||
<?php namespace Laravel\Database\Schema;
|
||||
|
||||
use Laravel\Fluent;
|
||||
|
||||
class Table {
|
||||
|
||||
/**
|
||||
* The database table name.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $name;
|
||||
|
||||
/**
|
||||
* The database connection that should be used.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $connection;
|
||||
|
||||
/**
|
||||
* The engine that should be used for the table.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $engine;
|
||||
|
||||
/**
|
||||
* The columns that should be added to the table.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
public $columns = array();
|
||||
|
||||
/**
|
||||
* The commands that should be executed on the table.
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
public $commands = array();
|
||||
|
||||
/**
|
||||
* Create a new schema table instance.
|
||||
*
|
||||
* @param string $name
|
||||
* @return void
|
||||
*/
|
||||
public function __construct($name)
|
||||
{
|
||||
$this->name = $name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Indicate that the table should be created.
|
||||
*
|
||||
* @return Fluent
|
||||
*/
|
||||
public function create()
|
||||
{
|
||||
return $this->command(__FUNCTION__);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new primary key on the table.
|
||||
*
|
||||
* @param string|array $columns
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function primary($columns, $name = null)
|
||||
{
|
||||
return $this->key(__FUNCTION__, $columns, $name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new unique index on the table.
|
||||
*
|
||||
* @param string|array $columns
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function unique($columns, $name = null)
|
||||
{
|
||||
return $this->key(__FUNCTION__, $columns, $name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new full-text index on the table.
|
||||
*
|
||||
* @param string|array $columns
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function fulltext($columns, $name = null)
|
||||
{
|
||||
return $this->key(__FUNCTION__, $columns, $name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new index on the table.
|
||||
*
|
||||
* @param string|array
|
||||
*/
|
||||
public function index($columns, $name = null)
|
||||
{
|
||||
return $this->key(__FUNCTION__, $columns, $name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a command for creating any index.
|
||||
*
|
||||
* @param string $type
|
||||
* @param string|array $columns
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function key($type, $columns, $name = null)
|
||||
{
|
||||
$parameters = array('name' => $name, 'columns' => (array) $columns);
|
||||
|
||||
return $this->command($type, $parameters);
|
||||
}
|
||||
|
||||
/**
|
||||
* Drop the database table.
|
||||
*
|
||||
* @return Fluent
|
||||
*/
|
||||
public function drop()
|
||||
{
|
||||
return $this->command(__FUNCTION__);
|
||||
}
|
||||
|
||||
/**
|
||||
* Drop a column from the table.
|
||||
*
|
||||
* @param string|array $columns
|
||||
* @return void
|
||||
*/
|
||||
public function drop_column($columns)
|
||||
{
|
||||
return $this->command(__FUNCTION__, array('columns' => (array) $columns));
|
||||
}
|
||||
|
||||
/**
|
||||
* Drop a primary key from the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return void
|
||||
*/
|
||||
public function drop_primary($name)
|
||||
{
|
||||
return $this->drop_key(__FUNCTION__, $name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Drop a unique index from the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return void
|
||||
*/
|
||||
public function drop_unique($name)
|
||||
{
|
||||
return $this->drop_key(__FUNCTION__, $name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Drop a full-text index from the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return void
|
||||
*/
|
||||
public function drop_fulltext($name)
|
||||
{
|
||||
return $this->drop_key(__FUNCTION__, $name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Drop an index from the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return void
|
||||
*/
|
||||
public function drop_index($name)
|
||||
{
|
||||
return $this->drop_key(__FUNCTION__, $name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a command to drop any type of index.
|
||||
*
|
||||
* @param string $type
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
protected function drop_key($type, $name)
|
||||
{
|
||||
return $this->command($type, array('name' => $name));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an auto-incrementing integer to the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function increments($name)
|
||||
{
|
||||
return $this->integer($name, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a string column to the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @param int $length
|
||||
* @return Fluent
|
||||
*/
|
||||
public function string($name, $length = 200)
|
||||
{
|
||||
return $this->column(__FUNCTION__, compact('name', 'length'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an integer column to the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @param bool $increment
|
||||
* @return Fluent
|
||||
*/
|
||||
public function integer($name, $increment = false)
|
||||
{
|
||||
return $this->column(__FUNCTION__, compact('name', 'increment'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a float column to the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @param bool $increment
|
||||
* @return Fluent
|
||||
*/
|
||||
public function float($name)
|
||||
{
|
||||
return $this->column(__FUNCTION__, compact('name'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a boolean column to the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function boolean($name)
|
||||
{
|
||||
return $this->column(__FUNCTION__, compact('name'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Create date-time columns for creation and update timestamps.
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function timestamps()
|
||||
{
|
||||
$this->date('created_at');
|
||||
|
||||
$this->date('updated_at');
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a date-time column to the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function date($name)
|
||||
{
|
||||
return $this->column(__FUNCTION__, compact('name'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a timestamp column to the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function timestamp($name)
|
||||
{
|
||||
return $this->column(__FUNCTION__, compact('name'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a text column to the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function text($name)
|
||||
{
|
||||
return $this->column(__FUNCTION__, compact('name'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a blob column to the table.
|
||||
*
|
||||
* @param string $name
|
||||
* @return Fluent
|
||||
*/
|
||||
public function blob($name)
|
||||
{
|
||||
return $this->column(__FUNCTION__, compact('name'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the database connection for the table operation.
|
||||
*
|
||||
* @param string $connection
|
||||
* @return void
|
||||
*/
|
||||
public function on($connection)
|
||||
{
|
||||
$this->connection = $connection;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if the schema table has a creation command.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function creating()
|
||||
{
|
||||
return ! is_null(array_first($this->commands, function($key, $value)
|
||||
{
|
||||
return $value->type == 'create';
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new fluent command instance.
|
||||
*
|
||||
* @param string $type
|
||||
* @param array $parameters
|
||||
* @return Fluent
|
||||
*/
|
||||
protected function command($type, $parameters = array())
|
||||
{
|
||||
$parameters = array_merge(compact('type'), $parameters);
|
||||
|
||||
$this->commands[] = new Fluent($parameters);
|
||||
|
||||
return end($this->commands);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new fluent column instance.
|
||||
*
|
||||
* @param string $type
|
||||
* @param array $parameters
|
||||
* @return Fluent
|
||||
*/
|
||||
protected function column($type, $parameters = array())
|
||||
{
|
||||
$parameters = array_merge(compact('type'), $parameters);
|
||||
|
||||
$this->columns[] = new Fluent($parameters);
|
||||
|
||||
return end($this->columns);
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user