Subversion-Projekte lars-tiefland.laravel_shop

<?php

namespace Illuminate\Database\Schema;

use BadMethodCallException;

use Closure;

use Illuminate\Database\Connection;

use Illuminate\Database\Query\Expression;

use Illuminate\Database\Schema\Grammars\Grammar;

use Illuminate\Database\SQLiteConnection;

use Illuminate\Support\Fluent;

use Illuminate\Support\Traits\Macroable;

class Blueprint

{

    use Macroable;

    /**

     * The table the blueprint describes.

     *

     * @var string

     */

    protected $table;

    /**

     * The prefix of the table.

     *

     * @var string

     */

    protected $prefix;

    /**

     * The columns that should be added to the table.

     *

     * @var \Illuminate\Database\Schema\ColumnDefinition[]

     */

    protected $columns = [];

    /**

     * The commands that should be run for the table.

     *

     * @var \Illuminate\Support\Fluent[]

     */

    protected $commands = [];

    /**

     * The storage engine that should be used for the table.

     *

     * @var string

     */

    public $engine;

    /**

     * The default character set that should be used for the table.

     *

     * @var string

     */

    public $charset;

    /**

     * The collation that should be used for the table.

     *

     * @var string

     */

    public $collation;

    /**

     * Whether to make the table temporary.

     *

     * @var bool

     */

    public $temporary = false;

    /**

     * The column to add new columns after.

     *

     * @var string

     */

    public $after;

    /**

     * Create a new schema blueprint.

     *

     * @param  string  $table

     * @param  \Closure|null  $callback

     * @param  string  $prefix

     * @return void

     */

    public function __construct($table, Closure $callback = null, $prefix = '')

    {

        $this->table = $table;

        $this->prefix = $prefix;

        if (! is_null($callback)) {

            $callback($this);

        }

    }

    /**

     * Execute the blueprint against the database.

     *

     * @param  \Illuminate\Database\Connection  $connection

     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar

     * @return void

     */

    public function build(Connection $connection, Grammar $grammar)

    {

        foreach ($this->toSql($connection, $grammar) as $statement) {

            $connection->statement($statement);

        }

    }

    /**

     * Get the raw SQL statements for the blueprint.

     *

     * @param  \Illuminate\Database\Connection  $connection

     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar

     * @return array

     */

    public function toSql(Connection $connection, Grammar $grammar)

    {

        $this->addImpliedCommands($grammar);

        $statements = [];

        // Each type of command has a corresponding compiler function on the schema

        // grammar which is used to build the necessary SQL statements to build

        // the blueprint element, so we'll just call that compilers function.

        $this->ensureCommandsAreValid($connection);

        foreach ($this->commands as $command) {

            $method = 'compile'.ucfirst($command->name);

            if (method_exists($grammar, $method) || $grammar::hasMacro($method)) {

                if (! is_null($sql = $grammar->$method($this, $command, $connection))) {

                    $statements = array_merge($statements, (array) $sql);

                }

            }

        }

        return $statements;

    }

    /**

     * Ensure the commands on the blueprint are valid for the connection type.

     *

     * @param  \Illuminate\Database\Connection  $connection

     * @return void

     *

     * @throws \BadMethodCallException

     */

    protected function ensureCommandsAreValid(Connection $connection)

    {

        if ($connection instanceof SQLiteConnection) {

            if ($this->commandsNamed(['dropColumn', 'renameColumn'])->count() > 1

                && ! $connection->usingNativeSchemaOperations()) {

                throw new BadMethodCallException(

                    "SQLite doesn't support multiple calls to dropColumn / renameColumn in a single modification."

                );

            }

            if ($this->commandsNamed(['dropForeign'])->count() > 0) {

                throw new BadMethodCallException(

                    "SQLite doesn't support dropping foreign keys (you would need to re-create the table)."

                );

            }

        }

    }

    /**

     * Get all of the commands matching the given names.

     *

     * @param  array  $names

     * @return \Illuminate\Support\Collection

     */

    protected function commandsNamed(array $names)

    {

        return collect($this->commands)->filter(function ($command) use ($names) {

            return in_array($command->name, $names);

        });

    }

    /**

     * Add the commands that are implied by the blueprint's state.

     *

     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar

     * @return void

     */

    protected function addImpliedCommands(Grammar $grammar)

