Esecuzione di uno specifico Laravel migrazione (singolo file)

Non voglio eseguire Tutte le operazioni di Migrazioni di laravel 4. Ho 5 migrazioni. Adesso ho solo voglia di esecuzione di una migrazione.
invece di fare : php artigianale migrazione
Vorrei eseguire una migrazione specifici come : php artigianale migrazione MY_MIGRATION_TO_RUN

  • Anche io ho lo stesso caso d’uso. Ci dovrebbe essere un’opzione. Ho bisogno di eseguire una migrazione, un grande etl script, quindi eseguire la seconda metà della migrazione. Non ha senso che il secondo file non dovrebbe essere nel mio codice di base, fino a quando il etl script viene eseguito.
  • php artisan migrate --path="app/database/migrations/my_single_migration"
InformationsquelleAutor Mamadou | 2013-09-30

 

17 Replies
  1. 49

    Sembra che si sta facendo male.

    Migrazioni sono state fatte per essere eseguito da Laravel uno per uno, nell’esatto ordine in cui sono stati creati, in modo da poter tenere traccia di esecuzione e ordine di esecuzione. Che modo Laravel sarà possibile eseguire il rollback di un lotto di migrazioni, senza rischiare di rompere il vostro database.

    Dando la possibilità all’utente di eseguire manualmente l’impossibilità di sapere con certezza come il rollback delle modifiche nel database.

    Se il tuo davvero bisogno di eseguire qualcosa nel database, è meglio creare uno script DDL e eseguire manualmente sul tuo webserver.

    O semplicemente creare una nuova migrazione ed eseguito tramite artigianale.

    EDIT:

    Se è necessario eseguire per primo, è necessario creare prima.

    Se avete solo bisogno di riordinarle, rinominare il file per essere il primo. Le migrazioni sono creato con un timestemp:

    2013_01_20_221554_table

    Per creare una nuova migrazione prima di questo può essere un nome

    2013_01_19_221554_myFirstMigration
    • Sì, è così chiaro whta dici, ma alla fine del tuo commento vedo : “O creare una nuova migrazione ed eseguito tramite artigianale.” Ho creato una nuova migrazione e vorrei eseguirlo. Se faccio : artigiano migrazione, questo comando verrà eseguito tutta la mia migrazione non quello nuovo che ho creato.
    • Se è necessario eseguire PRIMA, è necessario creare prima. Le migrazioni sono creato con un timestemp sul nome (2013_01_20_221554_table), basta rinominare tuo per essere il primo.
    • A cura di risposta migliore.
    • Non sto cercando di riordinare i miei migrazioni. Creare cinque migrazioni all’inizio del progetto. Settimane dopo, avevo bisogno di una nuova tabella, in modo da creare una nuova migrazione. Voglio correre questo per aggiungere la nuova tabella e la sua struttura. Non capisco perché dovrei ri-eseguire migrazioni ho già excecuted e non juste uno nuovo che ho creato ?
    • Come ho detto, Laravel tiene traccia delle migrazioni, se è reruning qualsiasi di loro è perché un rollback (o reset) è stato eseguito su di esso, o qualcosa di brutto è accaduto con le migrazioni tabella.
    • AH ! Grande ! Questa osservazione .se è reruning qualsiasi di loro è perché un rollback (o reset)
    • Grazie Antonio. Ho intenzione di fare il backup dei miei bdd ( invece, lol) e di farlo.
    • Bello! Godere Di Laravel!
    • Se si esegue la migrazione di database, quindi aggiungere nuove migrazioni, è sufficiente eseguire l’artigiano migrare di nuovo il comando. Migrazione in tutte le camere per non migrazione migrazioni sinistra nell’ordine in cui sono stati creati.
    • come si fa a laravel tenere traccia delle migrazioni che già sono stati eseguiti? non conservare in un migrazioni tabella nel db?
    • Sì, esattamente, c’è un migrations file per questo scopo.
    • Comunque, penso che eseguire migrazioni specifiche forse utile, soprattutto se la migrazione include diverse relative tabelle (le chiavi esterne e tabelle pivot), in tal caso è necessario eliminare le tabelle in ordine corretto. Ho creato la base migrazioni come catalog_layer, office_layer, ecc, che comprende tutte le tabelle necessarie per la sola parte delle funzionalità dell’applicazione e in seguito aggiungere le migrazioni che migliorare alcune tabelle/strati se necessario. Forse questo è un approccio sbagliato, ma tutti i layer roba per alcune funzionalità in un unico file e di avere adeguata goccia ordine, utile quando si modifica e seme di nuovo e di nuovo (test/miglioramenti/modifiche).
    • Sono d’accordo – quando si sviluppa voglio che il mio migrazioni di essere solo di destra. Così, quando ho eseguito in produzione funzionano perfettamente. A volte (in sviluppo) mi rotolo per tornare all’inizio, modifica, di una migrazione e andare di nuovo. Ma quando si esegue la migrazione, si esegue la migrazione di tutti – io preferirei l’opzione per l’esecuzione ancora una volta, ancora in sequenza e la migrazione, uno alla volta, in modo che io possa rollback, uno alla volta, anche.
    • -1 a causa di “Guarda come si sta facendo male”. IMHO il Laravel è sbagliato. Sviluppo <> Produzione. I due ambienti che richiedono diverse tipologie di garanzie e misure di sicurezza ed è del tutto legittima se si seguono diverse discipline. Lo sviluppo richiede flessibilità di sopra di tutti, solo che potrebbe accadere che uno sviluppatore ha bisogno di modificare il meccanismo di migrazione per le sue esigenze. Io sono me manca questa flessibilità caro e resort a dirigere la manipolazione di database per ottenere ciò che voglio, che non accadrebbe MAI in produzione, ma abbastanza spesso in via di sviluppo.
    • Io non sono d’accordo con voi, perché Laravel non sta facendo nulla di male. La regola è “Mai modificare le migrazioni che sono stati eseguiti in produzione”. Ma è possibile modificare locale migrazioni in qualsiasi modo si vede in forma.
    • Forse mi manca qualcosa qui, ma un caso in cui l’esecuzione di un singolo, la migrazione può essere molto utile in fase di test. Se si desidera eseguire alcuni test dopo una grande migrazione, quindi è probabile che prima bisogno di alcune tabelle e roba del test di db in modo che si può popolano. Poi si desidera eseguire il vostro grande migrazione e assicurarsi che tutto sembra ok nei test. Per quanto posso dire questo richiede un po ‘ di hacky approccio in Laravel come movimento migrazioni in e fuori della migrazione dir o utilizzando il pignolo --path opzione.

  2. 38

    Basta spostare il già eseguire migrazioni al di fuori della app/config/database/migrazioni/cartella . Quindi eseguire il comando php artisan migrate . Funzionato come un fascino per me .

    • provato e questo è un bene, ma non se io incontro un problema quando ho rollback se
    • sì @Diamante, come per il plugin in base modulo quando è necessario disinstallare allora potrebbe essere un grosso problema per il rollback..
  3. 25

    Si può mettere le migrazioni in più cartelle e di eseguire qualcosa di simile:

    php artisan migrate --path=/app/database/migrations/my_migrations
  4. 22

    Un bel po ‘ di snippet per alleviare le paure quando si esegue Laravel 4 migrazioni php artisan migrate --pretend . Questo sarà solo l’uscita SQL che sarebbero state eseguite se si esegue la migrazione vera e propria.

    Sembra che la tua iniziale di 4 migrazioni sono già stati eseguiti. Credo che quando si php artisan migrate verrà eseguito solo il nuovo, recente migrazione.

    Parola di consulenza: si assicura che tutto il tuo up() e giù() funziona come previsto. Mi piace correre(), giù(), up() quando ho eseguito il mio migrazioni, solo per test. Sarebbe terribile per voi per ottenere 5-6 migrazioni e rendersi conto che non può rotolare indietro senza problemi, perché non è andata giù() con() il 100%.

    Solo i miei due centesimi!!! Spero che il --pretend aiuta.

    • grande! prevede che la pace della mente
    • grazie per il racconto finta
  5. 15

    L’unico modo per ri-eseguire un migrattion è una sporca. È necessario aprire il database ed eliminare la riga nel migrazioni tabella che rappresenta la migrazione.

    Quindi eseguire php artigianale emigrare di nuovo.

    • Inoltre è possibile impostare il “batch” campo – laravel corre (e rollback) le migrazioni una partita alla volta, quindi si può solo cambiare il numero di batch per consentire il rollback di una sola migrazione.
    • non possiamo fare questo per le migrazioni tabella This table does not contain a unique column. Grid edit, checkbox, Edit, Copy and Delete features are not available.
    • Bene, direi che può dipende dal motore del database in uso. Nel mio caso ha funzionato bene in quel modo. Come è possibile eseguire comandi SQL manualmente si può fare una select, delete.
    • Nella maggior parte dei casi, sì. Ma dipende dalla complessità del fenomeno che si vuole ri-fare. Se è l’aggiunta di una tabella e di nessun altro migrazioni contare su di alterare stessa tabella, sì, basta eliminare la tabella manualmente, eliminare la riga della migrazioni tabella corrispondente alla migrazione che si desidera eseguire. Questo è come io uso la funzione di migrazione, mentre la progettazione del tavolo. Dal momento che è l’ultimo/più recente/più recente migrazione, è in un batter d’occhio a farlo in questo modo e funziona perfettamente.
  6. 4

    È possibile creare una directory separata per le migrazioni dal vostro terminale come segue:

    mkdir /database/migrations/my_migrations

    E quindi spostare la migrazione specifica che si desidera eseguire directory e lancia questo comando:

    php artisan migrate --path=/database/migrations/my_migrations

    Spero che questo aiuta!

  7. 3

    Ho dato questa risposta in un altro post, ma questo è possibile: eseguire artisan migrate per l’esecuzione di tutte le migrazioni, quindi i seguenti comandi SQL per aggiornare le migrazioni tabella, facendo sembrare le migrazioni sono stati eseguiti uno alla volta:

    SET @a = 0;  
    UPDATE migrations SET batch = @a:=@a+1;

    Che cambierà il batch colonna 1, 2, 3, 4, ecc .. Aggiungi un WHERE batch>=... condizione e, di aggiornare il valore iniziale di @a), se si desidera solo per colpire alcuni migrazioni.

    Dopo questo, è possibile artisan migrate:rollback quanto è necessario, e il passaggio attraverso le migrazioni, uno alla volta.

  8. 2

    C’è un modo facile io so fare solo questo può essere solo host locale

    1. Modificare il file di migrazione come necessario
    2. aprire phpMyAdmin o qualsiasi altra cosa si usa per vedere la tabella di database
    3. trovare la tabella desiderata e rilasciare
    4. trovare le migrazioni tavolo e aprire
    5. in questa tabella sotto migrazione campo selezionare il nome della tabella e cancellare la riga
    6. infine, eseguire il comando php artisan migrate da riga di comando o terminale. questo consente di migrare solo che le tabelle che non esiste nel migrazioni tabella nel database.

    In questo modo è completamente sicuro e non fare errori o problemi, mentre sembra che l’onu-professionale, ma funziona ancora perfettamente.

    buona fortuna

  9. 1

    Se è solo per scopi di test, questo è come lo faccio:

    Per il mio caso, ho diverse migrazioni, uno di essi contiene una App Impostazioni.

    Mentre io sto testando l’App e non tutte le migrazioni sono già installazione ho semplicemente spostarli in una nuova cartella “futuro”. Questo folders non essere toccati da un artigiano e sarà solo eseguire la migrazione si desidera.

    Sporca soluzione, ma funziona…

  10. 1

    Se si desidera eseguire il tuo ultimo file di migrazione, occorre procedere nel seguente modo:

    php artisan migrate

    Si può anche tornare indietro a prima dell’aggiunta della migrazione con:

    php artisan migrate: rollback
  11. 1

    Ho lo stesso problema.
    Copia di creazione della tabella codici in prima file di migrazione qualcosa come di seguito:

      public function up()
        {
            Schema::create('posts', function(Blueprint $table){
                $table->increments('id');
                //Other columns...
                $table->timestamps();
            });
            Schema::create('users', function (Blueprint $table) {
                $table->increments('id');
                //Other columns...
                $table->softDeletes()->nullable();
            });
        }

    Inoltre, è possibile modificare(decremento) batch numero di colonna migrations tabella 😉

    E quindi eseguire php artisan migrate.

  12. 1

    Lanciare un’eccezione in una migrazione, se non si vuole applicare, e sarebbe fermare l’intero processo di migrazione.

    Utilizzando questo approccio è possibile dividere il vostro mazzo di migrazioni in passaggi.

  13. 0

    così semplice…! basta andare alla migrazione cartella. spostare tutti i file di migrazione in un’altra cartella. per poi tornare tutti migrazione a uno a uno in migrazione cartella ed eseguire la migrazione di uno di loro(php artigianale). quando si inserisce bad file di migrazione nella migrazione master cartella ed eseguire php artigianale migrare nel prompt dei comandi verrà errore.

  14. 0

    Ho usato il ritorno della linea 1, in modo che il precedente dbs sono mantenuti come è.

    <?php
    
    use Illuminate\Support\Facades\Schema;
    use Illuminate\Database\Schema\Blueprint;
    use Illuminate\Database\Migrations\Migration;
    
    class CreateUsersTable extends Migration
    {
        /**
         * Run the migrations.
         *
         * @return void
         */
        public function up()
        {
            return;  //This Line
            Schema::create('users', function (Blueprint $table) {
                $table->increments('id');
                $table->string('name', 50);
                $table->string('slug', 50)->unique();
                $table->integer('role_id')->default(1);
                $table->string('email', 50)->unique();
                $table->timestamp('email_verified_at')->nullable();
                $table->string('mobile', 10)->unique();
                $table->timestamp('mobile_verified_at')->nullable();
                $table->text('password');
                $table->integer('can_login')->default(1);
                $table->rememberToken();
                $table->timestamps();
            });
        }
    
        /**
         * Reverse the migrations.
         *
         * @return void
         */
        public function down()
        {
            return;//This Line
            Schema::dropIfExists('users');
        }
    }
  15. 0

    Questo è un cattivo approccio che uso io.. io eliminare altri file di migrazione, tranne il file specifico voglio migrare quindi eseguire PHP artigianale migrazione dopo la migrazione è stata completata io goto mio cestino e ripristinare i file eliminati

  16. 0

    Per qualcuno ancora interessato a questo, Laravel 5 aggiornamento: Laravel ha implementato l’opzione di eseguire la migrazione di un file alla volta (in versione 5.7).

    È ora possibile eseguire questo:
    php artisan migrate --path=/database/migrations/my_migration.php (come risposta qui)

    Perché il Illuminate\Database\Migrations\Migrator::getMigrationFiles() ora contiene questo codice:
    return Str::endsWith($path, '.php') ? [$path] : $this->files->glob($path.'/*_*.php');
    (vedere il codice sorgente.)


    Ma nel mio caso d’uso, in realtà io volevo di eseguire una serie di migrazioni, allo stesso tempo, non solo uno, o tutti.

    Così sono andato l’Laravel modo e registrato una diversa implementazione del Migrator, che decide quali sono i file da utilizzare:

    /**
     * A migrator that can run multiple specifically chosen migrations.
     */
    class MigrationsSetEnabledMigrator extends Migrator
    {
        /**
         * @param Migrator $migrator
         */
        public function __construct(Migrator $migrator)
        {
            parent::__construct($migrator->repository, $migrator->resolver, $migrator->files);
    
            //Compatibility with versions >= 5.8
            if (isset($migrator->events)) {
                $this->events = $migrator->events;
            }
        }
    
        /**
         * Get all of the migration files in a given path.
         *
         * @param  string|array $paths
         * @return array
         */
        public function getMigrationFiles($paths)
        {
            return Collection::make($paths)->flatMap(function ($path) {
                return Str::endsWith($path, ']') ? $this->parseArrayOfPaths($path) :
                    (Str::endsWith($path, '.php') ? [$path] : $this->files->glob($path . '/*_*.php'));
            })->filter()->sortBy(function ($file) {
                return $this->getMigrationName($file);
            })->values()->keyBy(function ($file) {
                return $this->getMigrationName($file);
            })->all();
        }
    
        public function parseArrayOfPaths($path)
        {
            $prefix = explode('[', $path)[0];
            $filePaths = explode('[', $path)[1];
            $filePaths = rtrim($filePaths, ']');
    
            return Collection::make(explode(',', $filePaths))->map(function ($filePath) use ($prefix) {
                return $prefix . $filePath;
            })->all();
        }
    }

    Dobbiamo registrare che nel contenitore, come 'migrator' (per essere accessibile come $app['migrator']), perché è così che la Migrazione di comando accede quando viene registrato in IoC. Per farlo, abbiamo messo questo codice in un service provider (nel mio caso, si tratta di un DatabaseServiceProvider):

        public function register()
        {
            $this->app->extend('migrator', function ($migrator, $app) {
                return new MultipleSpecificMigrationsEnabledMigrator($migrator);
            });
    
            //We reset the command.migrate bind, which uses the migrator - to 
            //force refresh of the migrator instance.
            $this->app->instance('command.migrate', null);
        }

    Quindi è possibile eseguire questo:

    php artisan migrate --path=[database/migrations/my_migration.php,database/migrations/another_migration.php]

    Notare i molteplici file di migrazione, separati da una virgola.

    È testato e funzionante in Laravel 5.4 e dovrebbe essere Laravel 5.8 compatibile.

    Perché?

    Per chiunque sia interessato: il caso d’uso è l’aggiornamento della versione del database con i dati.

    Immaginare, per esempio, che si voleva unire la via e il numero civico di tutti gli utenti in una nuova colonna, chiamiamolo street_and_house. E immaginate di voler fare sul installazioni multiple in un ambiente sicuro e testato modo – si sarebbe probabilmente creare uno script per che (nel mio caso, ho creato il controllo delle versioni dei dati comandi – artigianale comandi).

    Per effettuare questa operazione, è necessario prima di caricare gli utenti in memoria, quindi eseguire la migrazione e rimuovere le vecchie colonne e aggiungere uno nuovo; e poi, per ogni utente di assegnare il street_and_house=$street . " " . $house_no e salvare gli utenti. (Sto semplificando qui, ma si può sicuramente immaginare altri scenari)

    E non ho voglia di contare sul fatto che sono in grado di eseguire tutte le migrazioni in qualsiasi momento. Immaginate che si voleva aggiornare da diciamo 1.0.0 per 1.2.0 e c’erano più lotti di tali aggiornamenti – l’esecuzione di ogni più migrazioni potrebbe rompere i tuoi dati, perché le migrazioni devono essere gestiti da loro dedicati comando di aggiornamento. Quindi, voglio solo correre selezionato noto migrazioni che questo aggiornamento si sa come lavorare, quindi eseguire operazioni sui dati, e poi, eventualmente, eseguire il successivo aggiornamento dei dati di comando. (Voglio essere come difensiva possibile).

    Per raggiungere questo obiettivo, ho bisogno che il suddetto meccanismo di definire un insieme fisso di migrazioni da eseguire per un comando per lavoro.

    Nota: avrei preferito utilizzare un semplice decoratore utilizzando la magia __call metodo e di evitare la successione (un meccanismo simile che Laravel utilizza il \Illuminate\Database\Eloquent\Builder per avvolgere il \Illuminate\Database\Query\Builder), ma il MigrateCommand, purtroppo, richiede un’istanza di Migrator nel costruttore.


    Nota finale: ho voluto pubblicare questa risposta alla domanda Come posso eseguire la migrazione specifica in laravel , in quanto è Laravel 5 – specifici. Ma io non posso – dal momento che la domanda è contrassegnato come un duplicato di questo (anche se questo è etichettato come Laravel 4).

  17. 0

    Si può utilizzare sotto la soluzione:

    1. creare la migrazione.
    2. controllare il tuo status di immigrazione, come: php artisan migrate:status.
    3. copiare il nome completo della nuova migrazione e farlo come: php artisan migrate:rollback --path:2018_07_13_070910_table_tests.
    4. e poi fare questo php artisan migrate.

    infine, la migrazione specifica tabella.
    Goodluck.

Lascia un commento