Projects [SHOW]

Generating Migrations

Um eine Migration zu erstellen, verwenden Sie den Artisan Befehl make:migration:

php artisan make:migration create_users_table

Die neue Migration wird in Ihrem Datenbank-/Migrationsverzeichnis (database/migrations directory) abgelegt. Jeder Name der Migrationsdatei enthält einen Zeitstempel, der es Laravel erlaubt, die Reihenfolge der Migrationen zu bestimmen.

Die --table und --create Optionen können auch verwendet werden, um den Namen der Tabelle anzugeben und ob die Migration eine neue Tabelle erstellen wird. Diese Optionen füllen die generierte Migrations-Stub-Datei mit der angegebenen Tabelle vor:

php artisan make:migration create_users_table --create=users

php artisan make:migration add_votes_to_users_table --table=users

Wenn Sie einen benutzerdefinierten Ausgabepfad für die generierte Migration angeben möchten, können Sie bei der Ausführung des Befehls make:migration die Option --path verwenden. Der angegebene Pfad sollte relativ zum Basispfad Ihrer Anwendung sein.

Migration Structure

Eine Migrationsklasse enthält zwei Methoden: up und down. Die up-Methode wird verwendet, um neue Tabellen, Spalten oder Indizes zu Ihrer Datenbank hinzuzufügen, während die down-Methode die von der up-Methode ausgeführten Operationen umkehren sollte.

Innerhalb dieser beiden Methoden können Sie den Laravel-Schema-Builder verwenden, um ausdrucksstarke Tabellen zu erstellen und zu modifizieren. Um mehr über alle verfügbaren Methoden des Schema-Builders zu erfahren, schauen Sie sich seine Dokumentation an. Dieses Migrationsbeispiel erstellt beispielsweise eine Flugtabelle:

<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateFlightsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('flights', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->string('airline');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::drop('flights');
    }
}

Running Migrations

Um alle Ihre ausstehenden Migrationen auszuführen, führen Sie den Artisan-Befehl migrate aus:

php artisan migrate

Forcing Migrations To Run In Production

Einige Migrationsoperationen sind destruktiv, was bedeutet, dass sie zu Datenverlusten führen können. Um Sie vor der Ausführung dieser Befehle gegen Ihre Produktionsdatenbank zu schützen, werden Sie vor der Ausführung der Befehle zur Bestätigung aufgefordert. Um die Ausführung der Befehle ohne eine Eingabeaufforderung zu erzwingen, verwenden Sie das Kennzeichen --force:

php artisan migrate --force

Rolling Back Migrations

Um den letzten Migrationsvorgang rückgängig zu machen, können Sie den Rollback-Befehl verwenden. Dieser Befehl rollt den letzten "Batch" von Migrationen zurück, der mehrere Migrationsdateien enthalten kann:

php artisan migrate:rollback

Sie können eine begrenzte Anzahl von Migrationen rückgängig machen, indem Sie dem Rollback-Befehl die step-Option zur Verfügung stellen. Der folgende Befehl führt beispielsweise ein Rollback der letzten fünf Migrationen durch:

php artisan migrate:rollback --step=5

Mit dem Befehl migrate:reset werden alle Migrationen Ihrer Anwendung zurückgesetzt:

php artisan migrate:reset

Rollback & Migrate In Single Command

Der Befehl migrate:refresh rollt alle Ihre Migrationen zurück und führt dann den Befehl migrate aus. Dieser Befehl erstellt effektiv Ihre gesamte Datenbank neu:

php artisan migrate:refresh

// Refresh the database and run all database seeds...
php artisan migrate:refresh --seed

Sie können eine begrenzte Anzahl von Migrationen rückgängig machen und neu migrieren, indem Sie die step-Option für den refresh-Befehl bereitstellen. Der folgende Befehl rollt beispielsweise die letzten fünf Migrationen zurück und migriert sie erneut:

php artisan migrate:refresh --step=5

Drop All Tables & Migrate

Der Befehl migrate:refresh löscht alle Tabellen aus der Datenbank und führt dann den Befehl migrate aus:

php artisan migrate:fresh

php artisan migrate:fresh --seed

Tables

Creating Tables

Um eine neue Datenbanktabelle zu erstellen, verwenden Sie die create-Methode auf der Fassade Schema. Die create-Methode akzeptiert zwei Argumente. Das erste ist der Name der Tabelle, während das zweite ein Closure ist, das ein Blueprint-Objekt erhält, das zur Definition der neuen Tabelle verwendet werden kann:

Schema::create('users', function (Blueprint $table) {
    $table->bigIncrements('id');
});

Beim Anlegen der Tabelle können Sie jede beliebige column-Methode des Schema-Builders verwenden, um die Spalten der Tabelle zu definieren.

Checking For Table / Column Existence

 Mit den Methoden hasTable und hasColumn können Sie leicht auf die Existenz einer Tabelle oder Spalte überprüfen:

if (Schema::hasTable('users')) {
    //
}

if (Schema::hasColumn('users', 'email')) {
    //
}

Database Connection & Table Options

Wenn Sie eine Schemaoperation auf einer Datenbankverbindung durchführen möchten, die nicht Ihre Standardverbindung ist, verwenden Sie die connection-Methode:

Schema::connection('foo')->create('users', function (Blueprint $table) {
    $table->bigIncrements('id');
});

Sie können die folgenden Befehle im Schema Builder verwenden, um die Optionen der Tabelle zu definieren:

$table->engine = 'InnoDB';

$table->charset = 'utf8';

$table->collation = 'utf8_unicode_ci';

$table->temporary();

Renaming / Dropping Tables

Um eine bestehende Datenbanktabelle umzubenennen, verwenden Sie die rename-Methode:

Schema::rename($from, $to);

Um eine bestehende Tabelle zu löschen, können Sie die Methoden drop oder dropIfExists verwenden:

Schema::drop('users');

Schema::dropIfExists('users');

Renaming Tables With Foreign Keys

Bevor Sie eine Tabelle umbenennen, sollten Sie überprüfen, ob alle Fremdschlüssel-Einschränkungen auf der Tabelle einen expliziten Namen in Ihren Migrationsdateien haben, anstatt Laravel einen auf Konvention basierenden Namen zuweisen zu lassen. Andernfalls wird der Name der Fremdschlüsselbeschränkung auf den alten Tabellennamen verweisen.

Columns

Creating Columns

Mit der table-Methode auf der Fassade Schema können Sie bestehende Tabellen aktualisieren. Wie die create-Methode akzeptiert die table-Methode zwei Argumente: den Namen der Tabelle und einen Closure, der eine Blueprint-Instanz erhält, mit der Sie der Tabelle Spalten hinzufügen können:

Schema::table('users', function (Blueprint $table) {
    $table->string('email');
});

Available Column Types

Der Schema-Builder enthält eine Vielzahl von Spaltentypen, die Sie beim Aufbau Ihrer Tabellen angeben können:

$table->bigIncrements('id');

$table->bigInteger('votes');

$table->binary('data');

$table->boolean('confirmed');

$table->char('name', 100);

$table->date('created_at');

$table->dateTime('created_at');

$table->dateTimeTz('created_at');

$table->decimal('amount', 8, 2);

$table->double('amount', 8, 2);

$table->enum('level', ['easy', 'hard']);

$table->float('amount', 8, 2);

$table->geometry('positions');

$table->geometryCollection('positions');

$table->increments('id');

$table->integer('votes');

$table->ipAddress('visitor');

$table->json('options');

$table->jsonb('options');

$table->lineString('positions');

$table->longText('description');

$table->macAddress('device');

$table->mediumIncrements('id');

$table->mediumInteger('votes');

$table->mediumText('description');

$table->morphs('taggable');

taggable_id

taggable_type

$table->uuidMorphs('taggable');

taggable_id

taggable_type

$table->multiLineString('positions');

$table->multiPoint('positions');

$table->multiPolygon('positions');

$table->nullableMorphs('taggable');

morphs()

$table->nullableUuidMorphs('taggable');

uuidMorphs()

$table->nullableTimestamps();

timestamps()

$table->point('position');

$table->polygon('positions');

$table->rememberToken();

remember_token

$table->set('flavors', ['strawberry', 'vanilla']);

$table->smallIncrements('id');

$table->smallInteger('votes');

$table->softDeletes();

deleted_at

$table->softDeletesTz();

deleted_at

$table->string('name', 100);

$table->text('description');

$table->time('sunrise');

$table->timeTz('sunrise');

$table->timestamp('added_on');

$table->timestampTz('added_on');

$table->timestamps();

created_at

updated_at

$table->timestampsTz();

created_at

updated_at

$table->tinyIncrements('id');