    {

        if (count($this->getAddedColumns()) > 0 && ! $this->creating()) {

            array_unshift($this->commands, $this->createCommand('add'));

        }

        if (count($this->getChangedColumns()) > 0 && ! $this->creating()) {

            array_unshift($this->commands, $this->createCommand('change'));

        }

        $this->addFluentIndexes();

        $this->addFluentCommands($grammar);

    }

    /**

     * Add the index commands fluently specified on columns.

     *

     * @return void

     */

    protected function addFluentIndexes()

    {

        foreach ($this->columns as $column) {

            foreach (['primary', 'unique', 'index', 'fulltext', 'fullText', 'spatialIndex'] as $index) {

                // If the index has been specified on the given column, but is simply equal

                // to "true" (boolean), no name has been specified for this index so the

                // index method can be called without a name and it will generate one.

                if ($column->{$index} === true) {

                    $this->{$index}($column->name);

                    $column->{$index} = null;

                    continue 2;

                }

                // If the index has been specified on the given column, but it equals false

                // and the column is supposed to be changed, we will call the drop index

                // method with an array of column to drop it by its conventional name.

                elseif ($column->{$index} === false && $column->change) {

                    $this->{'drop'.ucfirst($index)}([$column->name]);

                    $column->{$index} = null;

                    continue 2;

                }

                // If the index has been specified on the given column, and it has a string

                // value, we'll go ahead and call the index method and pass the name for

                // the index since the developer specified the explicit name for this.

                elseif (isset($column->{$index})) {

                    $this->{$index}($column->name, $column->{$index});

                    $column->{$index} = null;

                    continue 2;

                }

            }

        }

    }

    /**

     * Add the fluent commands specified on any columns.

     *

     * @param  \Illuminate\Database\Schema\Grammars\Grammar  $grammar

     * @return void

     */

    public function addFluentCommands(Grammar $grammar)

    {

        foreach ($this->columns as $column) {

            foreach ($grammar->getFluentCommands() as $commandName) {

                $attributeName = lcfirst($commandName);

                if (! isset($column->{$attributeName})) {

                    continue;

                }

                $value = $column->{$attributeName};

                $this->addCommand(

                    $commandName, compact('value', 'column')

                );

            }

        }

    }

    /**

     * Determine if the blueprint has a create command.

     *

     * @return bool

     */

    public function creating()

    {

        return collect($this->commands)->contains(function ($command) {

            return $command->name === 'create';

        });

    }

    /**

     * Indicate that the table needs to be created.

     *

     * @return \Illuminate\Support\Fluent

     */

    public function create()

    {

        return $this->addCommand('create');

    }

    /**

     * Indicate that the table needs to be temporary.

     *

     * @return void

     */

    public function temporary()

    {

        $this->temporary = true;

    }

    /**

     * Indicate that the table should be dropped.

     *

     * @return \Illuminate\Support\Fluent

     */

    public function drop()

    {

        return $this->addCommand('drop');

    }

    /**

     * Indicate that the table should be dropped if it exists.

     *

     * @return \Illuminate\Support\Fluent

     */

    public function dropIfExists()

    {

        return $this->addCommand('dropIfExists');

    }

    /**

     * Indicate that the given columns should be dropped.

     *

     * @param  array|mixed  $columns

     * @return \Illuminate\Support\Fluent

     */

    public function dropColumn($columns)

    {

        $columns = is_array($columns) ? $columns : func_get_args();

        return $this->addCommand('dropColumn', compact('columns'));

    }

    /**

     * Indicate that the given columns should be renamed.

     *

     * @param  string  $from

     * @param  string  $to

     * @return \Illuminate\Support\Fluent

     */

    public function renameColumn($from, $to)

    {

        return $this->addCommand('renameColumn', compact('from', 'to'));

    }

    /**

     * Indicate that the given primary key should be dropped.

     *

     * @param  string|array|null  $index

     * @return \Illuminate\Support\Fluent

     */

    public function dropPrimary($index = null)

    {

        return $this->dropIndexCommand('dropPrimary', 'primary', $index);

    }

    /**

     * Indicate that the given unique key should be dropped.

     *

     * @param  string|array  $index

     * @return \Illuminate\Support\Fluent

     */

    public function dropUnique($index)

    {

        return $this->dropIndexCommand('dropUnique', 'unique', $index);

    }

    /**

     * Indicate that the given index should be dropped.

     *

     * @param  string|array  $index

     * @return \Illuminate\Support\Fluent

     */

    public function dropIndex($index)

