/** * Execute the console command. * * @return void */ public function fire() { $this->migrator->setConnection($this->input->getOption('database')); $pretend = $this->input->getOption('pretend'); while ($this->migrator->rollback($this->output, $pretend)) { } }
/** * Prepare the migration database for running. * * @return void */ protected function prepareDatabase() { $this->migrator->setConnection($this->input->getOption('database')); if (!$this->migrator->repositoryExists()) { $options = ['--database' => $this->input->getOption('database')]; $this->call('migrate:install', $options); } }
/** * Execute the console command. * * @return void */ public function fire() { $this->migrator->setConnection($this->input->getOption('database')); $package = $this->input->getOption('package') ?: 'application'; // The pretend option can be used for "simulating" the migration and grabbing // the SQL queries that would fire if the migration were to be run against // a database for real, which is helpful for double checking migrations. $pretend = $this->input->getOption('pretend'); $path = $this->getMigrationPath(); $this->migrator->run($this->output, $package, $path, $pretend); }
protected function execute(InputInterface $input, OutputInterface $output) { $capsule = app('capsule'); $connectionResolver = $capsule->getDatabaseManager(); $repository = new DatabaseMigrationRepository($connectionResolver, 'migrations'); if (!$repository->repositoryExists()) { $repository->createRepository(); } $migrator = new Migrator($repository, $connectionResolver, new Filesystem()); return $migrator->run(__DIR__ . '/../database/migrations'); }
/** * Execute the console command. * * @return void */ public function fire() { $this->migrator->setConnection($this->input->getOption('database')); $pretend = $this->input->getOption('pretend'); $this->migrator->rollback($pretend); // Once the migrator has run we will grab the note output and send it out to // the console screen, since the migrator itself functions without having // any instances of the OutputInterface contract passed into the class. foreach ($this->migrator->getNotes() as $note) { $this->output->writeln($note); } }
/** * Execute the console command. * * @return mixed */ public function fire() { if (!$this->confirmToProceed()) { return; } $this->migrator->setConnection($this->option('database')); $paths = $this->getMigrationPaths(); $this->migrator->rollback($paths, ['pretend' => $this->option('pretend'), 'step' => (int) $this->option('step')]); foreach ($this->migrator->getNotes() as $note) { $this->output->writeln($note); } }
/** * Execute the console command. * * @return void */ public function fire() { if (!$this->confirmToProceed()) { return; } $this->migrator->setConnection($this->option('database')); $this->migrator->rollback($this->getMigrationPaths(), ['pretend' => $this->option('pretend'), 'step' => (int) $this->option('step')]); // Once the migrator has run we will grab the note output and send it out to // the console screen, since the migrator itself functions without having // any instances of the OutputInterface contract passed into the class. foreach ($this->migrator->getNotes() as $note) { $this->output->writeln($note); } }
public function resolve($file) { /* @var $class \Consolet\Migrator\Migration */ $class = parent::resolve($file); $class::setSchemaOnce($this->resolveConnection(null)->getSchemaBuilder()); return $class; }
/** * Returns a new TenantMigrator instance. * * @param MigrationRepositoryInterface $repository * @param Resolver $resolver * @param Filesystem $files * @param TenantManager $manager */ public function __construct(MigrationRepositoryInterface $repository, Resolver $resolver, Filesystem $files, TenantManager $manager) { $this->manager = $manager; // There is nothing special about the TenantMigrationResolver class, so let's just new up one. $this->tenantMigrationResolver = new TenantMigrationResolver(); parent::__construct($repository, $resolver, $files); }
/** * Run "down" a migration instance. (Overridden) * * @param object $migration * @param bool $pretend * @return void */ protected function runDown($migration, $pretend) { $migrations = [$migration->migration]; // Retrieve migration path and throw exception if it doesn't exist $path = $this->getMigrationPath(true); $this->requireFiles($path, $migrations); parent::runDown($migration, $pretend); }
/** * Prepare the migration database for running. */ private function prepareDatabase() { if ($database = $this->getStringOption('database')) { $this->migrator->setConnection($database); } if (!$this->migrator->repositoryExists()) { $this->call('migrate:install', ['--database' => $database]); } }
/** * Run the migration reset for the specified module. * * @param string $slug * @return mixed */ protected function reset($slug) { $this->migrator->setconnection($this->input->getOption('database')); $pretend = $this->input->getOption('pretend'); $migrationPath = $this->getMigrationPath($slug); $migrations = $this->migrator->getMigrationFiles($migrationPath); if (count($migrations) == 0) { return $this->error('Nothing to rollback.'); } // We need to reverse these migrations so that they are "downed" in reverse // to what they run on "up". It lets us backtrack through the migrations // and properly reverse the entire database schema operation that originally // ran. foreach ($migrations as $migration) { $this->info('Migration: ' . $migration); $this->runDown($slug, $migration, $pretend); } }
public function run($path, $pretend = false) { parent::run($path, $pretend); $key = Config::get('database.default'); $database = Config::get('database.connections.' . $key . '.database'); $this->note('<info>Generating schema for: ' . $database . '</info>'); $builder = new Builder(); $builder->convert($database); $builder->write(); }
public static function setUpBeforeClass() { parent::setUpBeforeClass(); $config = (require __DIR__ . '/../config.php'); $capsule = new Manager(); $capsule->addConnection($config); $capsule->bootEloquent(); Schema::setConnection($capsule->getConnection('default')); DB::setConnection($capsule->getConnection('default')); // run the migrations $migration_repo = new DatabaseMigrationRepository(Model::getConnectionResolver(), 'migrations'); if (!$migration_repo->repositoryExists()) { $migration_repo->createRepository(); } $migrator = new Migrator($migration_repo, Model::getConnectionResolver(), new Filesystem()); $migrator->rollback(); $migrator->run(__DIR__ . '/../../src/migrations'); static::loadFixtures(); }
/** * Execute the console command. * * @return void */ public function fire() { if (!$this->confirmToProceed()) { return; } $this->migrator->setConnection($this->input->getOption('database')); if (!$this->migrator->repositoryExists()) { $this->output->writeln('<comment>Migration table not found.</comment>'); return; } $pretend = $this->input->getOption('pretend'); $this->migrator->reset($pretend); // Once the migrator has run we will grab the note output and send it out to // the console screen, since the migrator itself functions without having // any instances of the OutputInterface contract passed into the class. foreach ($this->migrator->getNotes() as $note) { $this->output->writeln($note); } }
/** * Execute the console command. * * @return void */ public function fire() { if (!$this->confirmToProceed()) { return; } $this->migrator->setConnection($this->option('database')); // First, we'll make sure that the migration table actually exists before we // start trying to rollback and re-run all of the migrations. If it's not // present we will just bail out with a info message for the developer. if (!$this->migrator->repositoryExists()) { return $this->comment('Migration table not found.'); } $this->migrator->reset($this->getMigrationPaths(), $this->option('pretend')); // Once the migrator has run we will grab the note output and send it out to // the console screen, since the migrator itself functions without having // any instances of the OutputInterface contract passed into the class. foreach ($this->migrator->getNotes() as $note) { $this->output->writeln($note); } }
/** * @return $this */ public function rollbackModules() { while (true) { $count = $this->migrator->rollback(); foreach ($this->migrator->getNotes() as $note) { $this->output($note); } if ($count == 0) { break; } } return $this; }
public function execute(InputInterface $input, OutputInterface $output) { $migrationsPath = APP_ROOT . 'db/migrations/'; $c = $this->app->container(); $migrationsTableName = 'migrations'; $dbResolver = $c['database.manager']->getDatabaseManager(); $filesystem = new Filesystem(); // Get the database migrations repository (create if not existant) $repository = new MigrationRepo($dbResolver, $migrationsTableName); if (!$repository->repositoryExists()) { $repository->createRepository(); } // Run! $migrator = new Migrator($repository, $dbResolver, $filesystem); $migrator->run($migrationsPath); // Show notes foreach ($migrator->getNotes() as $note) { $output->writeln(preg_replace('(<[a-zA-Z/]+>)', '', $note)); } $output->writeln(''); $output->writeln('Migrated!'); }
/** * Execute the console command. * * @return void */ public function fire() { if ($this->manager->getMigrationBehavior() == 'only') { foreach ($this->manager->getTenantMigrations() as $migrationName) { $this->info($migrationName); } } else { // This bit of code will get all of the migrations from the file system and load them into // an array. After the migration files are in the array, we will get the actual class name // from the migration file. $path = $this->getMigrationPath(); $files = $this->migrator->getMigrationFiles($path); $migrations = array(); foreach ($files as $file) { $migrations[] = $this->tenantMigrationResolver->resolveMigrationName($file); } $migrations = array_diff($migrations, $this->manager->getTenantMigrations()); foreach ($migrations as $migrationName) { $this->info($migrationName); } } }
/** * Run the migration reset for the specified module. * * Migrations should be reset in the reverse order that they were * migrated up as. This ensures the database is properly reversed * without conflict. * * @param string $slug * @return mixed */ protected function reset($slug) { $this->migrator->setconnection($this->input->getOption('database')); $pretend = $this->input->getOption('pretend'); $migrationPath = $this->getMigrationPath($slug); $migrations = array_reverse($this->migrator->getMigrationFiles($migrationPath)); if (count($migrations) == 0) { return $this->error('Nothing to rollback.'); } foreach ($migrations as $migration) { $this->info('Migration: ' . $migration); $this->runDown($slug, $migration, $pretend); } }
/** * Get all of the migration paths. * * @return array */ protected function getMigrationPaths() { // Here, we will check to see if a path option has been defined. If it has // we will use the path relative to the root of this installation folder // so that migrations may be run for any path within the applications. if ($this->input->hasOption('path') && $this->option('path')) { return [$this->laravel->basePath() . '/' . $this->option('path')]; } $modules = config('module'); foreach ($modules as $modulePath) { $migrationFilePath = $modulePath . DIRECTORY_SEPARATOR . 'database' . DIRECTORY_SEPARATOR . 'migrations'; $this->migrator->path($migrationFilePath); } return $this->migrator->paths(); }
/** * Run the migration reset for the specified module. * * Migrations should be reset in the reverse order that they were * migrated up as. This ensures the database is properly reversed * without conflict. * * @param string $slug */ protected function reset($slug) { if ($this->getStringOption('database')) { $this->migrator->setconnection($this->getStringOption('database')); } $pretend = $this->getBooleanOption('pretend'); $migrationPath = $this->getMigrationPath($slug); $migrations = array_reverse($this->migrator->getMigrationFiles($migrationPath)); if (count($migrations)) { foreach ($migrations as $migration) { $this->info('Migration: ' . $migration); $this->runDown($slug, $migration, $pretend); } } else { $this->error('Nothing to rollback.'); } }
/** * Create a new migrator instance. * * @param \Jlapp\SmartSeeder\SmartSeederRepository $repository * @param \Illuminate\Database\ConnectionResolverInterface $resolver * @param \Illuminate\Filesystem\Filesystem $files */ public function __construct(SmartSeederRepository $repository, Resolver $resolver, Filesystem $files) { parent::__construct($repository, $resolver, $files); }
/** * Merge migrator operation notes. * * @param \Illuminate\Database\Migrations\Migrator $migrator * * @return void */ protected function mergeMigratorNotes(BaseMigrator $migrator) { $this->notes = array_merge($this->notes, $migrator->getNotes()); }
/** * Get all of the migration files. * * @return array */ protected function getAllMigrationFiles() { return $this->migrator->getMigrationFiles($this->getMigrationPath()); }
/** * Construct an instance of a NamespacedMigrator. * * @param MigrationRepositoryInterface $repository * @param Resolver $resolver * @param Filesystem $files * @param string $namespace */ public function __construct(MigrationRepositoryInterface $repository, Resolver $resolver, Filesystem $files, $namespace = '') { parent::__construct($repository, $resolver, $files); $this->namespace = $namespace; }
/** * Migrator constructor. * * @param \Illuminate\Container\Container $container * @param \Illuminate\Database\Migrations\MigrationRepositoryInterface $repository * @param \Illuminate\Database\ConnectionResolverInterface $resolver * @param \Illuminate\Filesystem\Filesystem $files */ public function __construct(Container $container, MigrationRepositoryInterface $repository, Resolver $resolver, Filesystem $files) { $this->container = $container; parent::__construct($repository, $resolver, $files); }
/** * Get all of the migration files. * * @return array */ protected function getAllMigrationFiles() { return $this->migrator->getMigrationFiles($this->laravel['path.database'] . '/migrations'); }
/** * Get all of the migration files. * * @param string $path * @return array */ protected function getAllMigrationFiles($path) { return $this->migrator->getMigrationFiles($path); }
/** * Resolve a migration instance from a file. * * @param string $file * * @return Migration */ public function resolve($file) { $this->requireOnce($file); if (!str_is('*.*.*', $file)) { return parent::resolve($file); } return app($this->dispatch(new TransformMigrationNameToClass($this->removeDatePrefix($file)))); }