'DROP SCHEMA ' . $schemaName;
 }
 public function quoteIdentifier($str)
 {
 if (strpos($str, '.') !== \false) {
 $parts = array_map([$this, 'quoteSingleIdentifier'], explode('.', $str));
 return implode('.', $parts);
 }
 return $this->quoteSingleIdentifier($str);
 }
 public function quoteSingleIdentifier($str)
 {
 $c = $this->getIdentifierQuoteCharacter();
 return $c . str_replace($c, $c . $c, $str) . $c;
 }
 public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table)
 {
 if ($table instanceof Table) {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/issues/4798', 'Passing $table as a Table object to %s is deprecated. Pass it as a quoted name instead.', __METHOD__);
 $table = $table->getQuotedName($this);
 }
 return 'ALTER TABLE ' . $table . ' ADD ' . $this->getForeignKeyDeclarationSQL($foreignKey);
 }
 public function getAlterTableSQL(TableDiff $diff)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getRenameTableSQL(string $oldName, string $newName) : array
 {
 return [sprintf('ALTER TABLE %s RENAME TO %s', $oldName, $newName)];
 }
 protected function onSchemaAlterTableAddColumn(Column $column, TableDiff $diff, &$columnSql)
 {
 if ($this->_eventManager === null) {
 return \false;
 }
 if (!$this->_eventManager->hasListeners(Events::onSchemaAlterTableAddColumn)) {
 return \false;
 }
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/issues/5784', 'Subscribing to %s events is deprecated.', Events::onSchemaAlterTableAddColumn);
 $eventArgs = new SchemaAlterTableAddColumnEventArgs($column, $diff, $this);
 $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableAddColumn, $eventArgs);
 $columnSql = array_merge($columnSql, $eventArgs->getSql());
 return $eventArgs->isDefaultPrevented();
 }
 protected function onSchemaAlterTableRemoveColumn(Column $column, TableDiff $diff, &$columnSql)
 {
 if ($this->_eventManager === null) {
 return \false;
 }
 if (!$this->_eventManager->hasListeners(Events::onSchemaAlterTableRemoveColumn)) {
 return \false;
 }
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/issues/5784', 'Subscribing to %s events is deprecated.', Events::onSchemaAlterTableRemoveColumn);
 $eventArgs = new SchemaAlterTableRemoveColumnEventArgs($column, $diff, $this);
 $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRemoveColumn, $eventArgs);
 $columnSql = array_merge($columnSql, $eventArgs->getSql());
 return $eventArgs->isDefaultPrevented();
 }
 protected function onSchemaAlterTableChangeColumn(ColumnDiff $columnDiff, TableDiff $diff, &$columnSql)
 {
 if ($this->_eventManager === null) {
 return \false;
 }
 if (!$this->_eventManager->hasListeners(Events::onSchemaAlterTableChangeColumn)) {
 return \false;
 }
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/issues/5784', 'Subscribing to %s events is deprecated.', Events::onSchemaAlterTableChangeColumn);
 $eventArgs = new SchemaAlterTableChangeColumnEventArgs($columnDiff, $diff, $this);
 $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableChangeColumn, $eventArgs);
 $columnSql = array_merge($columnSql, $eventArgs->getSql());
 return $eventArgs->isDefaultPrevented();
 }
 protected function onSchemaAlterTableRenameColumn($oldColumnName, Column $column, TableDiff $diff, &$columnSql)
 {
 if ($this->_eventManager === null) {
 return \false;
 }
 if (!$this->_eventManager->hasListeners(Events::onSchemaAlterTableRenameColumn)) {
 return \false;
 }
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/issues/5784', 'Subscribing to %s events is deprecated.', Events::onSchemaAlterTableRenameColumn);
 $eventArgs = new SchemaAlterTableRenameColumnEventArgs($oldColumnName, $column, $diff, $this);
 $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRenameColumn, $eventArgs);
 $columnSql = array_merge($columnSql, $eventArgs->getSql());
 return $eventArgs->isDefaultPrevented();
 }
 protected function onSchemaAlterTable(TableDiff $diff, &$sql)
 {
 if ($this->_eventManager === null) {
 return \false;
 }
 if (!$this->_eventManager->hasListeners(Events::onSchemaAlterTable)) {
 return \false;
 }
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/issues/5784', 'Subscribing to %s events is deprecated.', Events::onSchemaAlterTable);
 $eventArgs = new SchemaAlterTableEventArgs($diff, $this);
 $this->_eventManager->dispatchEvent(Events::onSchemaAlterTable, $eventArgs);
 $sql = array_merge($sql, $eventArgs->getSql());
 return $eventArgs->isDefaultPrevented();
 }
 protected function getPreAlterTableIndexForeignKeySQL(TableDiff $diff)
 {
 $tableNameSQL = ($diff->getOldTable() ?? $diff->getName($this))->getQuotedName($this);
 $sql = [];
 if ($this->supportsForeignKeyConstraints()) {
 foreach ($diff->getDroppedForeignKeys() as $foreignKey) {
 if ($foreignKey instanceof ForeignKeyConstraint) {
 $foreignKey = $foreignKey->getQuotedName($this);
 }
 $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableNameSQL);
 }
 foreach ($diff->getModifiedForeignKeys() as $foreignKey) {
 $sql[] = $this->getDropForeignKeySQL($foreignKey->getQuotedName($this), $tableNameSQL);
 }
 }
 foreach ($diff->getDroppedIndexes() as $index) {
 $sql[] = $this->getDropIndexSQL($index->getQuotedName($this), $tableNameSQL);
 }
 foreach ($diff->getModifiedIndexes() as $index) {
 $sql[] = $this->getDropIndexSQL($index->getQuotedName($this), $tableNameSQL);
 }
 return $sql;
 }
 protected function getPostAlterTableIndexForeignKeySQL(TableDiff $diff)
 {
 $sql = [];
 $newName = $diff->getNewName();
 if ($newName !== \false) {
 $tableNameSQL = $newName->getQuotedName($this);
 } else {
 $tableNameSQL = ($diff->getOldTable() ?? $diff->getName($this))->getQuotedName($this);
 }
 if ($this->supportsForeignKeyConstraints()) {
 foreach ($diff->getAddedForeignKeys() as $foreignKey) {
 $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableNameSQL);
 }
 foreach ($diff->getModifiedForeignKeys() as $foreignKey) {
 $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableNameSQL);
 }
 }
 foreach ($diff->getAddedIndexes() as $index) {
 $sql[] = $this->getCreateIndexSQL($index, $tableNameSQL);
 }
 foreach ($diff->getModifiedIndexes() as $index) {
 $sql[] = $this->getCreateIndexSQL($index, $tableNameSQL);
 }
 foreach ($diff->getRenamedIndexes() as $oldIndexName => $index) {
 $oldIndexName = new Identifier($oldIndexName);
 $sql = array_merge($sql, $this->getRenameIndexSQL($oldIndexName->getQuotedName($this), $index, $tableNameSQL));
 }
 return $sql;
 }
 protected function getRenameIndexSQL($oldIndexName, Index $index, $tableName)
 {
 return [$this->getDropIndexSQL($oldIndexName, $tableName), $this->getCreateIndexSQL($index, $tableName)];
 }
 public function getColumnDeclarationListSQL(array $columns)
 {
 $declarations = [];
 foreach ($columns as $name => $column) {
 $declarations[] = $this->getColumnDeclarationSQL($name, $column);
 }
 return implode(', ', $declarations);
 }
 public function getColumnDeclarationSQL($name, array $column)
 {
 if (isset($column['columnDefinition'])) {
 $declaration = $this->getCustomTypeDeclarationSQL($column);
 } else {
 $default = $this->getDefaultValueDeclarationSQL($column);
 $charset = !empty($column['charset']) ? ' ' . $this->getColumnCharsetDeclarationSQL($column['charset']) : '';
 $collation = !empty($column['collation']) ? ' ' . $this->getColumnCollationDeclarationSQL($column['collation']) : '';
 $notnull = !empty($column['notnull']) ? ' NOT NULL' : '';
 if (!empty($column['unique'])) {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5656', 'The usage of the "unique" column property is deprecated. Use unique constraints instead.');
 $unique = ' ' . $this->getUniqueFieldDeclarationSQL();
 } else {
 $unique = '';
 }
 if (!empty($column['check'])) {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5656', 'The usage of the "check" column property is deprecated.');
 $check = ' ' . $column['check'];
 } else {
 $check = '';
 }
 $typeDecl = $column['type']->getSQLDeclaration($column, $this);
 $declaration = $typeDecl . $charset . $default . $notnull . $unique . $check . $collation;
 if ($this->supportsInlineColumnComments() && isset($column['comment']) && $column['comment'] !== '') {
 $declaration .= ' ' . $this->getInlineColumnCommentSQL($column['comment']);
 }
 }
 return $name . ' ' . $declaration;
 }
 public function getDecimalTypeDeclarationSQL(array $column)
 {
 if (empty($column['precision'])) {
 if (!isset($column['precision'])) {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5637', 'Relying on the default decimal column precision is deprecated' . ', specify the precision explicitly.');
 }
 $precision = 10;
 } else {
 $precision = $column['precision'];
 }
 if (empty($column['scale'])) {
 if (!isset($column['scale'])) {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5637', 'Relying on the default decimal column scale is deprecated' . ', specify the scale explicitly.');
 }
 $scale = 0;
 } else {
 $scale = $column['scale'];
 }
 return 'NUMERIC(' . $precision . ', ' . $scale . ')';
 }
 public function getDefaultValueDeclarationSQL($column)
 {
 if (!isset($column['default'])) {
 return empty($column['notnull']) ? ' DEFAULT NULL' : '';
 }
 $default = $column['default'];
 if (!isset($column['type'])) {
 return " DEFAULT '" . $default . "'";
 }
 $type = $column['type'];
 if ($type instanceof Types\PhpIntegerMappingType) {
 return ' DEFAULT ' . $default;
 }
 if ($type instanceof Types\PhpDateTimeMappingType && $default === $this->getCurrentTimestampSQL()) {
 return ' DEFAULT ' . $this->getCurrentTimestampSQL();
 }
 if ($type instanceof Types\TimeType && $default === $this->getCurrentTimeSQL()) {
 return ' DEFAULT ' . $this->getCurrentTimeSQL();
 }
 if ($type instanceof Types\DateType && $default === $this->getCurrentDateSQL()) {
 return ' DEFAULT ' . $this->getCurrentDateSQL();
 }
 if ($type instanceof Types\BooleanType) {
 return ' DEFAULT ' . $this->convertBooleans($default);
 }
 return ' DEFAULT ' . $this->quoteStringLiteral($default);
 }
 public function getCheckDeclarationSQL(array $definition)
 {
 $constraints = [];
 foreach ($definition as $column => $def) {
 if (is_string($def)) {
 $constraints[] = 'CHECK (' . $def . ')';
 } else {
 if (isset($def['min'])) {
 $constraints[] = 'CHECK (' . $column . ' >= ' . $def['min'] . ')';
 }
 if (isset($def['max'])) {
 $constraints[] = 'CHECK (' . $column . ' <= ' . $def['max'] . ')';
 }
 }
 }
 return implode(', ', $constraints);
 }
 public function getUniqueConstraintDeclarationSQL($name, UniqueConstraint $constraint)
 {
 $columns = $constraint->getQuotedColumns($this);
 $name = new Identifier($name);
 if (count($columns) === 0) {
 throw new InvalidArgumentException("Incomplete definition. 'columns' required.");
 }
 $constraintFlags = array_merge(['UNIQUE'], array_map('strtoupper', $constraint->getFlags()));
 $constraintName = $name->getQuotedName($this);
 $columnListNames = $this->getColumnsFieldDeclarationListSQL($columns);
 return sprintf('CONSTRAINT %s %s (%s)', $constraintName, implode(' ', $constraintFlags), $columnListNames);
 }
 public function getIndexDeclarationSQL($name, Index $index)
 {
 $columns = $index->getColumns();
 $name = new Identifier($name);
 if (count($columns) === 0) {
 throw new InvalidArgumentException("Incomplete definition. 'columns' required.");
 }
 return $this->getCreateIndexSQLFlags($index) . 'INDEX ' . $name->getQuotedName($this) . ' (' . $this->getIndexFieldDeclarationListSQL($index) . ')' . $this->getPartialIndexSQL($index);
 }
 public function getCustomTypeDeclarationSQL(array $column)
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5527', '%s is deprecated.', __METHOD__);
 return $column['columnDefinition'];
 }
 public function getIndexFieldDeclarationListSQL(Index $index) : string
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5527', '%s is deprecated.', __METHOD__);
 return implode(', ', $index->getQuotedColumns($this));
 }
 public function getColumnsFieldDeclarationListSQL(array $columns) : string
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5527', '%s is deprecated.', __METHOD__);
 $ret = [];
 foreach ($columns as $column => $definition) {
 if (is_array($definition)) {
 $ret[] = $column;
 } else {
 $ret[] = $definition;
 }
 }
 return implode(', ', $ret);
 }
 public function getTemporaryTableSQL()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::getTemporaryTableSQL() is deprecated.');
 return 'TEMPORARY';
 }
 public function getTemporaryTableName($tableName)
 {
 return $tableName;
 }
 public function getForeignKeyDeclarationSQL(ForeignKeyConstraint $foreignKey)
 {
 $sql = $this->getForeignKeyBaseDeclarationSQL($foreignKey);
 $sql .= $this->getAdvancedForeignKeyOptionsSQL($foreignKey);
 return $sql;
 }
 public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey)
 {
 $query = '';
 if ($foreignKey->hasOption('onUpdate')) {
 $query .= ' ON UPDATE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onUpdate'));
 }
 if ($foreignKey->hasOption('onDelete')) {
 $query .= ' ON DELETE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onDelete'));
 }
 return $query;
 }
 public function getForeignKeyReferentialActionSQL($action)
 {
 $upper = strtoupper($action);
 switch ($upper) {
 case 'CASCADE':
 case 'SET NULL':
 case 'NO ACTION':
 case 'RESTRICT':
 case 'SET DEFAULT':
 return $upper;
 default:
 throw new InvalidArgumentException('Invalid foreign key action: ' . $upper);
 }
 }
 public function getForeignKeyBaseDeclarationSQL(ForeignKeyConstraint $foreignKey)
 {
 $sql = '';
 if (strlen($foreignKey->getName()) > 0) {
 $sql .= 'CONSTRAINT ' . $foreignKey->getQuotedName($this) . ' ';
 }
 $sql .= 'FOREIGN KEY (';
 if (count($foreignKey->getLocalColumns()) === 0) {
 throw new InvalidArgumentException("Incomplete definition. 'local' required.");
 }
 if (count($foreignKey->getForeignColumns()) === 0) {
 throw new InvalidArgumentException("Incomplete definition. 'foreign' required.");
 }
 if (strlen($foreignKey->getForeignTableName()) === 0) {
 throw new InvalidArgumentException("Incomplete definition. 'foreignTable' required.");
 }
 return $sql . implode(', ', $foreignKey->getQuotedLocalColumns($this)) . ') REFERENCES ' . $foreignKey->getQuotedForeignTableName($this) . ' (' . implode(', ', $foreignKey->getQuotedForeignColumns($this)) . ')';
 }
 public function getUniqueFieldDeclarationSQL()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::getUniqueFieldDeclarationSQL() is deprecated. Use UNIQUE in SQL instead.');
 return 'UNIQUE';
 }
 public function getColumnCharsetDeclarationSQL($charset)
 {
 return '';
 }
 public function getColumnCollationDeclarationSQL($collation)
 {
 return $this->supportsColumnCollation() ? 'COLLATE ' . $this->quoteSingleIdentifier($collation) : '';
 }
 public function prefersIdentityColumns()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/1519', 'AbstractPlatform::prefersIdentityColumns() is deprecated.');
 return \false;
 }
 public function convertBooleans($item)
 {
 if (is_array($item)) {
 foreach ($item as $k => $value) {
 if (!is_bool($value)) {
 continue;
 }
 $item[$k] = (int) $value;
 }
 } elseif (is_bool($item)) {
 $item = (int) $item;
 }
 return $item;
 }
 public function convertFromBoolean($item)
 {
 return $item === null ? null : (bool) $item;
 }
 public function convertBooleansToDatabaseValue($item)
 {
 return $this->convertBooleans($item);
 }
 public function getCurrentDateSQL()
 {
 return 'CURRENT_DATE';
 }
 public function getCurrentTimeSQL()
 {
 return 'CURRENT_TIME';
 }
 public function getCurrentTimestampSQL()
 {
 return 'CURRENT_TIMESTAMP';
 }
 protected function _getTransactionIsolationLevelSQL($level)
 {
 switch ($level) {
 case TransactionIsolationLevel::READ_UNCOMMITTED:
 return 'READ UNCOMMITTED';
 case TransactionIsolationLevel::READ_COMMITTED:
 return 'READ COMMITTED';
 case TransactionIsolationLevel::REPEATABLE_READ:
 return 'REPEATABLE READ';
 case TransactionIsolationLevel::SERIALIZABLE:
 return 'SERIALIZABLE';
 default:
 throw new InvalidArgumentException('Invalid isolation level:' . $level);
 }
 }
 public function getListDatabasesSQL()
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getListNamespacesSQL()
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/issues/4503', 'AbstractPlatform::getListNamespacesSQL() is deprecated,' . ' use AbstractSchemaManager::listSchemaNames() instead.');
 throw Exception::notSupported(__METHOD__);
 }
 public function getListSequencesSQL($database)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getListTableConstraintsSQL($table)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getListTableColumnsSQL($table, $database = null)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getListTablesSQL()
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getListUsersSQL()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::getListUsersSQL() is deprecated.');
 throw Exception::notSupported(__METHOD__);
 }
 public function getListViewsSQL($database)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getListTableIndexesSQL($table, $database = null)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getListTableForeignKeysSQL($table)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getCreateViewSQL($name, $sql)
 {
 return 'CREATE VIEW ' . $name . ' AS ' . $sql;
 }
 public function getDropViewSQL($name)
 {
 return 'DROP VIEW ' . $name;
 }
 public function getSequenceNextValSQL($sequence)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getCreateDatabaseSQL($name)
 {
 if (!$this->supportsCreateDropDatabase()) {
 throw Exception::notSupported(__METHOD__);
 }
 return 'CREATE DATABASE ' . $name;
 }
 public function getDropDatabaseSQL($name)
 {
 if (!$this->supportsCreateDropDatabase()) {
 throw Exception::notSupported(__METHOD__);
 }
 return 'DROP DATABASE ' . $name;
 }
 public function getSetTransactionIsolationSQL($level)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getDateTimeTypeDeclarationSQL(array $column)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getDateTimeTzTypeDeclarationSQL(array $column)
 {
 return $this->getDateTimeTypeDeclarationSQL($column);
 }
 public function getDateTypeDeclarationSQL(array $column)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getTimeTypeDeclarationSQL(array $column)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function getFloatDeclarationSQL(array $column)
 {
 return 'DOUBLE PRECISION';
 }
 public function getDefaultTransactionIsolationLevel()
 {
 return TransactionIsolationLevel::READ_COMMITTED;
 }
 public function supportsSequences()
 {
 return \false;
 }
 public function supportsIdentityColumns()
 {
 return \false;
 }
 public function usesSequenceEmulatedIdentityColumns()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5513', '%s is deprecated.', __METHOD__);
 return \false;
 }
 public function getIdentitySequenceName($tableName, $columnName)
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function supportsIndexes()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::supportsIndexes() is deprecated.');
 return \true;
 }
 public function supportsPartialIndexes()
 {
 return \false;
 }
 public function supportsColumnLengthIndexes() : bool
 {
 return \false;
 }
 public function supportsAlterTable()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::supportsAlterTable() is deprecated. All platforms must implement altering tables.');
 return \true;
 }
 public function supportsTransactions()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::supportsTransactions() is deprecated.');
 return \true;
 }
 public function supportsSavepoints()
 {
 return \true;
 }
 public function supportsReleaseSavepoints()
 {
 return $this->supportsSavepoints();
 }
 public function supportsPrimaryConstraints()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::supportsPrimaryConstraints() is deprecated.');
 return \true;
 }
 public function supportsForeignKeyConstraints()
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5409', 'AbstractPlatform::supportsForeignKeyConstraints() is deprecated.');
 return \true;
 }
 public function supportsSchemas()
 {
 return \false;
 }
 public function canEmulateSchemas()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4805', 'AbstractPlatform::canEmulateSchemas() is deprecated.');
 return \false;
 }
 public function getDefaultSchemaName()
 {
 throw Exception::notSupported(__METHOD__);
 }
 public function supportsCreateDropDatabase()
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5513', '%s is deprecated.', __METHOD__);
 return \true;
 }
 public function supportsGettingAffectedRows()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::supportsGettingAffectedRows() is deprecated.');
 return \true;
 }
 public function supportsInlineColumnComments()
 {
 return \false;
 }
 public function supportsCommentOnStatement()
 {
 return \false;
 }
 public function hasNativeGuidType()
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5509', '%s is deprecated.', __METHOD__);
 return \false;
 }
 public function hasNativeJsonType()
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5509', '%s is deprecated.', __METHOD__);
 return \false;
 }
 public function supportsViews()
 {
 Deprecation::trigger('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::supportsViews() is deprecated. All platforms must implement support for views.');
 return \true;
 }
 public function supportsColumnCollation()
 {
 return \false;
 }
 public function getDateTimeFormatString()
 {
 return 'Y-m-d H:i:s';
 }
 public function getDateTimeTzFormatString()
 {
 return 'Y-m-d H:i:s';
 }
 public function getDateFormatString()
 {
 return 'Y-m-d';
 }
 public function getTimeFormatString()
 {
 return 'H:i:s';
 }
 public final function modifyLimitQuery($query, $limit, $offset = 0) : string
 {
 if ($offset < 0) {
 throw new Exception(sprintf('Offset must be a positive integer or zero, %d given', $offset));
 }
 if ($offset > 0 && !$this->supportsLimitOffset()) {
 throw new Exception(sprintf('Platform %s does not support offset values in limit queries.', $this->getName()));
 }
 if ($limit !== null) {
 $limit = (int) $limit;
 }
 return $this->doModifyLimitQuery($query, $limit, (int) $offset);
 }
 protected function doModifyLimitQuery($query, $limit, $offset)
 {
 if ($limit !== null) {
 $query .= sprintf(' LIMIT %d', $limit);
 }
 if ($offset > 0) {
 $query .= sprintf(' OFFSET %d', $offset);
 }
 return $query;
 }
 public function supportsLimitOffset()
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/4724', 'AbstractPlatform::supportsViews() is deprecated.' . ' All platforms must implement support for offsets in modify limit clauses.');
 return \true;
 }
 public function getMaxIdentifierLength()
 {
 return 63;
 }
 public function getEmptyIdentityInsertSQL($quotedTableName, $quotedIdentifierColumnName)
 {
 return 'INSERT INTO ' . $quotedTableName . ' (' . $quotedIdentifierColumnName . ') VALUES (null)';
 }
 public function getTruncateTableSQL($tableName, $cascade = \false)
 {
 $tableIdentifier = new Identifier($tableName);
 return 'TRUNCATE ' . $tableIdentifier->getQuotedName($this);
 }
 public function getDummySelectSQL()
 {
 $expression = func_num_args() > 0 ? func_get_arg(0) : '1';
 return sprintf('SELECT %s', $expression);
 }
 public function createSavePoint($savepoint)
 {
 return 'SAVEPOINT ' . $savepoint;
 }
 public function releaseSavePoint($savepoint)
 {
 return 'RELEASE SAVEPOINT ' . $savepoint;
 }
 public function rollbackSavePoint($savepoint)
 {
 return 'ROLLBACK TO SAVEPOINT ' . $savepoint;
 }
 public final function getReservedKeywordsList() : KeywordList
 {
 // Store the instance so it doesn't need to be generated on every request.
 return $this->_keywords ??= $this->createReservedKeywordsList();
 }
 protected function createReservedKeywordsList() : KeywordList
 {
 $class = $this->getReservedKeywordsClass();
 $keywords = new $class();
 if (!$keywords instanceof KeywordList) {
 throw Exception::notSupported(__METHOD__);
 }
 return $keywords;
 }
 protected function getReservedKeywordsClass()
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/issues/4510', 'AbstractPlatform::getReservedKeywordsClass() is deprecated,' . ' use AbstractPlatform::createReservedKeywordsList() instead.');
 throw Exception::notSupported(__METHOD__);
 }
 public function quoteStringLiteral($str)
 {
 $c = $this->getStringLiteralQuoteCharacter();
 return $c . str_replace($c, $c . $c, $str) . $c;
 }
 public function getStringLiteralQuoteCharacter()
 {
 Deprecation::triggerIfCalledFromOutside('doctrine/dbal', 'https://github.com/doctrine/dbal/pull/5388', 'AbstractPlatform::getStringLiteralQuoteCharacter() is deprecated.' . ' Use quoteStringLiteral() instead.');
 return "'";
 }
 public final function escapeStringForLike(string $inputString, string $escapeChar) : string
 {
 return preg_replace('~([' . preg_quote($this->getLikeWildcardCharacters() . $escapeChar, '~') . '])~u', addcslashes($escapeChar, '\\') . '$1', $inputString);
 }
 private function columnToArray(Column $column) : array
 {
 $name = $column->getQuotedName($this);
 return array_merge($column->toArray(), ['name' => $name, 'version' => $column->hasPlatformOption('version') ? $column->getPlatformOption('version') : \false, 'comment' => $this->getColumnComment($column)]);
 }
 public function createSQLParser() : Parser
 {
 return new Parser(\false);
 }
 protected function getLikeWildcardCharacters() : string
 {
 return '%_';
 }
 public function columnsEqual(Column $column1, Column $column2) : bool
 {
 $column1Array = $this->columnToArray($column1);
 $column2Array = $this->columnToArray($column2);
 // ignore explicit columnDefinition since it's not set on the Column generated by the SchemaManager
 unset($column1Array['columnDefinition']);
 unset($column2Array['columnDefinition']);
 if ($this->getColumnDeclarationSQL('', $column1Array) !== $this->getColumnDeclarationSQL('', $column2Array)) {
 return \false;
 }
 if (!$this->columnDeclarationsMatch($column1, $column2)) {
 return \false;
 }
 // If the platform supports inline comments, all comparison is already done above
 if ($this->supportsInlineColumnComments()) {
 return \true;
 }
 if ($column1->getComment() !== $column2->getComment()) {
 return \false;
 }
 return $column1->getType() === $column2->getType();
 }
 private function columnDeclarationsMatch(Column $column1, Column $column2) : bool
 {
 return !($column1->hasPlatformOption('declarationMismatch') || $column2->hasPlatformOption('declarationMismatch'));
 }
 public function createSchemaManager(Connection $connection) : AbstractSchemaManager
 {
 throw Exception::notSupported(__METHOD__);
 }
}