    {

        return $this->dropIndexCommand('dropIndex', 'index', $index);

    }

    /**

     * Indicate that the given fulltext index should be dropped.

     *

     * @param  string|array  $index

     * @return \Illuminate\Support\Fluent

     */

    public function dropFullText($index)

    {

        return $this->dropIndexCommand('dropFullText', 'fulltext', $index);

    }

    /**

     * Indicate that the given spatial index should be dropped.

     *

     * @param  string|array  $index

     * @return \Illuminate\Support\Fluent

     */

    public function dropSpatialIndex($index)

    {

        return $this->dropIndexCommand('dropSpatialIndex', 'spatialIndex', $index);

    }

    /**

     * Indicate that the given foreign key should be dropped.

     *

     * @param  string|array  $index

     * @return \Illuminate\Support\Fluent

     */

    public function dropForeign($index)

    {

        return $this->dropIndexCommand('dropForeign', 'foreign', $index);

    }

    /**

     * Indicate that the given column and foreign key should be dropped.

     *

     * @param  string  $column

     * @return \Illuminate\Support\Fluent

     */

    public function dropConstrainedForeignId($column)

    {

        $this->dropForeign([$column]);

        return $this->dropColumn($column);

    }

    /**

     * Indicate that the given foreign key should be dropped.

     *

     * @param  \Illuminate\Database\Eloquent\Model|string  $model

     * @param  string|null  $column

     * @return \Illuminate\Support\Fluent

     */

    public function dropForeignIdFor($model, $column = null)

    {

        if (is_string($model)) {

            $model = new $model;

        }

        return $this->dropForeign([$column ?: $model->getForeignKey()]);

    }

    /**

     * Indicate that the given foreign key should be dropped.

     *

     * @param  \Illuminate\Database\Eloquent\Model|string  $model

     * @param  string|null  $column

     * @return \Illuminate\Support\Fluent

     */

    public function dropConstrainedForeignIdFor($model, $column = null)

    {

        if (is_string($model)) {

            $model = new $model;

        }

        return $this->dropConstrainedForeignId($column ?: $model->getForeignKey());

    }

    /**

     * Indicate that the given indexes should be renamed.

     *

     * @param  string  $from

     * @param  string  $to

     * @return \Illuminate\Support\Fluent

     */

    public function renameIndex($from, $to)

    {

        return $this->addCommand('renameIndex', compact('from', 'to'));

    }

    /**

     * Indicate that the timestamp columns should be dropped.

     *

     * @return void

     */

    public function dropTimestamps()

    {

        $this->dropColumn('created_at', 'updated_at');

    }

    /**

     * Indicate that the timestamp columns should be dropped.

     *

     * @return void

     */

    public function dropTimestampsTz()

    {

        $this->dropTimestamps();

    }

    /**

     * Indicate that the soft delete column should be dropped.

     *

     * @param  string  $column

     * @return void

     */

    public function dropSoftDeletes($column = 'deleted_at')

    {

        $this->dropColumn($column);

    }

    /**

     * Indicate that the soft delete column should be dropped.

     *

     * @param  string  $column

     * @return void

     */

    public function dropSoftDeletesTz($column = 'deleted_at')

    {

        $this->dropSoftDeletes($column);

    }

    /**

     * Indicate that the remember token column should be dropped.

     *

     * @return void

     */

    public function dropRememberToken()

    {

        $this->dropColumn('remember_token');

    }

    /**

     * Indicate that the polymorphic columns should be dropped.

     *

     * @param  string  $name

     * @param  string|null  $indexName

     * @return void

     */

    public function dropMorphs($name, $indexName = null)

    {

        $this->dropIndex($indexName ?: $this->createIndexName('index', ["{$name}_type", "{$name}_id"]));

        $this->dropColumn("{$name}_type", "{$name}_id");

    }

    /**

     * Rename the table to a given name.

     *

     * @param  string  $to

     * @return \Illuminate\Support\Fluent

     */

    public function rename($to)

    {

        return $this->addCommand('rename', compact('to'));

    }

    /**

     * Specify the primary key(s) for the table.

     *

     * @param  string|array  $columns

     * @param  string|null  $name

     * @param  string|null  $algorithm

     * @return \Illuminate\Database\Schema\IndexDefinition

     */

    public function primary($columns, $name = null, $algorithm = null)

    {

        return $this->indexCommand('primary', $columns, $name, $algorithm);

    }