$table->tinyInteger('votes');

$table->unsignedBigInteger('votes');

$table->unsignedDecimal('amount', 8, 2);

$table->unsignedInteger('votes');

$table->unsignedMediumInteger('votes');

$table->unsignedSmallInteger('votes');

$table->unsignedTinyInteger('votes');

$table->uuid('id');

$table->year('birth_year');

Column Modifiers

Zusätzlich zu den oben aufgeführten Spaltentypen gibt es mehrere Spalten-"Modifikatoren", die Sie beim Hinzufügen einer Spalte zu einer Datenbanktabelle verwenden können. Um die Spalte z.B. "löschbar" zu machen, können Sie die "nullable"-Methode verwenden:

Schema::table('users', function (Blueprint $table) {
    $table->string('email')->nullable();
});

Unten ist eine Liste aller verfügbaren Spaltenmodifikatoren. Diese Liste enthält nicht die Indexmodifikatoren:

->after('column')

->autoIncrement()

->charset('utf8')

->collation('utf8_unicode_ci')

->comment('my comment')

->default($value)

->first()

->nullable($value = true)

->storedAs($expression)

->unsigned()

->useCurrent()

->virtualAs($expression)

->generatedAs($expression)

->always()

Modifying Columns

Prerequisites (Voraussetzungen)

Bevor Sie eine Spalte ändern, fügen Sie die doctrine/dbal Abhängigkeit zu Ihrer composer.json Datei hinzu. Die Doctrine DBAL-Bibliothek wird verwendet, um den aktuellen Zustand der Spalte zu ermitteln und die SQL-Abfragen zu erstellen, die für die angegebenen Anpassungen der Spalte erforderlich sind:

composer require doctrine/dbal

Updating Column Attributes

Die change-Methode erlaubt es Ihnen, einige bestehende Spaltentypen auf einen neuen Typ zu ändern oder die Attribute der Spalte zu modifizieren. Beispielsweise können Sie die Größe einer String-Spalte erhöhen. Um die change-Methode in Aktion zu sehen, lassen Sie uns die Größe der Namensspalte von 25 auf 50 erhöhen:

Schema::table('users', function (Blueprint $table) {
    $table->string('name', 50)->change();
});

Wir könnten auch eine Spalte so modifizieren, dass sie löschbar ist:

Schema::table('users', function (Blueprint $table) {
    $table->string('name', 50)->nullable()->change();
});

Renaming Columns

Um eine Spalte umzubenennen, können Sie die Methode renameColumn im Schema-Builder verwenden. Bevor Sie eine Spalte umbenennen, stellen Sie sicher, dass Sie die doctrine/dbal-Abhängigkeit zu Ihrer composer.json-Datei hinzufügen:

Schema::table('users', function (Blueprint $table) {
    $table->renameColumn('from', 'to');
});

Dropping Columns

Um eine Spalte zu löschen, verwenden Sie die dropColumn-Methode im Schema-Builder. Bevor Sie Spalten aus einer SQLite-Datenbank löschen, müssen Sie die doctrine/dbal-Abhängigkeit zu Ihrer composer.json-Datei hinzufügen und den composer update Befehl in Ihrem Terminal ausführen, um die Bibliothek zu installieren:

Schema::table('users', function (Blueprint $table) {
    $table->dropColumn('votes');
});

Sie können mehrere Spalten aus einer Tabelle löschen, indem Sie ein Array mit Spaltennamen an die dropColumn-Methode übergeben:

Schema::table('users', function (Blueprint $table) {
    $table->dropColumn(['votes', 'avatar', 'location']);
});

Available Command Aliases

$table->dropMorphs('morphable');

$table->dropRememberToken();

$table->dropSoftDeletes();

$table->dropSoftDeletesTz();

$table->dropTimestamps();

$table->dropTimestampsTz();

Indexes

Creating Indexes

Der Schema-Builder unterstützt mehrere Arten von Indizes. Zuerst schauen wir uns ein Beispiel an, das angibt, dass die Werte einer Spalte eindeutig sein sollten. Um den Index zu erstellen, können wir die unique-Methode mit der Spaltendefinition verketten:

$table->string('email')->unique();

Alternativ können Sie den Index nach der Definition der Spalte erstellen. Zum Beispiel:

$table->unique('email');

Sie können sogar ein Array von Spalten an eine Indexmethode übergeben, um einen zusammengesetzten (oder zusammengesetzten) Index zu erstellen:

