Return name of the table where we store info about executed migrations.

@return string
325887
public function getTableName()
    {
        if ($this->table_exists === null && !in_array($this->table_name, $this->connection->getTableNames())) {
            $this->connection->execute('CREATE TABLE ' . $this->connection->escapeTableName($this->table_name) . ' (
                `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
                `migration` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
                `executed_at` datetime NOT NULL,
                PRIMARY KEY (`id`),
                UNIQUE KEY `migration` (`migration`),
                KEY `executed_on` (`executed_at`)
            ) ENGINE=InnoDB CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;');

            $this->table_exists = true;
        }

        return $this->table_name;
    }
479170
protected function getDbScheme()
    {
        return array(
            'backup' => array(
                'fields' => array(
                    'backup_id' => array('type' => 'int', 'length' => 10, 'auto_increment' => true, 'primary' => true),
                    'created' => array('type' => 'int', 'length' => 10, 'not_null' => true),
                    'name' => array('type' => 'varchar', 'length' => 255, 'not_null' => true),
                    'path' => array('type' => 'varchar', 'length' => 255, 'not_null' => true),
                    'user_id' => array('type' => 'int', 'length' => 10, 'not_null' => true, 'default' => 0),
                    'type' => array('type' => 'varchar', 'length' => 50, 'not_null' => true, 'default' => ''),
                    'version' => array('type' => 'varchar', 'length' => 50, 'not_null' => true, 'default' => ''),
                    'id' => array('type' => 'varchar', 'length' => 50, 'not_null' => true, 'default' => '')
                )
            )
        );
    }
133293
public function getLast() {
		$list = array_reverse($this->getList());
		foreach($list as $migration=>$params) {
			if(isset($params['migrated']))
				return $migration;
		}
	}
156138
public function getMigrationStatus()
    {
        $configuration = $this->getMigrationConfiguration();

        $executedMigrations = $configuration->getMigratedVersions();
        $availableMigrations = $configuration->getAvailableVersions();
        $executedUnavailableMigrations = array_diff($executedMigrations, $availableMigrations);

        $numExecutedUnavailableMigrations = count($executedUnavailableMigrations);
        $numNewMigrations = count(array_diff($availableMigrations, $executedMigrations));

        return [
            'Name' => $configuration->getName() ? $configuration->getName() : 'Doctrine Database Migrations',
            'Database Driver' => $configuration->getConnection()->getDriver()->getName(),
            'Database Name' => $configuration->getConnection()->getDatabase(),
            'Configuration Source' => 'manually configured',
            'Version Table Name' => $configuration->getMigrationsTableName(),
            'Version Column Name' => $configuration->getMigrationsColumnName(),
            'Migrations Namespace' => $configuration->getMigrationsNamespace(),
            'Migrations Target Directory' => $configuration->getMigrationsDirectory(),
            'Previous Version' => $this->getFormattedVersionAlias('prev', $configuration),
            'Current Version' => $this->getFormattedVersionAlias('current', $configuration),
            'Next Version' => $this->getFormattedVersionAlias('next', $configuration),
            'Latest Version' => $this->getFormattedVersionAlias('latest', $configuration),
            'Executed Migrations' => count($executedMigrations),
            'Executed Unavailable Migrations' => $numExecutedUnavailableMigrations,
            'Available Migrations' => count($availableMigrations),
            'New Migrations' => $numNewMigrations,
        ];
    }
255703
public function table()
    {
        return $this->database ? $this->laravel['db']->connection($this->database)->table(config('database.migrations')) : $this->laravel['db']->table(config('database.migrations'));
    }
1310646
public function getTable(): string
	{
		if(empty($this->tableName))
		{
			$this->tableName = Str::pluralize(Str::camel2underscored($this->getClassShortName()));
		}

		return $this->tableName;
	}
855634
protected function getTableName(): string
    {
        $prefix = 'cf_';
        $configuration = GeneralUtility::makeInstance(ConfigurationService::class);
        if ($configuration->isBool('renameTablesToOtherPrefix')) {
            $prefix = 'sfc_';
        }

        return $prefix . 'staticfilecache';
    }
841432
public function getTableName()
    {
        if ($this->_tableName === null) {
            $this->_tableName = $this->model->tableName();
        }
        
        return $this->_tableName;
    }
916285
public function listTableNames()
    {
        $sql = $this->_platform->getListTablesSQL();

        $tables     = $this->_conn->fetchAll($sql);
        $tableNames = $this->_getPortableTablesList($tables);

        return $this->filterAssetNames($tableNames);
    }
230019
public function getSequenceName()
    {
        $schemaManager = $this->getConnection()->getSchemaManager();

        try {
            $schemaManager->listSequences();

            return implode('_', [
                $this->tableName(),
                $this->getPrimaryKeyName(),
                'seq',
            ]);
        } catch (DBALException $e) {
            return;
        }
    }
187704
public function table()
    {
        if (!$this->_properties['table_name']) {
            $class = explode('\\', get_called_class());
            $this->_properties['table_name'] = Instance::snakecase(lcfirst(end($class)));
        }

        return $this->_properties['table_name'];
    }
672445
private function buildTableName(): string
    {
        $table = '{db_prefix}' . $this->table;
        
        $no_alias_methods = [
            'REPLACE',
            'INSERT'
        ];
        
        if (in_array($this->method, $no_alias_methods)) {
            return $table;
        }
        
        if (! empty($this->alias)) {
            $table .= ' AS ' . $this->alias;
        }
        
        return $table;
    }
1230244
public function getTableFieldMigrationName($name, $tableName)
    {
        return sprintf(
            MigrationBuilder::PATTERN_FIELD,
            ucfirst($name),
            ucfirst($tableName)
        );
    }
58884
public function getTableName() {
		if ($this->name === null) {
			$this->name = lcfirst($this->getIntrospectiveData()->name);
		}

		return $this->name;
	}
681401
public function getNewMigrations( )
    {
        // check if migration table exists
        $exists = $this->db->tableExists( $this->migrationTable );
        
        if ( !$exists )
        {
            $this->createMigrationTable( );
        }
        
        $query = "SELECT * FROM $this->migrationTable";
        
        $applied = $this->db->query( $query );
        
        $migrations = $this->getMigrations();
        
        $list = array();
        
        foreach( $migrations as $migration )
        {
            $done = FALSE;
            $migToFind = NULL;
            
            foreach( $this->namespaces as $ns )
            {
                $cls = $ns . $migration;
                
                if ( class_exists( $cls ) )
                {
                    $migToFind = $cls;
                    
                    break;
                }
            }
            
            foreach( $applied as $mig )
            {
                if ( $mig[ 'migration_name' ] === $migToFind )
                {
                    $done = TRUE;
                    break;
                }
            }
            
            if ( !$done )
            {
                $list[] = $migration;
            }
        }
        
        return $this->filter( self::ON_GET_NEW_MIGRATIONS_FILTER, $list );
    }
1341559
public function createMigrationTable( )
    {
        if ( empty( $this->migrationTable ) )
        {
            throw new RawException( 'Migration table name must be set' );
        }
        
        $result = NULL;
        
        $table = array(
            'migration_id'           => 'INTEGER(11) PRIMARY KEY AUTO_INCREMENT NOT NULL',
            'migration_name'         => 'VARCHAR(128) NOT NULL',
            'migration_date_applied' => 'BIGINT(20) NOT NULL',
        );
        
        if ( TRUE === $this->db->createTable( $this->migrationTable, $table ) )
        {
            $result = $this->db->addIndex( $this->migrationTable, array( 'migration_name' ) );
        }
        
        $this->doAction( self::ON_CREATE_MIGRATION_TABLE_ACTION );
        
        return $result;
    }
445952
protected function fetchTableNamesDb() {
        // Get the table names.
        $tables = $this->get(
            new Identifier('sqlite_master'),
            [
                'type' => 'table',
                'name' => [Db::OP_LIKE => $this->escapeLike($this->getPx()).'%']
            ],
            [
                'columns' => ['name']
            ]
        )->fetchAll(PDO::FETCH_COLUMN);

        // Remove internal tables.
        $tables = array_filter($tables, function ($name) {
            return substr($name, 0, 7) !== 'sqlite_';
        });

        return $tables;
    }