    /**

     * Specify a unique index for the table.

     *

     * @param  string|array  $columns

     * @param  string|null  $name

     * @param  string|null  $algorithm

     * @return \Illuminate\Database\Schema\IndexDefinition

     */

    public function unique($columns, $name = null, $algorithm = null)

    {

        return $this->indexCommand('unique', $columns, $name, $algorithm);

    }

    /**

     * Specify an index for the table.

     *

     * @param  string|array  $columns

     * @param  string|null  $name

     * @param  string|null  $algorithm

     * @return \Illuminate\Database\Schema\IndexDefinition

     */

    public function index($columns, $name = null, $algorithm = null)

    {

        return $this->indexCommand('index', $columns, $name, $algorithm);

    }

    /**

     * Specify an fulltext for the table.

     *

     * @param  string|array  $columns

     * @param  string|null  $name

     * @param  string|null  $algorithm

     * @return \Illuminate\Database\Schema\IndexDefinition

     */

    public function fullText($columns, $name = null, $algorithm = null)

    {

        return $this->indexCommand('fulltext', $columns, $name, $algorithm);

    }

    /**

     * Specify a spatial index for the table.

     *

     * @param  string|array  $columns

     * @param  string|null  $name

     * @return \Illuminate\Database\Schema\IndexDefinition

     */

    public function spatialIndex($columns, $name = null)

    {

        return $this->indexCommand('spatialIndex', $columns, $name);

    }

    /**

     * Specify a raw index for the table.

     *

     * @param  string  $expression

     * @param  string  $name

     * @return \Illuminate\Database\Schema\IndexDefinition

     */

    public function rawIndex($expression, $name)

    {

        return $this->index([new Expression($expression)], $name);

    }

    /**

     * Specify a foreign key for the table.

     *

     * @param  string|array  $columns

     * @param  string|null  $name

     * @return \Illuminate\Database\Schema\ForeignKeyDefinition

     */

    public function foreign($columns, $name = null)

    {

        $command = new ForeignKeyDefinition(

            $this->indexCommand('foreign', $columns, $name)->getAttributes()

        );

        $this->commands[count($this->commands) - 1] = $command;

        return $command;

    }

