upgrade

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/ConnectionEventArgs.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\Common\EventArgs;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Driver;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\AbstractSchemaManager;
+use Doctrine\Deprecations\Deprecation;
+
+/**
+ * Event Arguments used when a Driver connection is established inside {@link Connection}.
+ */
+class ConnectionEventArgs extends EventArgs
+{
+    /** @var Connection */
+    private $connection;
+
+    public function __construct(Connection $connection)
+    {
+        $this->connection = $connection;
+    }
+
+    /**
+     * @return Connection
+     */
+    public function getConnection()
+    {
+        return $this->connection;
+    }
+
+    /**
+     * @deprecated Use ConnectionEventArgs::getConnection() and Connection::getDriver() instead.
+     *
+     * @return Driver
+     */
+    public function getDriver()
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/3580',
+            'ConnectionEventArgs::getDriver() is deprecated, ' .
+            'use ConnectionEventArgs::getConnection()->getDriver() instead.'
+        );
+
+        return $this->connection->getDriver();
+    }
+
+    /**
+     * @deprecated Use ConnectionEventArgs::getConnection() and Connection::getDatabasePlatform() instead.
+     *
+     * @return AbstractPlatform
+     */
+    public function getDatabasePlatform()
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/3580',
+            'ConnectionEventArgs::getDatabasePlatform() is deprecated, ' .
+            'use ConnectionEventArgs::getConnection()->getDatabasePlatform() instead.'
+        );
+
+        return $this->connection->getDatabasePlatform();
+    }
+
+    /**
+     * @deprecated Use ConnectionEventArgs::getConnection() and Connection::getSchemaManager() instead.
+     *
+     * @return AbstractSchemaManager
+     */
+    public function getSchemaManager()
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/3580',
+            'ConnectionEventArgs::getSchemaManager() is deprecated, ' .
+            'use ConnectionEventArgs::getConnection()->getSchemaManager() instead.'
+        );
+
+        return $this->connection->getSchemaManager();
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/Listeners/MysqlSessionInit.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Doctrine\DBAL\Event\Listeners;
+
+use Doctrine\Common\EventSubscriber;
+use Doctrine\DBAL\Event\ConnectionEventArgs;
+use Doctrine\DBAL\Events;
+
+/**
+ * MySQL Session Init Event Subscriber which allows to set the Client Encoding of the Connection.
+ *
+ * @deprecated Use "charset" option to PDO MySQL Connection instead.
+ */
+class MysqlSessionInit implements EventSubscriber
+{
+    /**
+     * The charset.
+     *
+     * @var string
+     */
+    private $charset;
+
+    /**
+     * The collation, or FALSE if no collation.
+     *
+     * @var string|bool
+     */
+    private $collation;
+
+    /**
+     * Configure Charset and Collation options of MySQL Client for each Connection.
+     *
+     * @param string      $charset   The charset.
+     * @param string|bool $collation The collation, or FALSE if no collation.
+     */
+    public function __construct($charset = 'utf8', $collation = false)
+    {
+        $this->charset   = $charset;
+        $this->collation = $collation;
+    }
+
+    /**
+     * @return void
+     */
+    public function postConnect(ConnectionEventArgs $args)
+    {
+        $collation = $this->collation ? ' COLLATE ' . $this->collation : '';
+        $args->getConnection()->executeStatement('SET NAMES ' . $this->charset . $collation);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSubscribedEvents()
+    {
+        return [Events::postConnect];
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/Listeners/OracleSessionInit.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Doctrine\DBAL\Event\Listeners;
+
+use Doctrine\Common\EventSubscriber;
+use Doctrine\DBAL\Event\ConnectionEventArgs;
+use Doctrine\DBAL\Events;
+
+use function array_change_key_case;
+use function array_merge;
+use function count;
+use function implode;
+
+use const CASE_UPPER;
+
+/**
+ * Should be used when Oracle Server default environment does not match the Doctrine requirements.
+ *
+ * The following environment variables are required for the Doctrine default date format:
+ *
+ * NLS_TIME_FORMAT="HH24:MI:SS"
+ * NLS_DATE_FORMAT="YYYY-MM-DD HH24:MI:SS"
+ * NLS_TIMESTAMP_FORMAT="YYYY-MM-DD HH24:MI:SS"
+ * NLS_TIMESTAMP_TZ_FORMAT="YYYY-MM-DD HH24:MI:SS TZH:TZM"
+ */
+class OracleSessionInit implements EventSubscriber
+{
+    /** @var string[] */
+    protected $_defaultSessionVars = [
+        'NLS_TIME_FORMAT' => 'HH24:MI:SS',
+        'NLS_DATE_FORMAT' => 'YYYY-MM-DD HH24:MI:SS',
+        'NLS_TIMESTAMP_FORMAT' => 'YYYY-MM-DD HH24:MI:SS',
+        'NLS_TIMESTAMP_TZ_FORMAT' => 'YYYY-MM-DD HH24:MI:SS TZH:TZM',
+        'NLS_NUMERIC_CHARACTERS' => '.,',
+    ];
+
+    /**
+     * @param string[] $oracleSessionVars
+     */
+    public function __construct(array $oracleSessionVars = [])
+    {
+        $this->_defaultSessionVars = array_merge($this->_defaultSessionVars, $oracleSessionVars);
+    }
+
+    /**
+     * @return void
+     */
+    public function postConnect(ConnectionEventArgs $args)
+    {
+        if (! count($this->_defaultSessionVars)) {
+            return;
+        }
+
+        $vars = [];
+        foreach (array_change_key_case($this->_defaultSessionVars, CASE_UPPER) as $option => $value) {
+            if ($option === 'CURRENT_SCHEMA') {
+                $vars[] = $option . ' = ' . $value;
+            } else {
+                $vars[] = $option . " = '" . $value . "'";
+            }
+        }
+
+        $sql = 'ALTER SESSION SET ' . implode(' ', $vars);
+        $args->getConnection()->executeStatement($sql);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSubscribedEvents()
+    {
+        return [Events::postConnect];
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/Listeners/SQLSessionInit.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Doctrine\DBAL\Event\Listeners;
+
+use Doctrine\Common\EventSubscriber;
+use Doctrine\DBAL\Event\ConnectionEventArgs;
+use Doctrine\DBAL\Events;
+
+/**
+ * Session init listener for executing a single SQL statement right after a connection is opened.
+ */
+class SQLSessionInit implements EventSubscriber
+{
+    /** @var string */
+    protected $sql;
+
+    /**
+     * @param string $sql
+     */
+    public function __construct($sql)
+    {
+        $this->sql = $sql;
+    }
+
+    /**
+     * @return void
+     */
+    public function postConnect(ConnectionEventArgs $args)
+    {
+        $conn = $args->getConnection();
+        $conn->exec($this->sql);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSubscribedEvents()
+    {
+        return [Events::postConnect];
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaAlterTableAddColumnEventArgs.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Schema\TableDiff;
+use Doctrine\Deprecations\Deprecation;
+
+use function array_merge;
+use function func_get_args;
+use function is_array;
+
+/**
+ * Event Arguments used when SQL queries for adding table columns are generated inside {@link AbstractPlatform}.
+ */
+class SchemaAlterTableAddColumnEventArgs extends SchemaEventArgs
+{
+    /** @var Column */
+    private $column;
+
+    /** @var TableDiff */
+    private $tableDiff;
+
+    /** @var AbstractPlatform */
+    private $platform;
+
+    /** @var string[] */
+    private $sql = [];
+
+    public function __construct(Column $column, TableDiff $tableDiff, AbstractPlatform $platform)
+    {
+        $this->column    = $column;
+        $this->tableDiff = $tableDiff;
+        $this->platform  = $platform;
+    }
+
+    /**
+     * @return Column
+     */
+    public function getColumn()
+    {
+        return $this->column;
+    }
+
+    /**
+     * @return TableDiff
+     */
+    public function getTableDiff()
+    {
+        return $this->tableDiff;
+    }
+
+    /**
+     * @return AbstractPlatform
+     */
+    public function getPlatform()
+    {
+        return $this->platform;
+    }
+
+    /**
+     * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead.
+     *
+     * @param string|string[] $sql
+     *
+     * @return SchemaAlterTableAddColumnEventArgs
+     */
+    public function addSql($sql)
+    {
+        if (is_array($sql)) {
+            Deprecation::trigger(
+                'doctrine/dbal',
+                'https://github.com/doctrine/dbal/issues/3580',
+                'Passing multiple SQL statements as an array to SchemaAlterTableAddColumnEventaArrgs::addSql() ' .
+                'is deprecated. Pass each statement as an individual argument instead.'
+            );
+        }
+
+        $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args());
+
+        return $this;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getSql()
+    {
+        return $this->sql;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaAlterTableChangeColumnEventArgs.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\ColumnDiff;
+use Doctrine\DBAL\Schema\TableDiff;
+
+use function array_merge;
+use function func_get_args;
+use function is_array;
+
+/**
+ * Event Arguments used when SQL queries for changing table columns are generated inside {@link AbstractPlatform}.
+ */
+class SchemaAlterTableChangeColumnEventArgs extends SchemaEventArgs
+{
+    /** @var ColumnDiff */
+    private $columnDiff;
+
+    /** @var TableDiff */
+    private $tableDiff;
+
+    /** @var AbstractPlatform */
+    private $platform;
+
+    /** @var string[] */
+    private $sql = [];
+
+    public function __construct(ColumnDiff $columnDiff, TableDiff $tableDiff, AbstractPlatform $platform)
+    {
+        $this->columnDiff = $columnDiff;
+        $this->tableDiff  = $tableDiff;
+        $this->platform   = $platform;
+    }
+
+    /**
+     * @return ColumnDiff
+     */
+    public function getColumnDiff()
+    {
+        return $this->columnDiff;
+    }
+
+    /**
+     * @return TableDiff
+     */
+    public function getTableDiff()
+    {
+        return $this->tableDiff;
+    }
+
+    /**
+     * @return AbstractPlatform
+     */
+    public function getPlatform()
+    {
+        return $this->platform;
+    }
+
+    /**
+     * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead.
+     *
+     * @param string|string[] $sql
+     *
+     * @return SchemaAlterTableChangeColumnEventArgs
+     */
+    public function addSql($sql)
+    {
+        $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args());
+
+        return $this;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getSql()
+    {
+        return $this->sql;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaAlterTableEventArgs.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\TableDiff;
+
+use function array_merge;
+use function func_get_args;
+use function is_array;
+
+/**
+ * Event Arguments used when SQL queries for creating tables are generated inside {@link AbstractPlatform}.
+ */
+class SchemaAlterTableEventArgs extends SchemaEventArgs
+{
+    /** @var TableDiff */
+    private $tableDiff;
+
+    /** @var AbstractPlatform */
+    private $platform;
+
+    /** @var string[] */
+    private $sql = [];
+
+    public function __construct(TableDiff $tableDiff, AbstractPlatform $platform)
+    {
+        $this->tableDiff = $tableDiff;
+        $this->platform  = $platform;
+    }
+
+    /**
+     * @return TableDiff
+     */
+    public function getTableDiff()
+    {
+        return $this->tableDiff;
+    }
+
+    /**
+     * @return AbstractPlatform
+     */
+    public function getPlatform()
+    {
+        return $this->platform;
+    }
+
+    /**
+     * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead.
+     *
+     * @param string|string[] $sql
+     *
+     * @return SchemaAlterTableEventArgs
+     */
+    public function addSql($sql)
+    {
+        $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args());
+
+        return $this;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getSql()
+    {
+        return $this->sql;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaAlterTableRemoveColumnEventArgs.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Schema\TableDiff;
+
+use function array_merge;
+use function func_get_args;
+use function is_array;
+
+/**
+ * Event Arguments used when SQL queries for removing table columns are generated inside {@link AbstractPlatform}.
+ */
+class SchemaAlterTableRemoveColumnEventArgs extends SchemaEventArgs
+{
+    /** @var Column */
+    private $column;
+
+    /** @var TableDiff */
+    private $tableDiff;
+
+    /** @var AbstractPlatform */
+    private $platform;
+
+    /** @var string[] */
+    private $sql = [];
+
+    public function __construct(Column $column, TableDiff $tableDiff, AbstractPlatform $platform)
+    {
+        $this->column    = $column;
+        $this->tableDiff = $tableDiff;
+        $this->platform  = $platform;
+    }
+
+    /**
+     * @return Column
+     */
+    public function getColumn()
+    {
+        return $this->column;
+    }
+
+    /**
+     * @return TableDiff
+     */
+    public function getTableDiff()
+    {
+        return $this->tableDiff;
+    }
+
+    /**
+     * @return AbstractPlatform
+     */
+    public function getPlatform()
+    {
+        return $this->platform;
+    }
+
+    /**
+     * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead.
+     *
+     * @param string|string[] $sql
+     *
+     * @return SchemaAlterTableRemoveColumnEventArgs
+     */
+    public function addSql($sql)
+    {
+        $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args());
+
+        return $this;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getSql()
+    {
+        return $this->sql;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaAlterTableRenameColumnEventArgs.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Schema\TableDiff;
+
+use function array_merge;
+use function func_get_args;
+use function is_array;
+
+/**
+ * Event Arguments used when SQL queries for renaming table columns are generated inside {@link AbstractPlatform}.
+ */
+class SchemaAlterTableRenameColumnEventArgs extends SchemaEventArgs
+{
+    /** @var string */
+    private $oldColumnName;
+
+    /** @var Column */
+    private $column;
+
+    /** @var TableDiff */
+    private $tableDiff;
+
+    /** @var AbstractPlatform */
+    private $platform;
+
+    /** @var string[] */
+    private $sql = [];
+
+    /**
+     * @param string $oldColumnName
+     */
+    public function __construct($oldColumnName, Column $column, TableDiff $tableDiff, AbstractPlatform $platform)
+    {
+        $this->oldColumnName = $oldColumnName;
+        $this->column        = $column;
+        $this->tableDiff     = $tableDiff;
+        $this->platform      = $platform;
+    }
+
+    /**
+     * @return string
+     */
+    public function getOldColumnName()
+    {
+        return $this->oldColumnName;
+    }
+
+    /**
+     * @return Column
+     */
+    public function getColumn()
+    {
+        return $this->column;
+    }
+
+    /**
+     * @return TableDiff
+     */
+    public function getTableDiff()
+    {
+        return $this->tableDiff;
+    }
+
+    /**
+     * @return AbstractPlatform
+     */
+    public function getPlatform()
+    {
+        return $this->platform;
+    }
+
+    /**
+     * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead.
+     *
+     * @param string|string[] $sql
+     *
+     * @return SchemaAlterTableRenameColumnEventArgs
+     */
+    public function addSql($sql)
+    {
+        $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args());
+
+        return $this;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getSql()
+    {
+        return $this->sql;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaColumnDefinitionEventArgs.php

@@ -0,0 +1,116 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\Deprecations\Deprecation;
+
+/**
+ * Event Arguments used when the portable column definition is generated inside {@link AbstractPlatform}.
+ */
+class SchemaColumnDefinitionEventArgs extends SchemaEventArgs
+{
+    /** @var Column|null */
+    private $column;
+
+    /**
+     * Raw column data as fetched from the database.
+     *
+     * @var mixed[]
+     */
+    private $tableColumn;
+
+    /** @var string */
+    private $table;
+
+    /** @var string */
+    private $database;
+
+    /** @var Connection */
+    private $connection;
+
+    /**
+     * @param mixed[] $tableColumn
+     * @param string  $table
+     * @param string  $database
+     */
+    public function __construct(array $tableColumn, $table, $database, Connection $connection)
+    {
+        $this->tableColumn = $tableColumn;
+        $this->table       = $table;
+        $this->database    = $database;
+        $this->connection  = $connection;
+    }
+
+    /**
+     * Allows to clear the column which means the column will be excluded from
+     * tables column list.
+     *
+     * @return SchemaColumnDefinitionEventArgs
+     */
+    public function setColumn(?Column $column = null)
+    {
+        $this->column = $column;
+
+        return $this;
+    }
+
+    /**
+     * @return Column|null
+     */
+    public function getColumn()
+    {
+        return $this->column;
+    }
+
+    /**
+     * @return mixed[]
+     */
+    public function getTableColumn()
+    {
+        return $this->tableColumn;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTable()
+    {
+        return $this->table;
+    }
+
+    /**
+     * @return string
+     */
+    public function getDatabase()
+    {
+        return $this->database;
+    }
+
+    /**
+     * @return Connection
+     */
+    public function getConnection()
+    {
+        return $this->connection;
+    }
+
+    /**
+     * @deprecated Use SchemaColumnDefinitionEventArgs::getConnection() and Connection::getDatabasePlatform() instead.
+     *
+     * @return AbstractPlatform
+     */
+    public function getDatabasePlatform()
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/3580',
+            'SchemaColumnDefinitionEventArgs::getDatabasePlatform() is deprecated, ' .
+            'use SchemaColumnDefinitionEventArgs::getConnection()->getDatabasePlatform() instead.'
+        );
+
+        return $this->connection->getDatabasePlatform();
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaCreateTableColumnEventArgs.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Schema\Table;
+
+use function array_merge;
+use function func_get_args;
+use function is_array;
+
+/**
+ * Event Arguments used when SQL queries for creating table columns are generated inside {@link AbstractPlatform}.
+ */
+class SchemaCreateTableColumnEventArgs extends SchemaEventArgs
+{
+    /** @var Column */
+    private $column;
+
+    /** @var Table */
+    private $table;
+
+    /** @var AbstractPlatform */
+    private $platform;
+
+    /** @var string[] */
+    private $sql = [];
+
+    public function __construct(Column $column, Table $table, AbstractPlatform $platform)
+    {
+        $this->column   = $column;
+        $this->table    = $table;
+        $this->platform = $platform;
+    }
+
+    /**
+     * @return Column
+     */
+    public function getColumn()
+    {
+        return $this->column;
+    }
+
+    /**
+     * @return Table
+     */
+    public function getTable()
+    {
+        return $this->table;
+    }
+
+    /**
+     * @return AbstractPlatform
+     */
+    public function getPlatform()
+    {
+        return $this->platform;
+    }
+
+    /**
+     * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead.
+     *
+     * @param string|string[] $sql
+     *
+     * @return SchemaCreateTableColumnEventArgs
+     */
+    public function addSql($sql)
+    {
+        $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args());
+
+        return $this;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getSql()
+    {
+        return $this->sql;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaCreateTableEventArgs.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\Table;
+
+use function array_merge;
+use function func_get_args;
+use function is_array;
+
+/**
+ * Event Arguments used when SQL queries for creating tables are generated inside {@link AbstractPlatform}.
+ */
+class SchemaCreateTableEventArgs extends SchemaEventArgs
+{
+    /** @var Table */
+    private $table;
+
+    /** @var mixed[][] */
+    private $columns;
+
+    /** @var mixed[] */
+    private $options;
+
+    /** @var AbstractPlatform */
+    private $platform;
+
+    /** @var string[] */
+    private $sql = [];
+
+    /**
+     * @param mixed[][] $columns
+     * @param mixed[]   $options
+     */
+    public function __construct(Table $table, array $columns, array $options, AbstractPlatform $platform)
+    {
+        $this->table    = $table;
+        $this->columns  = $columns;
+        $this->options  = $options;
+        $this->platform = $platform;
+    }
+
+    /**
+     * @return Table
+     */
+    public function getTable()
+    {
+        return $this->table;
+    }
+
+    /**
+     * @return mixed[][]
+     */
+    public function getColumns()
+    {
+        return $this->columns;
+    }
+
+    /**
+     * @return mixed[]
+     */
+    public function getOptions()
+    {
+        return $this->options;
+    }
+
+    /**
+     * @return AbstractPlatform
+     */
+    public function getPlatform()
+    {
+        return $this->platform;
+    }
+
+    /**
+     * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead.
+     *
+     * @param string|string[] $sql
+     *
+     * @return SchemaCreateTableEventArgs
+     */
+    public function addSql($sql)
+    {
+        $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args());
+
+        return $this;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getSql()
+    {
+        return $this->sql;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaDropTableEventArgs.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\Table;
+use InvalidArgumentException;
+
+/**
+ * Event Arguments used when the SQL query for dropping tables are generated inside {@link AbstractPlatform}.
+ */
+class SchemaDropTableEventArgs extends SchemaEventArgs
+{
+    /** @var string|Table */
+    private $table;
+
+    /** @var AbstractPlatform */
+    private $platform;
+
+    /** @var string|null */
+    private $sql;
+
+    /**
+     * @param string|Table $table
+     *
+     * @throws InvalidArgumentException
+     */
+    public function __construct($table, AbstractPlatform $platform)
+    {
+        $this->table    = $table;
+        $this->platform = $platform;
+    }
+
+    /**
+     * @return string|Table
+     */
+    public function getTable()
+    {
+        return $this->table;
+    }
+
+    /**
+     * @return AbstractPlatform
+     */
+    public function getPlatform()
+    {
+        return $this->platform;
+    }
+
+    /**
+     * @param string $sql
+     *
+     * @return SchemaDropTableEventArgs
+     */
+    public function setSql($sql)
+    {
+        $this->sql = $sql;
+
+        return $this;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getSql()
+    {
+        return $this->sql;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaEventArgs.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\Common\EventArgs;
+
+/**
+ * Base class for schema related events.
+ */
+class SchemaEventArgs extends EventArgs
+{
+    /** @var bool */
+    private $preventDefault = false;
+
+    /**
+     * @return SchemaEventArgs
+     */
+    public function preventDefault()
+    {
+        $this->preventDefault = true;
+
+        return $this;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isDefaultPrevented()
+    {
+        return $this->preventDefault;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Event/SchemaIndexDefinitionEventArgs.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Doctrine\DBAL\Event;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Schema\Index;
+use Doctrine\Deprecations\Deprecation;
+
+/**
+ * Event Arguments used when the portable index definition is generated inside {@link AbstractSchemaManager}.
+ */
+class SchemaIndexDefinitionEventArgs extends SchemaEventArgs
+{
+    /** @var Index|null */
+    private $index;
+
+    /**
+     * Raw index data as fetched from the database.
+     *
+     * @var mixed[]
+     */
+    private $tableIndex;
+
+    /** @var string */
+    private $table;
+
+    /** @var Connection */
+    private $connection;
+
+    /**
+     * @param mixed[] $tableIndex
+     * @param string  $table
+     */
+    public function __construct(array $tableIndex, $table, Connection $connection)
+    {
+        $this->tableIndex = $tableIndex;
+        $this->table      = $table;
+        $this->connection = $connection;
+    }
+
+    /**
+     * Allows to clear the index which means the index will be excluded from tables index list.
+     *
+     * @return SchemaIndexDefinitionEventArgs
+     */
+    public function setIndex(?Index $index = null)
+    {
+        $this->index = $index;
+
+        return $this;
+    }
+
+    /**
+     * @return Index|null
+     */
+    public function getIndex()
+    {
+        return $this->index;
+    }
+
+    /**
+     * @return mixed[]
+     */
+    public function getTableIndex()
+    {
+        return $this->tableIndex;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTable()
+    {
+        return $this->table;
+    }
+
+    /**
+     * @return Connection
+     */
+    public function getConnection()
+    {
+        return $this->connection;
+    }
+
+    /**
+     * @deprecated Use SchemaIndexDefinitionEventArgs::getConnection() and Connection::getDatabasePlatform() instead.
+     *
+     * @return AbstractPlatform
+     */
+    public function getDatabasePlatform()
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/3580',
+            'SchemaIndexDefinitionEventArgs::getDatabasePlatform() is deprecated, ' .
+            'use SchemaIndexDefinitionEventArgs::getConnection()->getDatabasePlatform() instead.'
+        );
+
+        return $this->connection->getDatabasePlatform();
+    }
+}