$table->index(['account_id', 'created_at']);

Laravel wird automatisch einen vernünftigen Indexnamen generieren, aber Sie können der Methode ein zweites Argument übergeben, um den Namen selbst zu spezifizieren:

$table->unique('email', 'unique_email');

Available Index Types

Jede Indexmethode akzeptiert ein optionales zweites Argument, um den Namen des Indexes anzugeben. Wenn es weggelassen wird, wird der Name aus den Namen der Tabelle und der Spalte(n) abgeleitet.

$table->primary('id');

$table->primary(['id', 'parent_id']);

$table->unique('email');

$table->index('state');

$table->spatialIndex('location');

Index Lengths & MySQL / MariaDB

Laravel verwendet standardmäßig den Zeichensatz utf8mb4, der auch die Speicherung von "Emojis" in der Datenbank unterstützt. Wenn Sie eine Version von MySQL älter als das 5.7.7-Release oder MariaDB älter als das 10.2.2-Release verwenden, müssen Sie möglicherweise die von Migrationen generierte Standard-Stringlänge manuell konfigurieren, damit MySQL Indizes für sie erstellt. Sie können dies konfigurieren, indem Sie die Schema::defaultStringLength-Methode innerhalb Ihres AppServiceProviders aufrufen:

use Illuminate\Support\Facades\Schema;

/**
 * Bootstrap any application services.
 *
 * @return void
 */
public function boot()
{
    Schema::defaultStringLength(191);
}

Alternativ können Sie die Option innodb_large_prefix für Ihre Datenbank aktivieren. Lesen Sie in der Dokumentation Ihrer Datenbank nach, wie Sie diese Option korrekt aktivieren können.

Renaming Indexes

Um einen Index umzubenennen, können Sie die renameIndex-Methode verwenden. Diese Methode akzeptiert den aktuellen Indexnamen als erstes Argument und den gewünschten Namen als zweites Argument:

$table->renameIndex('from', 'to')

Dropping Indexes

Um einen Index zu löschen, müssen Sie den Namen des Indexes angeben. Standardmäßig vergibt Laravel automatisch einen sinnvollen Namen für die Indizes. Sie verknüpfen den Tabellennamen, den Namen der indizierten Spalte und die Indexart. Hier sind einige Beispiele:

$table->dropPrimary('users_id_primary');

$table->dropUnique('users_email_unique');

$table->dropIndex('geo_state_index');

$table->dropSpatialIndex('geo_location_spatialindex');

Wenn Sie ein Array von Spalten an eine Methode übergeben, die Indizes fallen lässt, wird der konventionelle Indexname basierend auf dem Tabellennamen, den Spalten und dem Schlüsseltyp generiert:

Schema::table('geo', function (Blueprint $table) {
    $table->dropIndex(['state']); // Drops index 'geo_state_index'
});

Foreign Key Constraints

Laravel bietet auch Unterstützung für die Erstellung von Fremdschlüssel-Bedingungen, die verwendet werden, um die referentielle Integrität auf Datenbankebene zu erzwingen. Lassen Sie uns zum Beispiel eine user_id Spalte auf der posts Tabelle definieren, die die id Spalte auf einer user Tabelle referenziert:

Schema::table('posts', function (Blueprint $table) {
    $table->unsignedBigInteger('user_id');

    $table->foreign('user_id')->references('id')->on('users');
});

Sie können auch die gewünschte Aktion für die "on delete" und "on update" Eigenschaften des Constraints angeben:

$table->foreign('user_id')
      ->references('id')->on('users')
      ->onDelete('cascade');

Um einen Fremdschlüssel zu löschen, können Sie die dropForeign-Methode verwenden. Fremdschlüssel-Einschränkungen verwenden die gleiche Namenskonvention wie Indizes. Wir werden also den Tabellennamen und die Spalten im Constraint verknüpfen und den Namen mit "_foreign" anhängen:

$table->dropForeign('posts_user_id_foreign');

Oder Sie können einen Array-Wert übergeben, der beim Fallenlassen automatisch den konventionellen Constraint-Namen verwendet:

$table->dropForeign(['user_id']);

Sie können Fremdschlüsseleinschränkungen innerhalb Ihrer Migrationen mit den folgenden Methoden aktivieren oder deaktivieren:

Schema::enableForeignKeyConstraints();

Schema::disableForeignKeyConstraints();