    /**

     * Create a new auto-incrementing big integer (8-byte) column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function id($column = 'id')

    {

        return $this->bigIncrements($column);

    }

    /**

     * Create a new auto-incrementing integer (4-byte) column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function increments($column)

    {

        return $this->unsignedInteger($column, true);

    }

    /**

     * Create a new auto-incrementing integer (4-byte) column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function integerIncrements($column)

    {

        return $this->unsignedInteger($column, true);

    }

    /**

     * Create a new auto-incrementing tiny integer (1-byte) column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function tinyIncrements($column)

    {

        return $this->unsignedTinyInteger($column, true);

    }

    /**

     * Create a new auto-incrementing small integer (2-byte) column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function smallIncrements($column)

    {

        return $this->unsignedSmallInteger($column, true);

    }

    /**

     * Create a new auto-incrementing medium integer (3-byte) column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function mediumIncrements($column)

    {

        return $this->unsignedMediumInteger($column, true);

    }

    /**

     * Create a new auto-incrementing big integer (8-byte) column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function bigIncrements($column)

    {

        return $this->unsignedBigInteger($column, true);

    }

    /**

     * Create a new char column on the table.

     *

     * @param  string  $column

     * @param  int|null  $length

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function char($column, $length = null)

    {

        $length = ! is_null($length) ? $length : Builder::$defaultStringLength;

        return $this->addColumn('char', $column, compact('length'));

    }

    /**

     * Create a new string column on the table.

     *

     * @param  string  $column

     * @param  int|null  $length

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function string($column, $length = null)

    {

        $length = $length ?: Builder::$defaultStringLength;

        return $this->addColumn('string', $column, compact('length'));

    }

    /**

     * Create a new tiny text column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function tinyText($column)

    {

        return $this->addColumn('tinyText', $column);

    }

    /**

     * Create a new text column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function text($column)

    {

        return $this->addColumn('text', $column);

    }

    /**

     * Create a new medium text column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function mediumText($column)

    {

        return $this->addColumn('mediumText', $column);

    }

    /**

     * Create a new long text column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function longText($column)

    {

        return $this->addColumn('longText', $column);

    }

    /**

     * Create a new integer (4-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @param  bool  $unsigned

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function integer($column, $autoIncrement = false, $unsigned = false)

    {

        return $this->addColumn('integer', $column, compact('autoIncrement', 'unsigned'));

    }

    /**

     * Create a new tiny integer (1-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @param  bool  $unsigned

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function tinyInteger($column, $autoIncrement = false, $unsigned = false)

    {

        return $this->addColumn('tinyInteger', $column, compact('autoIncrement', 'unsigned'));

    }

    /**

     * Create a new small integer (2-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @param  bool  $unsigned

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function smallInteger($column, $autoIncrement = false, $unsigned = false)

    {

        return $this->addColumn('smallInteger', $column, compact('autoIncrement', 'unsigned'));

    }

    /**

     * Create a new medium integer (3-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @param  bool  $unsigned

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function mediumInteger($column, $autoIncrement = false, $unsigned = false)

    {

        return $this->addColumn('mediumInteger', $column, compact('autoIncrement', 'unsigned'));

    }

    /**

     * Create a new big integer (8-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @param  bool  $unsigned

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function bigInteger($column, $autoIncrement = false, $unsigned = false)

    {

        return $this->addColumn('bigInteger', $column, compact('autoIncrement', 'unsigned'));

    }

    /**

     * Create a new unsigned integer (4-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function unsignedInteger($column, $autoIncrement = false)

    {

        return $this->integer($column, $autoIncrement, true);

    }

    /**

     * Create a new unsigned tiny integer (1-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function unsignedTinyInteger($column, $autoIncrement = false)

    {

        return $this->tinyInteger($column, $autoIncrement, true);

    }

    /**

     * Create a new unsigned small integer (2-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function unsignedSmallInteger($column, $autoIncrement = false)

    {

        return $this->smallInteger($column, $autoIncrement, true);

    }

    /**

     * Create a new unsigned medium integer (3-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function unsignedMediumInteger($column, $autoIncrement = false)

    {

        return $this->mediumInteger($column, $autoIncrement, true);

    }

    /**

     * Create a new unsigned big integer (8-byte) column on the table.

     *

     * @param  string  $column

     * @param  bool  $autoIncrement

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function unsignedBigInteger($column, $autoIncrement = false)

    {

        return $this->bigInteger($column, $autoIncrement, true);

    }

    /**

     * Create a new unsigned big integer (8-byte) column on the table.

     *

     * @param  string  $column

     * @return \Illuminate\Database\Schema\ForeignIdColumnDefinition

     */

    public function foreignId($column)

    {

        return $this->addColumnDefinition(new ForeignIdColumnDefinition($this, [

            'type' => 'bigInteger',

            'name' => $column,

            'autoIncrement' => false,

            'unsigned' => true,

        ]));

    }

    /**

     * Create a foreign ID column for the given model.

     *

     * @param  \Illuminate\Database\Eloquent\Model|string  $model

     * @param  string|null  $column

     * @return \Illuminate\Database\Schema\ForeignIdColumnDefinition

     */

    public function foreignIdFor($model, $column = null)

    {

        if (is_string($model)) {

            $model = new $model;

        }

        return $model->getKeyType() === 'int' && $model->getIncrementing()

                    ? $this->foreignId($column ?: $model->getForeignKey())

                    : $this->foreignUuid($column ?: $model->getForeignKey());

    }

    /**

     * Create a new float column on the table.

     *

     * @param  string  $column

     * @param  int  $total

     * @param  int  $places

     * @param  bool  $unsigned

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function float($column, $total = 8, $places = 2, $unsigned = false)

    {

        return $this->addColumn('float', $column, compact('total', 'places', 'unsigned'));

    }

    /**

     * Create a new double column on the table.

     *

     * @param  string  $column

     * @param  int|null  $total

     * @param  int|null  $places

     * @param  bool  $unsigned

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function double($column, $total = null, $places = null, $unsigned = false)

    {

        return $this->addColumn('double', $column, compact('total', 'places', 'unsigned'));

    }

    /**

     * Create a new decimal column on the table.

     *

     * @param  string  $column

     * @param  int  $total

     * @param  int  $places

     * @param  bool  $unsigned

     * @return \Illuminate\Database\Schema\ColumnDefinition

     */

    public function decimal($column, $total = 8, $places = 2, $unsigned = false)

    {

        return $this->addColumn('decimal', $column, compact('total', 'places', 'unsigned'));

    }

    /**

     * Create a new unsigned float column on the table.

     *

     * @param  string  $column

     * @param  int  $total

     * @param  int  $places