vendor/doctrine/dbal/src/Platforms/AbstractPlatform.php line 4379

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Platforms;
  5. use Doctrine\Common\EventManager;
  6. use Doctrine\DBAL\Connection;
  7. use Doctrine\DBAL\Event\SchemaAlterTableAddColumnEventArgs;
  8. use Doctrine\DBAL\Event\SchemaAlterTableChangeColumnEventArgs;
  9. use Doctrine\DBAL\Event\SchemaAlterTableEventArgs;
  10. use Doctrine\DBAL\Event\SchemaAlterTableRemoveColumnEventArgs;
  11. use Doctrine\DBAL\Event\SchemaAlterTableRenameColumnEventArgs;
  12. use Doctrine\DBAL\Event\SchemaCreateTableColumnEventArgs;
  13. use Doctrine\DBAL\Event\SchemaCreateTableEventArgs;
  14. use Doctrine\DBAL\Event\SchemaDropTableEventArgs;
  15. use Doctrine\DBAL\Events;
  16. use Doctrine\DBAL\Exception;
  17. use Doctrine\DBAL\Exception\InvalidLockMode;
  18. use Doctrine\DBAL\LockMode;
  19. use Doctrine\DBAL\Platforms\Keywords\KeywordList;
  20. use Doctrine\DBAL\Schema\AbstractSchemaManager;
  21. use Doctrine\DBAL\Schema\Column;
  22. use Doctrine\DBAL\Schema\ColumnDiff;
  23. use Doctrine\DBAL\Schema\Constraint;
  24. use Doctrine\DBAL\Schema\ForeignKeyConstraint;
  25. use Doctrine\DBAL\Schema\Identifier;
  26. use Doctrine\DBAL\Schema\Index;
  27. use Doctrine\DBAL\Schema\SchemaDiff;
  28. use Doctrine\DBAL\Schema\Sequence;
  29. use Doctrine\DBAL\Schema\Table;
  30. use Doctrine\DBAL\Schema\TableDiff;
  31. use Doctrine\DBAL\Schema\UniqueConstraint;
  32. use Doctrine\DBAL\SQL\Builder\DefaultSelectSQLBuilder;
  33. use Doctrine\DBAL\SQL\Builder\SelectSQLBuilder;
  34. use Doctrine\DBAL\SQL\Parser;
  35. use Doctrine\DBAL\TransactionIsolationLevel;
  36. use Doctrine\DBAL\Types;
  37. use Doctrine\DBAL\Types\Type;
  38. use Doctrine\Deprecations\Deprecation;
  39. use InvalidArgumentException;
  40. use UnexpectedValueException;
  42. use function addcslashes;
  43. use function array_map;
  44. use function array_merge;
  45. use function array_unique;
  46. use function array_values;
  47. use function assert;
  48. use function count;
  49. use function explode;
  50. use function func_get_arg;
  51. use function func_get_args;
  52. use function func_num_args;
  53. use function implode;
  54. use function in_array;
  55. use function is_array;
  56. use function is_bool;
  57. use function is_int;
  58. use function is_string;
  59. use function preg_quote;
  60. use function preg_replace;
  61. use function sprintf;
  62. use function str_replace;
  63. use function strlen;
  64. use function strpos;
  65. use function strtolower;
  66. use function strtoupper;
  68. /**
  69.  * Base class for all DatabasePlatforms. The DatabasePlatforms are the central
  70.  * point of abstraction of platform-specific behaviors, features and SQL dialects.
  71.  * They are a passive source of information.
  72.  *
  73.  * @todo Remove any unnecessary methods.
  74.  */
  75. abstract class AbstractPlatform
  76. {
  77.     public const CREATE_INDEXES = 1;
  79.     public const CREATE_FOREIGNKEYS = 2;
  81.     /** @var string[]|null */
  82.     protected $doctrineTypeMapping;
  84.     /**
  85.      * Contains a list of all columns that should generate parseable column comments for type-detection
  86.      * in reverse engineering scenarios.
  87.      *
  88.      * @deprecated This property is deprecated and will be removed in Doctrine DBAL 4.0.
  89.      *
  90.      * @var string[]|null
  91.      */
  92.     protected $doctrineTypeComments;
  94.     /**
  95.      * @deprecated
  96.      *
  97.      * @var EventManager|null
  98.      */
  99.     protected $_eventManager;
  101.     /**
  102.      * Holds the KeywordList instance for the current platform.
  103.      *
  104.      * @var KeywordList|null
  105.      */
  106.     protected $_keywords;
  108.     private bool $disableTypeComments = false;
  110.     /** @internal */
  111.     final public function setDisableTypeComments(bool $value): void
  112.     {
  113.         $this->disableTypeComments = $value;
  114.     }
  116.     /**
  117.      * Sets the EventManager used by the Platform.
  118.      *
  119.      * @deprecated
  120.      *
  121.      * @return void
  122.      */
  123.     public function setEventManager(EventManager $eventManager)
  124.     {
  125.         Deprecation::triggerIfCalledFromOutside(
  126.             'doctrine/dbal',
  127.             'https://github.com/doctrine/dbal/issues/5784',
  128.             '%s is deprecated.',
  129.             __METHOD__,
  130.         );
  132.         $this->_eventManager = $eventManager;
  133.     }
  135.     /**
  136.      * Gets the EventManager used by the Platform.
  137.      *
  138.      * @deprecated
  139.      *
  140.      * @return EventManager|null
  141.      */
  142.     public function getEventManager()
  143.     {
  144.         Deprecation::triggerIfCalledFromOutside(
  145.             'doctrine/dbal',
  146.             'https://github.com/doctrine/dbal/issues/5784',
  147.             '%s is deprecated.',
  148.             __METHOD__,
  149.         );
  151.         return $this->_eventManager;
  152.     }
  154.     /**
  155.      * Returns the SQL snippet that declares a boolean column.
  156.      *
  157.      * @param mixed[] $column
  158.      *
  159.      * @return string
  160.      */
  161.     abstract public function getBooleanTypeDeclarationSQL(array $column);
  163.     /**
  164.      * Returns the SQL snippet that declares a 4 byte integer column.
  165.      *
  166.      * @param mixed[] $column
  167.      *
  168.      * @return string
  169.      */
  170.     abstract public function getIntegerTypeDeclarationSQL(array $column);
  172.     /**
  173.      * Returns the SQL snippet that declares an 8 byte integer column.
  174.      *
  175.      * @param mixed[] $column
  176.      *
  177.      * @return string
  178.      */
  179.     abstract public function getBigIntTypeDeclarationSQL(array $column);
  181.     /**
  182.      * Returns the SQL snippet that declares a 2 byte integer column.
  183.      *
  184.      * @param mixed[] $column
  185.      *
  186.      * @return string
  187.      */
  188.     abstract public function getSmallIntTypeDeclarationSQL(array $column);
  190.     /**
  191.      * Returns the SQL snippet that declares common properties of an integer column.
  192.      *
  193.      * @param mixed[] $column
  194.      *
  195.      * @return string
  196.      */
  197.     abstract protected function _getCommonIntegerTypeDeclarationSQL(array $column);
  199.     /**
  200.      * Lazy load Doctrine Type Mappings.
  201.      *
  202.      * @return void
  203.      */
  204.     abstract protected function initializeDoctrineTypeMappings();
  206.     /**
  207.      * Initializes Doctrine Type Mappings with the platform defaults
  208.      * and with all additional type mappings.
  209.      */
  210.     private function initializeAllDoctrineTypeMappings(): void
  211.     {
  212.         $this->initializeDoctrineTypeMappings();
  214.         foreach (Type::getTypesMap() as $typeName => $className) {
  215.             foreach (Type::getType($typeName)->getMappedDatabaseTypes($this) as $dbType) {
  216.                 $dbType                             = strtolower($dbType);
  217.                 $this->doctrineTypeMapping[$dbType] = $typeName;
  218.             }
  219.         }
  220.     }
  222.     /**
  223.      * Returns the SQL snippet used to declare a column that can
  224.      * store characters in the ASCII character set
  225.      *
  226.      * @param mixed[] $column
  227.      */
  228.     public function getAsciiStringTypeDeclarationSQL(array $column): string
  229.     {
  230.         return $this->getStringTypeDeclarationSQL($column);
  231.     }
  233.     /**
  234.      * Returns the SQL snippet used to declare a VARCHAR column type.
  235.      *
  236.      * @deprecated Use {@link getStringTypeDeclarationSQL()} instead.
  237.      *
  238.      * @param mixed[] $column
  239.      *
  240.      * @return string
  241.      */
  242.     public function getVarcharTypeDeclarationSQL(array $column)
  243.     {
  244.         if (isset($column['length'])) {
  245.             $lengthOmitted = false;
  246.         } else {
  247.             $column['length'] = $this->getVarcharDefaultLength();
  248.             $lengthOmitted    = true;
  249.         }
  251.         $fixed = $column['fixed'] ?? false;
  253.         $maxLength = $fixed
  254.             ? $this->getCharMaxLength()
  255.             : $this->getVarcharMaxLength();
  257.         if ($column['length'] > $maxLength) {
  258.             return $this->getClobTypeDeclarationSQL($column);
  259.         }
  261.         return $this->getVarcharTypeDeclarationSQLSnippet($column['length'], $fixed, $lengthOmitted);
  262.     }
  264.     /**
  265.      * Returns the SQL snippet used to declare a string column type.
  266.      *
  267.      * @param mixed[] $column
  268.      *
  269.      * @return string
  270.      */
  271.     public function getStringTypeDeclarationSQL(array $column)
  272.     {
  273.         return $this->getVarcharTypeDeclarationSQL($column);
  274.     }
  276.     /**
  277.      * Returns the SQL snippet used to declare a BINARY/VARBINARY column type.
  278.      *
  279.      * @param mixed[] $column The column definition.
  280.      *
  281.      * @return string
  282.      */
  283.     public function getBinaryTypeDeclarationSQL(array $column)
  284.     {
  285.         if (isset($column['length'])) {
  286.             $lengthOmitted = false;
  287.         } else {
  288.             $column['length'] = $this->getBinaryDefaultLength();
  289.             $lengthOmitted    = true;
  290.         }
  292.         $fixed = $column['fixed'] ?? false;
  294.         $maxLength = $this->getBinaryMaxLength();
  296.         if ($column['length'] > $maxLength) {
  297.             if ($maxLength > 0) {
  298.                 Deprecation::trigger(
  299.                     'doctrine/dbal',
  300.                     'https://github.com/doctrine/dbal/issues/3187',
  301.                     'Binary column length %d is greater than supported by the platform (%d).'
  302.                         . ' Reduce the column length or use a BLOB column instead.',
  303.                     $column['length'],
  304.                     $maxLength,
  305.                 );
  306.             }
  308.             return $this->getBlobTypeDeclarationSQL($column);
  309.         }
  311.         return $this->getBinaryTypeDeclarationSQLSnippet($column['length'], $fixed, $lengthOmitted);
  312.     }
  314.     /**
  315.      * Returns the SQL snippet to declare a GUID/UUID column.
  316.      *
  317.      * By default this maps directly to a CHAR(36) and only maps to more
  318.      * special datatypes when the underlying databases support this datatype.
  319.      *
  320.      * @param mixed[] $column
  321.      *
  322.      * @return string
  323.      */
  324.     public function getGuidTypeDeclarationSQL(array $column)
  325.     {
  326.         $column['length'] = 36;
  327.         $column['fixed']  = true;
  329.         return $this->getStringTypeDeclarationSQL($column);
  330.     }
  332.     /**
  333.      * Returns the SQL snippet to declare a JSON column.
  334.      *
  335.      * By default this maps directly to a CLOB and only maps to more
  336.      * special datatypes when the underlying databases support this datatype.
  337.      *
  338.      * @param mixed[] $column
  339.      *
  340.      * @return string
  341.      */
  342.     public function getJsonTypeDeclarationSQL(array $column)
  343.     {
  344.         return $this->getClobTypeDeclarationSQL($column);
  345.     }
  347.     /**
  348.      * @param int|false $length
  349.      * @param bool      $fixed
  350.      *
  351.      * @return string
  352.      *
  353.      * @throws Exception If not supported on this platform.
  354.      */
  355.     protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed/*, $lengthOmitted = false*/)
  356.     {
  357.         throw Exception::notSupported('VARCHARs not supported by Platform.');
  358.     }
  360.     /**
  361.      * Returns the SQL snippet used to declare a BINARY/VARBINARY column type.
  362.      *
  363.      * @param int|false $length The length of the column.
  364.      * @param bool      $fixed  Whether the column length is fixed.
  365.      *
  366.      * @return string
  367.      *
  368.      * @throws Exception If not supported on this platform.
  369.      */
  370.     protected function getBinaryTypeDeclarationSQLSnippet($length, $fixed/*, $lengthOmitted = false*/)
  371.     {
  372.         throw Exception::notSupported('BINARY/VARBINARY column types are not supported by this platform.');
  373.     }
  375.     /**
  376.      * Returns the SQL snippet used to declare a CLOB column type.
  377.      *
  378.      * @param mixed[] $column
  379.      *
  380.      * @return string
  381.      */
  382.     abstract public function getClobTypeDeclarationSQL(array $column);
  384.     /**
  385.      * Returns the SQL Snippet used to declare a BLOB column type.
  386.      *
  387.      * @param mixed[] $column
  388.      *
  389.      * @return string
  390.      */
  391.     abstract public function getBlobTypeDeclarationSQL(array $column);
  393.     /**
  394.      * Gets the name of the platform.
  395.      *
  396.      * @deprecated Identify platforms by their class.
  397.      *
  398.      * @return string
  399.      */
  400.     abstract public function getName();
  402.     /**
  403.      * Registers a doctrine type to be used in conjunction with a column type of this platform.
  404.      *
  405.      * @param string $dbType
  406.      * @param string $doctrineType
  407.      *
  408.      * @return void
  409.      *
  410.      * @throws Exception If the type is not found.
  411.      */
  412.     public function registerDoctrineTypeMapping($dbType, $doctrineType)
  413.     {
  414.         if ($this->doctrineTypeMapping === null) {
  415.             $this->initializeAllDoctrineTypeMappings();
  416.         }
  418.         if (! Types\Type::hasType($doctrineType)) {
  419.             throw Exception::typeNotFound($doctrineType);
  420.         }
  422.         $dbType                             = strtolower($dbType);
  423.         $this->doctrineTypeMapping[$dbType] = $doctrineType;
  425.         $doctrineType = Type::getType($doctrineType);
  427.         if (! $doctrineType->requiresSQLCommentHint($this)) {
  428.             return;
  429.         }
  431.         $this->markDoctrineTypeCommented($doctrineType);
  432.     }
  434.     /**
  435.      * Gets the Doctrine type that is mapped for the given database column type.
  436.      *
  437.      * @param string $dbType
  438.      *
  439.      * @return string
  440.      *
  441.      * @throws Exception
  442.      */
  443.     public function getDoctrineTypeMapping($dbType)
  444.     {
  445.         if ($this->doctrineTypeMapping === null) {
  446.             $this->initializeAllDoctrineTypeMappings();
  447.         }
  449.         $dbType = strtolower($dbType);
  451.         if (! isset($this->doctrineTypeMapping[$dbType])) {
  452.             throw new Exception(
  453.                 'Unknown database type ' . $dbType . ' requested, ' . static::class . ' may not support it.',
  454.             );
  455.         }
  457.         return $this->doctrineTypeMapping[$dbType];
  458.     }
  460.     /**
  461.      * Checks if a database type is currently supported by this platform.
  462.      *
  463.      * @param string $dbType
  464.      *
  465.      * @return bool
  466.      */
  467.     public function hasDoctrineTypeMappingFor($dbType)
  468.     {
  469.         if ($this->doctrineTypeMapping === null) {
  470.             $this->initializeAllDoctrineTypeMappings();
  471.         }
  473.         $dbType = strtolower($dbType);
  475.         return isset($this->doctrineTypeMapping[$dbType]);
  476.     }
  478.     /**
  479.      * Initializes the Doctrine Type comments instance variable for in_array() checks.
  480.      *
  481.      * @deprecated This API will be removed in Doctrine DBAL 4.0.
  482.      *
  483.      * @return void
  484.      */
  485.     protected function initializeCommentedDoctrineTypes()
  486.     {
  487.         Deprecation::triggerIfCalledFromOutside(
  488.             'doctrine/dbal',
  489.             'https://github.com/doctrine/dbal/pull/5058',
  490.             '%s is deprecated and will be removed in Doctrine DBAL 4.0.',
  491.             __METHOD__,
  492.         );
  494.         $this->doctrineTypeComments = [];
  496.         foreach (Type::getTypesMap() as $typeName => $className) {
  497.             $type = Type::getType($typeName);
  499.             if (! $type->requiresSQLCommentHint($this)) {
  500.                 continue;
  501.             }
  503.             $this->doctrineTypeComments[] = $typeName;
  504.         }
  505.     }
  507.     /**
  508.      * Is it necessary for the platform to add a parsable type comment to allow reverse engineering the given type?
  509.      *
  510.      * @deprecated Use {@link Type::requiresSQLCommentHint()} instead.
  511.      *
  512.      * @return bool
  513.      */
  514.     public function isCommentedDoctrineType(Type $doctrineType)
  515.     {
  516.         Deprecation::triggerIfCalledFromOutside(
  517.             'doctrine/dbal',
  518.             'https://github.com/doctrine/dbal/pull/5058',
  519.             '%s is deprecated and will be removed in Doctrine DBAL 4.0. Use Type::requiresSQLCommentHint() instead.',
  520.             __METHOD__,
  521.         );
  523.         if ($this->doctrineTypeComments === null) {
  524.             $this->initializeCommentedDoctrineTypes();
  525.         }
  527.         return $doctrineType->requiresSQLCommentHint($this);
  528.     }
  530.     /**
  531.      * Marks this type as to be commented in ALTER TABLE and CREATE TABLE statements.
  532.      *
  533.      * @param string|Type $doctrineType
  534.      *
  535.      * @return void
  536.      */
  537.     public function markDoctrineTypeCommented($doctrineType)
  538.     {
  539.         Deprecation::triggerIfCalledFromOutside(
  540.             'doctrine/dbal',
  541.             'https://github.com/doctrine/dbal/pull/5058',
  542.             '%s is deprecated and will be removed in Doctrine DBAL 4.0. Use Type::requiresSQLCommentHint() instead.',
  543.             __METHOD__,
  544.         );
  546.         if ($this->doctrineTypeComments === null) {
  547.             $this->initializeCommentedDoctrineTypes();
  548.         }
  550.         assert(is_array($this->doctrineTypeComments));
  552.         $this->doctrineTypeComments[] = $doctrineType instanceof Type ? $doctrineType->getName() : $doctrineType;
  553.     }
  555.     /**
  556.      * Gets the comment to append to a column comment that helps parsing this type in reverse engineering.
  557.      *
  558.      * @deprecated This method will be removed without replacement.
  559.      *
  560.      * @return string
  561.      */
  562.     public function getDoctrineTypeComment(Type $doctrineType)
  563.     {
  564.         Deprecation::triggerIfCalledFromOutside(
  565.             'doctrine/dbal',
  566.             'https://github.com/doctrine/dbal/pull/5107',
  567.             '%s is deprecated and will be removed in Doctrine DBAL 4.0.',
  568.             __METHOD__,
  569.         );
  571.         return '(DC2Type:' . $doctrineType->getName() . ')';
  572.     }
  574.     /**
  575.      * Gets the comment of a passed column modified by potential doctrine type comment hints.
  576.      *
  577.      * @deprecated This method will be removed without replacement.
  578.      *
  579.      * @return string|null
  580.      */
  581.     protected function getColumnComment(Column $column)
  582.     {
  583.         Deprecation::triggerIfCalledFromOutside(
  584.             'doctrine/dbal',
  585.             'https://github.com/doctrine/dbal/pull/5107',
  586.             '%s is deprecated and will be removed in Doctrine DBAL 4.0.',
  587.             __METHOD__,
  588.         );
  590.         $comment = $column->getComment();
  592.         if (! $this->disableTypeComments && $column->getType()->requiresSQLCommentHint($this)) {
  593.             $comment .= $this->getDoctrineTypeComment($column->getType());
  594.         }
  596.         return $comment;
  597.     }
  599.     /**
  600.      * Gets the character used for identifier quoting.
  601.      *
  602.      * @deprecated Use {@see quoteIdentifier()} to quote identifiers instead.
  603.      *
  604.      * @return string
  605.      */
  606.     public function getIdentifierQuoteCharacter()
  607.     {
  608.         Deprecation::triggerIfCalledFromOutside(
  609.             'doctrine/dbal',
  610.             'https://github.com/doctrine/dbal/pull/5388',
  611.             'AbstractPlatform::getIdentifierQuoteCharacter() is deprecated. Use quoteIdentifier() instead.',
  612.         );
  614.         return '"';
  615.     }
  617.     /**
  618.      * Gets the string portion that starts an SQL comment.
  619.      *
  620.      * @deprecated
  621.      *
  622.      * @return string
  623.      */
  624.     public function getSqlCommentStartString()
  625.     {
  626.         Deprecation::trigger(
  627.             'doctrine/dbal',
  628.             'https://github.com/doctrine/dbal/pull/4724',
  629.             'AbstractPlatform::getSqlCommentStartString() is deprecated.',
  630.         );
  632.         return '--';
  633.     }
  635.     /**
  636.      * Gets the string portion that ends an SQL comment.
  637.      *
  638.      * @deprecated
  639.      *
  640.      * @return string
  641.      */
  642.     public function getSqlCommentEndString()
  643.     {
  644.         Deprecation::trigger(
  645.             'doctrine/dbal',
  646.             'https://github.com/doctrine/dbal/pull/4724',
  647.             'AbstractPlatform::getSqlCommentEndString() is deprecated.',
  648.         );
  650.         return "\n";
  651.     }
  653.     /**
  654.      * Gets the maximum length of a char column.
  655.      *
  656.      * @deprecated
  657.      */
  658.     public function getCharMaxLength(): int
  659.     {
  660.         Deprecation::triggerIfCalledFromOutside(
  661.             'doctrine/dbal',
  662.             'https://github.com/doctrine/dbal/issues/3263',
  663.             'AbstractPlatform::getCharMaxLength() is deprecated.',
  664.         );
  666.         return $this->getVarcharMaxLength();
  667.     }
  669.     /**
  670.      * Gets the maximum length of a varchar column.
  671.      *
  672.      * @deprecated
  673.      *
  674.      * @return int
  675.      */
  676.     public function getVarcharMaxLength()
  677.     {
  678.         Deprecation::triggerIfCalledFromOutside(
  679.             'doctrine/dbal',
  680.             'https://github.com/doctrine/dbal/issues/3263',
  681.             'AbstractPlatform::getVarcharMaxLength() is deprecated.',
  682.         );
  684.         return 4000;
  685.     }
  687.     /**
  688.      * Gets the default length of a varchar column.
  689.      *
  690.      * @deprecated
  691.      *
  692.      * @return int
  693.      */
  694.     public function getVarcharDefaultLength()
  695.     {
  696.         Deprecation::triggerIfCalledFromOutside(
  697.             'doctrine/dbal',
  698.             'https://github.com/doctrine/dbal/issues/3263',
  699.             'Relying on the default varchar column length is deprecated, specify the length explicitly.',
  700.         );
  702.         return 255;
  703.     }
  705.     /**
  706.      * Gets the maximum length of a binary column.
  707.      *
  708.      * @deprecated
  709.      *
  710.      * @return int
  711.      */
  712.     public function getBinaryMaxLength()
  713.     {
  714.         Deprecation::triggerIfCalledFromOutside(
  715.             'doctrine/dbal',
  716.             'https://github.com/doctrine/dbal/issues/3263',
  717.             'AbstractPlatform::getBinaryMaxLength() is deprecated.',
  718.         );
  720.         return 4000;
  721.     }
  723.     /**
  724.      * Gets the default length of a binary column.
  725.      *
  726.      * @deprecated
  727.      *
  728.      * @return int
  729.      */
  730.     public function getBinaryDefaultLength()
  731.     {
  732.         Deprecation::trigger(
  733.             'doctrine/dbal',
  734.             'https://github.com/doctrine/dbal/issues/3263',
  735.             'Relying on the default binary column length is deprecated, specify the length explicitly.',
  736.         );
  738.         return 255;
  739.     }
  741.     /**
  742.      * Gets all SQL wildcard characters of the platform.
  743.      *
  744.      * @deprecated Use {@see AbstractPlatform::getLikeWildcardCharacters()} instead.
  745.      *
  746.      * @return string[]
  747.      */
  748.     public function getWildcards()
  749.     {
  750.         Deprecation::trigger(
  751.             'doctrine/dbal',
  752.             'https://github.com/doctrine/dbal/pull/4724',
  753.             'AbstractPlatform::getWildcards() is deprecated.'
  754.             . ' Use AbstractPlatform::getLikeWildcardCharacters() instead.',
  755.         );
  757.         return ['%', '_'];
  758.     }
  760.     /**
  761.      * Returns the regular expression operator.
  762.      *
  763.      * @return string
  764.      *
  765.      * @throws Exception If not supported on this platform.
  766.      */
  767.     public function getRegexpExpression()
  768.     {
  769.         throw Exception::notSupported(__METHOD__);
  770.     }
  772.     /**
  773.      * Returns the SQL snippet to get the average value of a column.
  774.      *
  775.      * @deprecated Use AVG() in SQL instead.
  776.      *
  777.      * @param string $column The column to use.
  778.      *
  779.      * @return string Generated SQL including an AVG aggregate function.
  780.      */
  781.     public function getAvgExpression($column)
  782.     {
  783.         Deprecation::trigger(
  784.             'doctrine/dbal',
  785.             'https://github.com/doctrine/dbal/pull/4724',
  786.             'AbstractPlatform::getAvgExpression() is deprecated. Use AVG() in SQL instead.',
  787.         );
  789.         return 'AVG(' . $column . ')';
  790.     }
  792.     /**
  793.      * Returns the SQL snippet to get the number of rows (without a NULL value) of a column.
  794.      *
  795.      * If a '*' is used instead of a column the number of selected rows is returned.
  796.      *
  797.      * @deprecated Use COUNT() in SQL instead.
  798.      *
  799.      * @param string|int $column The column to use.
  800.      *
  801.      * @return string Generated SQL including a COUNT aggregate function.
  802.      */
  803.     public function getCountExpression($column)
  804.     {
  805.         Deprecation::trigger(
  806.             'doctrine/dbal',
  807.             'https://github.com/doctrine/dbal/pull/4724',
  808.             'AbstractPlatform::getCountExpression() is deprecated. Use COUNT() in SQL instead.',
  809.         );
  811.         return 'COUNT(' . $column . ')';
  812.     }
  814.     /**
  815.      * Returns the SQL snippet to get the highest value of a column.
  816.      *
  817.      * @deprecated Use MAX() in SQL instead.
  818.      *
  819.      * @param string $column The column to use.
  820.      *
  821.      * @return string Generated SQL including a MAX aggregate function.
  822.      */
  823.     public function getMaxExpression($column)
  824.     {
  825.         Deprecation::trigger(
  826.             'doctrine/dbal',
  827.             'https://github.com/doctrine/dbal/pull/4724',
  828.             'AbstractPlatform::getMaxExpression() is deprecated. Use MAX() in SQL instead.',
  829.         );
  831.         return 'MAX(' . $column . ')';
  832.     }
  834.     /**
  835.      * Returns the SQL snippet to get the lowest value of a column.
  836.      *
  837.      * @deprecated Use MIN() in SQL instead.
  838.      *
  839.      * @param string $column The column to use.
  840.      *
  841.      * @return string Generated SQL including a MIN aggregate function.
  842.      */
  843.     public function getMinExpression($column)
  844.     {
  845.         Deprecation::trigger(
  846.             'doctrine/dbal',
  847.             'https://github.com/doctrine/dbal/pull/4724',
  848.             'AbstractPlatform::getMinExpression() is deprecated. Use MIN() in SQL instead.',
  849.         );
  851.         return 'MIN(' . $column . ')';
  852.     }
  854.     /**
  855.      * Returns the SQL snippet to get the total sum of a column.
  856.      *
  857.      * @deprecated Use SUM() in SQL instead.
  858.      *
  859.      * @param string $column The column to use.
  860.      *
  861.      * @return string Generated SQL including a SUM aggregate function.
  862.      */
  863.     public function getSumExpression($column)
  864.     {
  865.         Deprecation::trigger(
  866.             'doctrine/dbal',
  867.             'https://github.com/doctrine/dbal/pull/4724',
  868.             'AbstractPlatform::getSumExpression() is deprecated. Use SUM() in SQL instead.',
  869.         );
  871.         return 'SUM(' . $column . ')';
  872.     }
  874.     // scalar functions
  876.     /**
  877.      * Returns the SQL snippet to get the md5 sum of a column.
  878.      *
  879.      * Note: Not SQL92, but common functionality.
  880.      *
  881.      * @deprecated
  882.      *
  883.      * @param string $column
  884.      *
  885.      * @return string
  886.      */
  887.     public function getMd5Expression($column)
  888.     {
  889.         Deprecation::trigger(
  890.             'doctrine/dbal',
  891.             'https://github.com/doctrine/dbal/pull/4724',
  892.             'AbstractPlatform::getMd5Expression() is deprecated.',
  893.         );
  895.         return 'MD5(' . $column . ')';
  896.     }
  898.     /**
  899.      * Returns the SQL snippet to get the length of a text column in characters.
  900.      *
  901.      * @param string $column
  902.      *
  903.      * @return string
  904.      */
  905.     public function getLengthExpression($column)
  906.     {
  907.         return 'LENGTH(' . $column . ')';
  908.     }
  910.     /**
  911.      * Returns the SQL snippet to get the squared value of a column.
  912.      *
  913.      * @deprecated Use SQRT() in SQL instead.
  914.      *
  915.      * @param string $column The column to use.
  916.      *
  917.      * @return string Generated SQL including an SQRT aggregate function.
  918.      */
  919.     public function getSqrtExpression($column)
  920.     {
  921.         Deprecation::trigger(
  922.             'doctrine/dbal',
  923.             'https://github.com/doctrine/dbal/pull/4724',
  924.             'AbstractPlatform::getSqrtExpression() is deprecated. Use SQRT() in SQL instead.',
  925.         );
  927.         return 'SQRT(' . $column . ')';
  928.     }
  930.     /**
  931.      * Returns the SQL snippet to round a numeric column to the number of decimals specified.
  932.      *
  933.      * @deprecated Use ROUND() in SQL instead.
  934.      *
  935.      * @param string     $column
  936.      * @param string|int $decimals
  937.      *
  938.      * @return string
  939.      */
  940.     public function getRoundExpression($column, $decimals = 0)
  941.     {
  942.         Deprecation::trigger(
  943.             'doctrine/dbal',
  944.             'https://github.com/doctrine/dbal/pull/4724',
  945.             'AbstractPlatform::getRoundExpression() is deprecated. Use ROUND() in SQL instead.',
  946.         );
  948.         return 'ROUND(' . $column . ', ' . $decimals . ')';
  949.     }
  951.     /**
  952.      * Returns the SQL snippet to get the remainder of the division operation $expression1 / $expression2.
  953.      *
  954.      * @param string $expression1
  955.      * @param string $expression2
  956.      *
  957.      * @return string
  958.      */
  959.     public function getModExpression($expression1, $expression2)
  960.     {
  961.         return 'MOD(' . $expression1 . ', ' . $expression2 . ')';
  962.     }
  964.     /**
  965.      * Returns the SQL snippet to trim a string.
  966.      *
  967.      * @param string      $str  The expression to apply the trim to.
  968.      * @param int         $mode The position of the trim (leading/trailing/both).
  969.      * @param string|bool $char The char to trim, has to be quoted already. Defaults to space.
  970.      *
  971.      * @return string
  972.      */
  973.     public function getTrimExpression($str, $mode = TrimMode::UNSPECIFIED, $char = false)
  974.     {
  975.         $expression = '';
  977.         switch ($mode) {
  978.             case TrimMode::LEADING:
  979.                 $expression = 'LEADING ';
  980.                 break;
  982.             case TrimMode::TRAILING:
  983.                 $expression = 'TRAILING ';
  984.                 break;
  986.             case TrimMode::BOTH:
  987.                 $expression = 'BOTH ';
  988.                 break;
  989.         }
  991.         if ($char !== false) {
  992.             $expression .= $char . ' ';
  993.         }
  995.         if ($mode !== TrimMode::UNSPECIFIED || $char !== false) {
  996.             $expression .= 'FROM ';
  997.         }
  999.         return 'TRIM(' . $expression . $str . ')';
  1000.     }
  1002.     /**
  1003.      * Returns the SQL snippet to trim trailing space characters from the expression.
  1004.      *
  1005.      * @deprecated Use RTRIM() in SQL instead.
  1006.      *
  1007.      * @param string $str Literal string or column name.
  1008.      *
  1009.      * @return string
  1010.      */
  1011.     public function getRtrimExpression($str)
  1012.     {
  1013.         Deprecation::trigger(
  1014.             'doctrine/dbal',
  1015.             'https://github.com/doctrine/dbal/pull/4724',
  1016.             'AbstractPlatform::getRtrimExpression() is deprecated. Use RTRIM() in SQL instead.',
  1017.         );
  1019.         return 'RTRIM(' . $str . ')';
  1020.     }
  1022.     /**
  1023.      * Returns the SQL snippet to trim leading space characters from the expression.
  1024.      *
  1025.      * @deprecated Use LTRIM() in SQL instead.
  1026.      *
  1027.      * @param string $str Literal string or column name.
  1028.      *
  1029.      * @return string
  1030.      */
  1031.     public function getLtrimExpression($str)
  1032.     {
  1033.         Deprecation::trigger(
  1034.             'doctrine/dbal',
  1035.             'https://github.com/doctrine/dbal/pull/4724',
  1036.             'AbstractPlatform::getLtrimExpression() is deprecated. Use LTRIM() in SQL instead.',
  1037.         );
  1039.         return 'LTRIM(' . $str . ')';
  1040.     }
  1042.     /**
  1043.      * Returns the SQL snippet to change all characters from the expression to uppercase,
  1044.      * according to the current character set mapping.
  1045.      *
  1046.      * @deprecated Use UPPER() in SQL instead.
  1047.      *
  1048.      * @param string $str Literal string or column name.
  1049.      *
  1050.      * @return string
  1051.      */
  1052.     public function getUpperExpression($str)
  1053.     {
  1054.         Deprecation::trigger(
  1055.             'doctrine/dbal',
  1056.             'https://github.com/doctrine/dbal/pull/4724',
  1057.             'AbstractPlatform::getUpperExpression() is deprecated. Use UPPER() in SQL instead.',
  1058.         );
  1060.         return 'UPPER(' . $str . ')';
  1061.     }
  1063.     /**
  1064.      * Returns the SQL snippet to change all characters from the expression to lowercase,
  1065.      * according to the current character set mapping.
  1066.      *
  1067.      * @deprecated Use LOWER() in SQL instead.
  1068.      *
  1069.      * @param string $str Literal string or column name.
  1070.      *
  1071.      * @return string
  1072.      */
  1073.     public function getLowerExpression($str)
  1074.     {
  1075.         Deprecation::trigger(
  1076.             'doctrine/dbal',
  1077.             'https://github.com/doctrine/dbal/pull/4724',
  1078.             'AbstractPlatform::getLowerExpression() is deprecated. Use LOWER() in SQL instead.',
  1079.         );
  1081.         return 'LOWER(' . $str . ')';
  1082.     }
  1084.     /**
  1085.      * Returns the SQL snippet to get the position of the first occurrence of substring $substr in string $str.
  1086.      *
  1087.      * @param string           $str      Literal string.
  1088.      * @param string           $substr   Literal string to find.
  1089.      * @param string|int|false $startPos Position to start at, beginning of string by default.
  1090.      *
  1091.      * @return string
  1092.      *
  1093.      * @throws Exception If not supported on this platform.
  1094.      */
  1095.     public function getLocateExpression($str, $substr, $startPos = false)
  1096.     {
  1097.         throw Exception::notSupported(__METHOD__);
  1098.     }
  1100.     /**
  1101.      * Returns the SQL snippet to get the current system date.
  1102.      *
  1103.      * @deprecated Generate dates within the application.
  1104.      *
  1105.      * @return string
  1106.      */
  1107.     public function getNowExpression()
  1108.     {
  1109.         Deprecation::trigger(
  1110.             'doctrine/dbal',
  1111.             'https://github.com/doctrine/dbal/pull/4753',
  1112.             'AbstractPlatform::getNowExpression() is deprecated. Generate dates within the application.',
  1113.         );
  1115.         return 'NOW()';
  1116.     }
  1118.     /**
  1119.      * Returns a SQL snippet to get a substring inside an SQL statement.
  1120.      *
  1121.      * Note: Not SQL92, but common functionality.
  1122.      *
  1123.      * SQLite only supports the 2 parameter variant of this function.
  1124.      *
  1125.      * @param string          $string An sql string literal or column name/alias.
  1126.      * @param string|int      $start  Where to start the substring portion.
  1127.      * @param string|int|null $length The substring portion length.
  1128.      *
  1129.      * @return string
  1130.      */
  1131.     public function getSubstringExpression($string, $start, $length = null)
  1132.     {
  1133.         if ($length === null) {
  1134.             return 'SUBSTRING(' . $string . ' FROM ' . $start . ')';
  1135.         }
  1137.         return 'SUBSTRING(' . $string . ' FROM ' . $start . ' FOR ' . $length . ')';
  1138.     }
  1140.     /**
  1141.      * Returns a SQL snippet to concatenate the given expressions.
  1142.      *
  1143.      * Accepts an arbitrary number of string parameters. Each parameter must contain an expression.
  1144.      *
  1145.      * @return string
  1146.      */
  1147.     public function getConcatExpression()
  1148.     {
  1149.         return implode(' || ', func_get_args());
  1150.     }
  1152.     /**
  1153.      * Returns the SQL for a logical not.
  1154.      *
  1155.      * Example:
  1156.      * <code>
  1157.      * $q = new Doctrine_Query();
  1158.      * $e = $q->expr;
  1159.      * $q->select('*')->from('table')
  1160.      *   ->where($e->eq('id', $e->not('null'));
  1161.      * </code>
  1162.      *
  1163.      * @deprecated Use NOT() in SQL instead.
  1164.      *
  1165.      * @param string $expression
  1166.      *
  1167.      * @return string The logical expression.
  1168.      */
  1169.     public function getNotExpression($expression)
  1170.     {
  1171.         Deprecation::trigger(
  1172.             'doctrine/dbal',
  1173.             'https://github.com/doctrine/dbal/pull/4724',
  1174.             'AbstractPlatform::getNotExpression() is deprecated. Use NOT() in SQL instead.',
  1175.         );
  1177.         return 'NOT(' . $expression . ')';
  1178.     }
  1180.     /**
  1181.      * Returns the SQL that checks if an expression is null.
  1182.      *
  1183.      * @deprecated Use IS NULL in SQL instead.
  1184.      *
  1185.      * @param string $expression The expression that should be compared to null.
  1186.      *
  1187.      * @return string The logical expression.
  1188.      */
  1189.     public function getIsNullExpression($expression)
  1190.     {
  1191.         Deprecation::trigger(
  1192.             'doctrine/dbal',
  1193.             'https://github.com/doctrine/dbal/pull/4724',
  1194.             'AbstractPlatform::getIsNullExpression() is deprecated. Use IS NULL in SQL instead.',
  1195.         );
  1197.         return $expression . ' IS NULL';
  1198.     }
  1200.     /**
  1201.      * Returns the SQL that checks if an expression is not null.
  1202.      *
  1203.      * @deprecated Use IS NOT NULL in SQL instead.
  1204.      *
  1205.      * @param string $expression The expression that should be compared to null.
  1206.      *
  1207.      * @return string The logical expression.
  1208.      */
  1209.     public function getIsNotNullExpression($expression)
  1210.     {
  1211.         Deprecation::trigger(
  1212.             'doctrine/dbal',
  1213.             'https://github.com/doctrine/dbal/pull/4724',
  1214.             'AbstractPlatform::getIsNotNullExpression() is deprecated. Use IS NOT NULL in SQL instead.',
  1215.         );
  1217.         return $expression . ' IS NOT NULL';
  1218.     }
  1220.     /**
  1221.      * Returns the SQL that checks if an expression evaluates to a value between two values.
  1222.      *
  1223.      * The parameter $expression is checked if it is between $value1 and $value2.
  1224.      *
  1225.      * Note: There is a slight difference in the way BETWEEN works on some databases.
  1226.      * http://www.w3schools.com/sql/sql_between.asp. If you want complete database
  1227.      * independence you should avoid using between().
  1228.      *
  1229.      * @deprecated Use BETWEEN in SQL instead.
  1230.      *
  1231.      * @param string $expression The value to compare to.
  1232.      * @param string $value1     The lower value to compare with.
  1233.      * @param string $value2     The higher value to compare with.
  1234.      *
  1235.      * @return string The logical expression.
  1236.      */
  1237.     public function getBetweenExpression($expression, $value1, $value2)
  1238.     {
  1239.         Deprecation::trigger(
  1240.             'doctrine/dbal',
  1241.             'https://github.com/doctrine/dbal/pull/4724',
  1242.             'AbstractPlatform::getBetweenExpression() is deprecated. Use BETWEEN in SQL instead.',
  1243.         );
  1245.         return $expression . ' BETWEEN ' . $value1 . ' AND ' . $value2;
  1246.     }
  1248.     /**
  1249.      * Returns the SQL to get the arccosine of a value.
  1250.      *
  1251.      * @deprecated Use ACOS() in SQL instead.
  1252.      *
  1253.      * @param string $value
  1254.      *
  1255.      * @return string
  1256.      */
  1257.     public function getAcosExpression($value)
  1258.     {
  1259.         Deprecation::trigger(
  1260.             'doctrine/dbal',
  1261.             'https://github.com/doctrine/dbal/pull/4724',
  1262.             'AbstractPlatform::getAcosExpression() is deprecated. Use ACOS() in SQL instead.',
  1263.         );
  1265.         return 'ACOS(' . $value . ')';
  1266.     }
  1268.     /**
  1269.      * Returns the SQL to get the sine of a value.
  1270.      *
  1271.      * @deprecated Use SIN() in SQL instead.
  1272.      *
  1273.      * @param string $value
  1274.      *
  1275.      * @return string
  1276.      */
  1277.     public function getSinExpression($value)
  1278.     {
  1279.         Deprecation::trigger(
  1280.             'doctrine/dbal',
  1281.             'https://github.com/doctrine/dbal/pull/4724',
  1282.             'AbstractPlatform::getSinExpression() is deprecated. Use SIN() in SQL instead.',
  1283.         );
  1285.         return 'SIN(' . $value . ')';
  1286.     }
  1288.     /**
  1289.      * Returns the SQL to get the PI value.
  1290.      *
  1291.      * @deprecated Use PI() in SQL instead.
  1292.      *
  1293.      * @return string
  1294.      */
  1295.     public function getPiExpression()
  1296.     {
  1297.         Deprecation::trigger(
  1298.             'doctrine/dbal',
  1299.             'https://github.com/doctrine/dbal/pull/4724',
  1300.             'AbstractPlatform::getPiExpression() is deprecated. Use PI() in SQL instead.',
  1301.         );
  1303.         return 'PI()';
  1304.     }
  1306.     /**
  1307.      * Returns the SQL to get the cosine of a value.
  1308.      *
  1309.      * @deprecated Use COS() in SQL instead.
  1310.      *
  1311.      * @param string $value
  1312.      *
  1313.      * @return string
  1314.      */
  1315.     public function getCosExpression($value)
  1316.     {
  1317.         Deprecation::trigger(
  1318.             'doctrine/dbal',
  1319.             'https://github.com/doctrine/dbal/pull/4724',
  1320.             'AbstractPlatform::getCosExpression() is deprecated. Use COS() in SQL instead.',
  1321.         );
  1323.         return 'COS(' . $value . ')';
  1324.     }
  1326.     /**
  1327.      * Returns the SQL to calculate the difference in days between the two passed dates.
  1328.      *
  1329.      * Computes diff = date1 - date2.
  1330.      *
  1331.      * @param string $date1
  1332.      * @param string $date2
  1333.      *
  1334.      * @return string
  1335.      *
  1336.      * @throws Exception If not supported on this platform.
  1337.      */
  1338.     public function getDateDiffExpression($date1, $date2)
  1339.     {
  1340.         throw Exception::notSupported(__METHOD__);
  1341.     }
  1343.     /**
  1344.      * Returns the SQL to add the number of given seconds to a date.
  1345.      *
  1346.      * @param string     $date
  1347.      * @param int|string $seconds
  1348.      *
  1349.      * @return string
  1350.      *
  1351.      * @throws Exception If not supported on this platform.
  1352.      */
  1353.     public function getDateAddSecondsExpression($date, $seconds)
  1354.     {
  1355.         if (is_int($seconds)) {
  1356.             Deprecation::trigger(
  1357.                 'doctrine/dbal',
  1358.                 'https://github.com/doctrine/dbal/pull/3498',
  1359.                 'Passing $seconds as an integer is deprecated. Pass it as a numeric string instead.',
  1360.             );
  1361.         }
  1363.         return $this->getDateArithmeticIntervalExpression($date, '+', $seconds, DateIntervalUnit::SECOND);
  1364.     }
  1366.     /**
  1367.      * Returns the SQL to subtract the number of given seconds from a date.
  1368.      *
  1369.      * @param string     $date
  1370.      * @param int|string $seconds
  1371.      *
  1372.      * @return string
  1373.      *
  1374.      * @throws Exception If not supported on this platform.
  1375.      */
  1376.     public function getDateSubSecondsExpression($date, $seconds)
  1377.     {
  1378.         if (is_int($seconds)) {
  1379.             Deprecation::trigger(
  1380.                 'doctrine/dbal',
  1381.                 'https://github.com/doctrine/dbal/pull/3498',
  1382.                 'Passing $seconds as an integer is deprecated. Pass it as a numeric string instead.',
  1383.             );
  1384.         }
  1386.         return $this->getDateArithmeticIntervalExpression($date, '-', $seconds, DateIntervalUnit::SECOND);
  1387.     }
  1389.     /**
  1390.      * Returns the SQL to add the number of given minutes to a date.
  1391.      *
  1392.      * @param string     $date
  1393.      * @param int|string $minutes
  1394.      *
  1395.      * @return string
  1396.      *
  1397.      * @throws Exception If not supported on this platform.
  1398.      */
  1399.     public function getDateAddMinutesExpression($date, $minutes)
  1400.     {
  1401.         if (is_int($minutes)) {
  1402.             Deprecation::trigger(
  1403.                 'doctrine/dbal',
  1404.                 'https://github.com/doctrine/dbal/pull/3498',
  1405.                 'Passing $minutes as an integer is deprecated. Pass it as a numeric string instead.',
  1406.             );
  1407.         }
  1409.         return $this->getDateArithmeticIntervalExpression($date, '+', $minutes, DateIntervalUnit::MINUTE);
  1410.     }
  1412.     /**
  1413.      * Returns the SQL to subtract the number of given minutes from a date.
  1414.      *
  1415.      * @param string     $date
  1416.      * @param int|string $minutes
  1417.      *
  1418.      * @return string
  1419.      *
  1420.      * @throws Exception If not supported on this platform.
  1421.      */
  1422.     public function getDateSubMinutesExpression($date, $minutes)
  1423.     {
  1424.         if (is_int($minutes)) {
  1425.             Deprecation::trigger(
  1426.                 'doctrine/dbal',
  1427.                 'https://github.com/doctrine/dbal/pull/3498',
  1428.                 'Passing $minutes as an integer is deprecated. Pass it as a numeric string instead.',
  1429.             );
  1430.         }
  1432.         return $this->getDateArithmeticIntervalExpression($date, '-', $minutes, DateIntervalUnit::MINUTE);
  1433.     }
  1435.     /**
  1436.      * Returns the SQL to add the number of given hours to a date.
  1437.      *
  1438.      * @param string     $date
  1439.      * @param int|string $hours
  1440.      *
  1441.      * @return string
  1442.      *
  1443.      * @throws Exception If not supported on this platform.
  1444.      */
  1445.     public function getDateAddHourExpression($date, $hours)
  1446.     {
  1447.         if (is_int($hours)) {
  1448.             Deprecation::trigger(
  1449.                 'doctrine/dbal',
  1450.                 'https://github.com/doctrine/dbal/pull/3498',
  1451.                 'Passing $hours as an integer is deprecated. Pass it as a numeric string instead.',
  1452.             );
  1453.         }
  1455.         return $this->getDateArithmeticIntervalExpression($date, '+', $hours, DateIntervalUnit::HOUR);
  1456.     }
  1458.     /**
  1459.      * Returns the SQL to subtract the number of given hours to a date.
  1460.      *
  1461.      * @param string     $date
  1462.      * @param int|string $hours
  1463.      *
  1464.      * @return string
  1465.      *
  1466.      * @throws Exception If not supported on this platform.
  1467.      */
  1468.     public function getDateSubHourExpression($date, $hours)
  1469.     {
  1470.         if (is_int($hours)) {
  1471.             Deprecation::trigger(
  1472.                 'doctrine/dbal',
  1473.                 'https://github.com/doctrine/dbal/pull/3498',
  1474.                 'Passing $hours as an integer is deprecated. Pass it as a numeric string instead.',
  1475.             );
  1476.         }
  1478.         return $this->getDateArithmeticIntervalExpression($date, '-', $hours, DateIntervalUnit::HOUR);
  1479.     }
  1481.     /**
  1482.      * Returns the SQL to add the number of given days to a date.
  1483.      *
  1484.      * @param string     $date
  1485.      * @param int|string $days
  1486.      *
  1487.      * @return string
  1488.      *
  1489.      * @throws Exception If not supported on this platform.
  1490.      */
  1491.     public function getDateAddDaysExpression($date, $days)
  1492.     {
  1493.         if (is_int($days)) {
  1494.             Deprecation::trigger(
  1495.                 'doctrine/dbal',
  1496.                 'https://github.com/doctrine/dbal/pull/3498',
  1497.                 'Passing $days as an integer is deprecated. Pass it as a numeric string instead.',
  1498.             );
  1499.         }
  1501.         return $this->getDateArithmeticIntervalExpression($date, '+', $days, DateIntervalUnit::DAY);
  1502.     }
  1504.     /**
  1505.      * Returns the SQL to subtract the number of given days to a date.
  1506.      *
  1507.      * @param string     $date
  1508.      * @param int|string $days
  1509.      *
  1510.      * @return string
  1511.      *
  1512.      * @throws Exception If not supported on this platform.
  1513.      */
  1514.     public function getDateSubDaysExpression($date, $days)
  1515.     {
  1516.         if (is_int($days)) {
  1517.             Deprecation::trigger(
  1518.                 'doctrine/dbal',
  1519.                 'https://github.com/doctrine/dbal/pull/3498',
  1520.                 'Passing $days as an integer is deprecated. Pass it as a numeric string instead.',
  1521.             );
  1522.         }
  1524.         return $this->getDateArithmeticIntervalExpression($date, '-', $days, DateIntervalUnit::DAY);
  1525.     }
  1527.     /**
  1528.      * Returns the SQL to add the number of given weeks to a date.
  1529.      *
  1530.      * @param string     $date
  1531.      * @param int|string $weeks
  1532.      *
  1533.      * @return string
  1534.      *
  1535.      * @throws Exception If not supported on this platform.
  1536.      */
  1537.     public function getDateAddWeeksExpression($date, $weeks)
  1538.     {
  1539.         if (is_int($weeks)) {
  1540.             Deprecation::trigger(
  1541.                 'doctrine/dbal',
  1542.                 'https://github.com/doctrine/dbal/pull/3498',
  1543.                 'Passing $weeks as an integer is deprecated. Pass it as a numeric string instead.',
  1544.             );
  1545.         }
  1547.         return $this->getDateArithmeticIntervalExpression($date, '+', $weeks, DateIntervalUnit::WEEK);
  1548.     }
  1550.     /**
  1551.      * Returns the SQL to subtract the number of given weeks from a date.
  1552.      *
  1553.      * @param string     $date
  1554.      * @param int|string $weeks
  1555.      *
  1556.      * @return string
  1557.      *
  1558.      * @throws Exception If not supported on this platform.
  1559.      */
  1560.     public function getDateSubWeeksExpression($date, $weeks)
  1561.     {
  1562.         if (is_int($weeks)) {
  1563.             Deprecation::trigger(
  1564.                 'doctrine/dbal',
  1565.                 'https://github.com/doctrine/dbal/pull/3498',
  1566.                 'Passing $weeks as an integer is deprecated. Pass it as a numeric string instead.',
  1567.             );
  1568.         }
  1570.         return $this->getDateArithmeticIntervalExpression($date, '-', $weeks, DateIntervalUnit::WEEK);
  1571.     }
  1573.     /**
  1574.      * Returns the SQL to add the number of given months to a date.
  1575.      *
  1576.      * @param string     $date
  1577.      * @param int|string $months
  1578.      *
  1579.      * @return string
  1580.      *
  1581.      * @throws Exception If not supported on this platform.
  1582.      */
  1583.     public function getDateAddMonthExpression($date, $months)
  1584.     {
  1585.         if (is_int($months)) {
  1586.             Deprecation::trigger(
  1587.                 'doctrine/dbal',
  1588.                 'https://github.com/doctrine/dbal/pull/3498',
  1589.                 'Passing $months as an integer is deprecated. Pass it as a numeric string instead.',
  1590.             );
  1591.         }
  1593.         return $this->getDateArithmeticIntervalExpression($date, '+', $months, DateIntervalUnit::MONTH);
  1594.     }
  1596.     /**
  1597.      * Returns the SQL to subtract the number of given months to a date.
  1598.      *
  1599.      * @param string     $date
  1600.      * @param int|string $months
  1601.      *
  1602.      * @return string
  1603.      *
  1604.      * @throws Exception If not supported on this platform.
  1605.      */
  1606.     public function getDateSubMonthExpression($date, $months)
  1607.     {
  1608.         if (is_int($months)) {
  1609.             Deprecation::trigger(
  1610.                 'doctrine/dbal',
  1611.                 'https://github.com/doctrine/dbal/pull/3498',
  1612.                 'Passing $months as an integer is deprecated. Pass it as a numeric string instead.',
  1613.             );
  1614.         }
  1616.         return $this->getDateArithmeticIntervalExpression($date, '-', $months, DateIntervalUnit::MONTH);
  1617.     }
  1619.     /**
  1620.      * Returns the SQL to add the number of given quarters to a date.
  1621.      *
  1622.      * @param string     $date
  1623.      * @param int|string $quarters
  1624.      *
  1625.      * @return string
  1626.      *
  1627.      * @throws Exception If not supported on this platform.
  1628.      */
  1629.     public function getDateAddQuartersExpression($date, $quarters)
  1630.     {
  1631.         if (is_int($quarters)) {
  1632.             Deprecation::trigger(
  1633.                 'doctrine/dbal',
  1634.                 'https://github.com/doctrine/dbal/pull/3498',
  1635.                 'Passing $quarters as an integer is deprecated. Pass it as a numeric string instead.',
  1636.             );
  1637.         }
  1639.         return $this->getDateArithmeticIntervalExpression($date, '+', $quarters, DateIntervalUnit::QUARTER);
  1640.     }
  1642.     /**
  1643.      * Returns the SQL to subtract the number of given quarters from a date.
  1644.      *
  1645.      * @param string     $date
  1646.      * @param int|string $quarters
  1647.      *
  1648.      * @return string
  1649.      *
  1650.      * @throws Exception If not supported on this platform.
  1651.      */
  1652.     public function getDateSubQuartersExpression($date, $quarters)
  1653.     {
  1654.         if (is_int($quarters)) {
  1655.             Deprecation::trigger(
  1656.                 'doctrine/dbal',
  1657.                 'https://github.com/doctrine/dbal/pull/3498',
  1658.                 'Passing $quarters as an integer is deprecated. Pass it as a numeric string instead.',
  1659.             );
  1660.         }
  1662.         return $this->getDateArithmeticIntervalExpression($date, '-', $quarters, DateIntervalUnit::QUARTER);
  1663.     }
  1665.     /**
  1666.      * Returns the SQL to add the number of given years to a date.
  1667.      *
  1668.      * @param string     $date
  1669.      * @param int|string $years
  1670.      *
  1671.      * @return string
  1672.      *
  1673.      * @throws Exception If not supported on this platform.
  1674.      */
  1675.     public function getDateAddYearsExpression($date, $years)
  1676.     {
  1677.         if (is_int($years)) {
  1678.             Deprecation::trigger(
  1679.                 'doctrine/dbal',
  1680.                 'https://github.com/doctrine/dbal/pull/3498',
  1681.                 'Passing $years as an integer is deprecated. Pass it as a numeric string instead.',
  1682.             );
  1683.         }
  1685.         return $this->getDateArithmeticIntervalExpression($date, '+', $years, DateIntervalUnit::YEAR);
  1686.     }
  1688.     /**
  1689.      * Returns the SQL to subtract the number of given years from a date.
  1690.      *
  1691.      * @param string     $date
  1692.      * @param int|string $years
  1693.      *
  1694.      * @return string
  1695.      *
  1696.      * @throws Exception If not supported on this platform.
  1697.      */
  1698.     public function getDateSubYearsExpression($date, $years)
  1699.     {
  1700.         if (is_int($years)) {
  1701.             Deprecation::trigger(
  1702.                 'doctrine/dbal',
  1703.                 'https://github.com/doctrine/dbal/pull/3498',
  1704.                 'Passing $years as an integer is deprecated. Pass it as a numeric string instead.',
  1705.             );
  1706.         }
  1708.         return $this->getDateArithmeticIntervalExpression($date, '-', $years, DateIntervalUnit::YEAR);
  1709.     }
  1711.     /**
  1712.      * Returns the SQL for a date arithmetic expression.
  1713.      *
  1714.      * @param string     $date     The column or literal representing a date
  1715.      *                                     to perform the arithmetic operation on.
  1716.      * @param string     $operator The arithmetic operator (+ or -).
  1717.      * @param int|string $interval The interval that shall be calculated into the date.
  1718.      * @param string     $unit     The unit of the interval that shall be calculated into the date.
  1719.      *                                     One of the {@see DateIntervalUnit} constants.
  1720.      *
  1721.      * @return string
  1722.      *
  1723.      * @throws Exception If not supported on this platform.
  1724.      */
  1725.     protected function getDateArithmeticIntervalExpression($date, $operator, $interval, $unit)
  1726.     {
  1727.         throw Exception::notSupported(__METHOD__);
  1728.     }
  1730.     /**
  1731.      * Generates the SQL expression which represents the given date interval multiplied by a number
  1732.      *
  1733.      * @param string $interval   SQL expression describing the interval value
  1734.      * @param int    $multiplier Interval multiplier
  1735.      */
  1736.     protected function multiplyInterval(string $interval, int $multiplier): string
  1737.     {
  1738.         return sprintf('(%s * %d)', $interval, $multiplier);
  1739.     }
  1741.     /**
  1742.      * Returns the SQL bit AND comparison expression.
  1743.      *
  1744.      * @param string $value1
  1745.      * @param string $value2
  1746.      *
  1747.      * @return string
  1748.      */
  1749.     public function getBitAndComparisonExpression($value1, $value2)
  1750.     {
  1751.         return '(' . $value1 . ' & ' . $value2 . ')';
  1752.     }
  1754.     /**
  1755.      * Returns the SQL bit OR comparison expression.
  1756.      *
  1757.      * @param string $value1
  1758.      * @param string $value2
  1759.      *
  1760.      * @return string
  1761.      */
  1762.     public function getBitOrComparisonExpression($value1, $value2)
  1763.     {
  1764.         return '(' . $value1 . ' | ' . $value2 . ')';
  1765.     }
  1767.     /**
  1768.      * Returns the SQL expression which represents the currently selected database.
  1769.      */
  1770.     abstract public function getCurrentDatabaseExpression(): string;
  1772.     /**
  1773.      * Returns the FOR UPDATE expression.
  1774.      *
  1775.      * @deprecated This API is not portable. Use {@link QueryBuilder::forUpdate()}` instead.
  1776.      *
  1777.      * @return string
  1778.      */
  1779.     public function getForUpdateSQL()
  1780.     {
  1781.         Deprecation::triggerIfCalledFromOutside(
  1782.             'doctrine/dbal',
  1783.             'https://github.com/doctrine/dbal/pull/6191',
  1784.             '%s is deprecated as non-portable.',
  1785.             __METHOD__,
  1786.         );
  1788.         return 'FOR UPDATE';
  1789.     }
  1791.     /**
  1792.      * Honors that some SQL vendors such as MsSql use table hints for locking instead of the
  1793.      * ANSI SQL FOR UPDATE specification.
  1794.      *
  1795.      * @param string $fromClause The FROM clause to append the hint for the given lock mode to
  1796.      * @param int    $lockMode   One of the Doctrine\DBAL\LockMode::* constants
  1797.      * @psalm-param LockMode::* $lockMode
  1798.      */
  1799.     public function appendLockHint(string $fromClause, int $lockMode): string
  1800.     {
  1801.         switch ($lockMode) {
  1802.             case LockMode::NONE:
  1803.             case LockMode::OPTIMISTIC:
  1804.             case LockMode::PESSIMISTIC_READ:
  1805.             case LockMode::PESSIMISTIC_WRITE:
  1806.                 return $fromClause;
  1808.             default:
  1809.                 throw InvalidLockMode::fromLockMode($lockMode);
  1810.         }
  1811.     }
  1813.     /**
  1814.      * Returns the SQL snippet to append to any SELECT statement which locks rows in shared read lock.
  1815.      *
  1816.      * This defaults to the ANSI SQL "FOR UPDATE", which is an exclusive lock (Write). Some database
  1817.      * vendors allow to lighten this constraint up to be a real read lock.
  1818.      *
  1819.      * @deprecated This API is not portable.
  1820.      *
  1821.      * @return string
  1822.      */
  1823.     public function getReadLockSQL()
  1824.     {
  1825.         Deprecation::trigger(
  1826.             'doctrine/dbal',
  1827.             'https://github.com/doctrine/dbal/pull/6191',
  1828.             '%s is deprecated as non-portable.',
  1829.             __METHOD__,
  1830.         );
  1832.         return $this->getForUpdateSQL();
  1833.     }
  1835.     /**
  1836.      * Returns the SQL snippet to append to any SELECT statement which obtains an exclusive lock on the rows.
  1837.      *
  1838.      * The semantics of this lock mode should equal the SELECT .. FOR UPDATE of the ANSI SQL standard.
  1839.      *
  1840.      * @deprecated This API is not portable.
  1841.      *
  1842.      * @return string
  1843.      */
  1844.     public function getWriteLockSQL()
  1845.     {
  1846.         Deprecation::trigger(
  1847.             'doctrine/dbal',
  1848.             'https://github.com/doctrine/dbal/pull/6191',
  1849.             '%s is deprecated as non-portable.',
  1850.             __METHOD__,
  1851.         );
  1853.         return $this->getForUpdateSQL();
  1854.     }
  1856.     /**
  1857.      * Returns the SQL snippet to drop an existing table.
  1858.      *
  1859.      * @param Table|string $table
  1860.      *
  1861.      * @return string
  1862.      *
  1863.      * @throws InvalidArgumentException
  1864.      */
  1865.     public function getDropTableSQL($table)
  1866.     {
  1867.         $tableArg = $table;
  1869.         if ($table instanceof Table) {
  1870.             Deprecation::trigger(
  1871.                 'doctrine/dbal',
  1872.                 'https://github.com/doctrine/dbal/issues/4798',
  1873.                 'Passing $table as a Table object to %s is deprecated. Pass it as a quoted name instead.',
  1874.                 __METHOD__,
  1875.             );
  1877.             $table = $table->getQuotedName($this);
  1878.         }
  1880.         if (! is_string($table)) {
  1881.             throw new InvalidArgumentException(
  1882.                 __METHOD__ . '() expects $table parameter to be string or ' . Table::class . '.',
  1883.             );
  1884.         }
  1886.         if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaDropTable)) {
  1887.             Deprecation::trigger(
  1888.                 'doctrine/dbal',
  1889.                 'https://github.com/doctrine/dbal/issues/5784',
  1890.                 'Subscribing to %s events is deprecated.',
  1891.                 Events::onSchemaDropTable,
  1892.             );
  1894.             $eventArgs = new SchemaDropTableEventArgs($tableArg, $this);
  1895.             $this->_eventManager->dispatchEvent(Events::onSchemaDropTable, $eventArgs);
  1897.             if ($eventArgs->isDefaultPrevented()) {
  1898.                 $sql = $eventArgs->getSql();
  1900.                 if ($sql === null) {
  1901.                     throw new UnexpectedValueException('Default implementation of DROP TABLE was overridden with NULL');
  1902.                 }
  1904.                 return $sql;
  1905.             }
  1906.         }
  1908.         return 'DROP TABLE ' . $table;
  1909.     }
  1911.     /**
  1912.      * Returns the SQL to safely drop a temporary table WITHOUT implicitly committing an open transaction.
  1913.      *
  1914.      * @param Table|string $table
  1915.      *
  1916.      * @return string
  1917.      */
  1918.     public function getDropTemporaryTableSQL($table)
  1919.     {
  1920.         if ($table instanceof Table) {
  1921.             Deprecation::trigger(
  1922.                 'doctrine/dbal',
  1923.                 'https://github.com/doctrine/dbal/issues/4798',
  1924.                 'Passing $table as a Table object to %s is deprecated. Pass it as a quoted name instead.',
  1925.                 __METHOD__,
  1926.             );
  1928.             $table = $table->getQuotedName($this);
  1929.         }
  1931.         return $this->getDropTableSQL($table);
  1932.     }
  1934.     /**
  1935.      * Returns the SQL to drop an index from a table.
  1936.      *
  1937.      * @param Index|string      $index
  1938.      * @param Table|string|null $table
  1939.      *
  1940.      * @return string
  1941.      *
  1942.      * @throws InvalidArgumentException
  1943.      */
  1944.     public function getDropIndexSQL($index, $table = null)
  1945.     {
  1946.         if ($index instanceof Index) {
  1947.             Deprecation::trigger(
  1948.                 'doctrine/dbal',
  1949.                 'https://github.com/doctrine/dbal/issues/4798',
  1950.                 'Passing $index as an Index object to %s is deprecated. Pass it as a quoted name instead.',
  1951.                 __METHOD__,
  1952.             );
  1954.             $index = $index->getQuotedName($this);
  1955.         } elseif (! is_string($index)) {
  1956.             throw new InvalidArgumentException(
  1957.                 __METHOD__ . '() expects $index parameter to be string or ' . Index::class . '.',
  1958.             );
  1959.         }
  1961.         return 'DROP INDEX ' . $index;
  1962.     }
  1964.     /**
  1965.      * Returns the SQL to drop a constraint.
  1966.      *
  1967.      * @internal The method should be only used from within the {@see AbstractPlatform} class hierarchy.
  1968.      *
  1969.      * @param Constraint|string $constraint
  1970.      * @param Table|string      $table
  1971.      *
  1972.      * @return string
  1973.      */
  1974.     public function getDropConstraintSQL($constraint, $table)
  1975.     {
  1976.         if ($constraint instanceof Constraint) {
  1977.             Deprecation::trigger(
  1978.                 'doctrine/dbal',
  1979.                 'https://github.com/doctrine/dbal/issues/4798',
  1980.                 'Passing $constraint as a Constraint object to %s is deprecated. Pass it as a quoted name instead.',
  1981.                 __METHOD__,
  1982.             );
  1983.         } else {
  1984.             $constraint = new Identifier($constraint);
  1985.         }
  1987.         if ($table instanceof Table) {
  1988.             Deprecation::trigger(
  1989.                 'doctrine/dbal',
  1990.                 'https://github.com/doctrine/dbal/issues/4798',
  1991.                 'Passing $table as a Table object to %s is deprecated. Pass it as a quoted name instead.',
  1992.                 __METHOD__,
  1993.             );
  1994.         } else {
  1995.             $table = new Identifier($table);
  1996.         }
  1998.         $constraint = $constraint->getQuotedName($this);
  1999.         $table      = $table->getQuotedName($this);
  2001.         return 'ALTER TABLE ' . $table . ' DROP CONSTRAINT ' . $constraint;
  2002.     }
  2004.     /**
  2005.      * Returns the SQL to drop a foreign key.
  2006.      *
  2007.      * @param ForeignKeyConstraint|string $foreignKey
  2008.      * @param Table|string                $table
  2009.      *
  2010.      * @return string
  2011.      */
  2012.     public function getDropForeignKeySQL($foreignKey, $table)
  2013.     {
  2014.         if ($foreignKey instanceof ForeignKeyConstraint) {
  2015.             Deprecation::trigger(
  2016.                 'doctrine/dbal',
  2017.                 'https://github.com/doctrine/dbal/issues/4798',
  2018.                 'Passing $foreignKey as a ForeignKeyConstraint object to %s is deprecated.'
  2019.                     . ' Pass it as a quoted name instead.',
  2020.                 __METHOD__,
  2021.             );
  2022.         } else {
  2023.             $foreignKey = new Identifier($foreignKey);
  2024.         }
  2026.         if ($table instanceof Table) {
  2027.             Deprecation::trigger(
  2028.                 'doctrine/dbal',
  2029.                 'https://github.com/doctrine/dbal/issues/4798',
  2030.                 'Passing $table as a Table object to %s is deprecated. Pass it as a quoted name instead.',
  2031.                 __METHOD__,
  2032.             );
  2033.         } else {
  2034.             $table = new Identifier($table);
  2035.         }
  2037.         $foreignKey = $foreignKey->getQuotedName($this);
  2038.         $table      = $table->getQuotedName($this);
  2040.         return 'ALTER TABLE ' . $table . ' DROP FOREIGN KEY ' . $foreignKey;
  2041.     }
  2043.     /**
  2044.      * Returns the SQL to drop a unique constraint.
  2045.      */
  2046.     public function getDropUniqueConstraintSQL(string $name, string $tableName): string
  2047.     {
  2048.         return $this->getDropConstraintSQL($name, $tableName);
  2049.     }
  2051.     /**
  2052.      * Returns the SQL statement(s) to create a table with the specified name, columns and constraints
  2053.      * on this platform.
  2054.      *
  2055.      * @param int $createFlags
  2056.      * @psalm-param int-mask-of<self::CREATE_*> $createFlags
  2057.      *
  2058.      * @return list<string> The list of SQL statements.
  2059.      *
  2060.      * @throws Exception
  2061.      * @throws InvalidArgumentException
  2062.      */
  2063.     public function getCreateTableSQL(Table $table, $createFlags = self::CREATE_INDEXES)
  2064.     {
  2065.         if (! is_int($createFlags)) {
  2066.             throw new InvalidArgumentException(
  2067.                 'Second argument of AbstractPlatform::getCreateTableSQL() has to be integer.',
  2068.             );
  2069.         }
  2071.         if (($createFlags & self::CREATE_INDEXES) === 0) {
  2072.             Deprecation::trigger(
  2073.                 'doctrine/dbal',
  2074.                 'https://github.com/doctrine/dbal/pull/5416',
  2075.                 'Unsetting the CREATE_INDEXES flag in AbstractPlatform::getCreateTableSQL() is deprecated.',
  2076.             );
  2077.         }
  2079.         if (($createFlags & self::CREATE_FOREIGNKEYS) === 0) {
  2080.             Deprecation::trigger(
  2081.                 'doctrine/dbal',
  2082.                 'https://github.com/doctrine/dbal/pull/5416',
  2083.                 'Not setting the CREATE_FOREIGNKEYS flag in AbstractPlatform::getCreateTableSQL()'
  2084.                     . ' is deprecated. In order to build the statements that create multiple tables'
  2085.                     . ' referencing each other via foreign keys, use AbstractPlatform::getCreateTablesSQL().',
  2086.             );
  2087.         }
  2089.         return $this->buildCreateTableSQL(
  2090.             $table,
  2091.             ($createFlags & self::CREATE_INDEXES) > 0,
  2092.             ($createFlags & self::CREATE_FOREIGNKEYS) > 0,
  2093.         );
  2094.     }
  2096.     public function createSelectSQLBuilder(): SelectSQLBuilder
  2097.     {
  2098.         return new DefaultSelectSQLBuilder($this, 'FOR UPDATE', 'SKIP LOCKED');
  2099.     }
  2101.     /**
  2102.      * @internal
  2103.      *
  2104.      * @return list<string>
  2105.      *
  2106.      * @throws Exception
  2107.      */
  2108.     final protected function getCreateTableWithoutForeignKeysSQL(Table $table): array
  2109.     {
  2110.         return $this->buildCreateTableSQL($table, true, false);
  2111.     }
  2113.     /**
  2114.      * @return list<string>
  2115.      *
  2116.      * @throws Exception
  2117.      */
  2118.     private function buildCreateTableSQL(Table $table, bool $createIndexes, bool $createForeignKeys): array
  2119.     {
  2120.         if (count($table->getColumns()) === 0) {
  2121.             throw Exception::noColumnsSpecifiedForTable($table->getName());
  2122.         }
  2124.         $tableName                    = $table->getQuotedName($this);
  2125.         $options                      = $table->getOptions();
  2126.         $options['uniqueConstraints'] = [];
  2127.         $options['indexes']           = [];
  2128.         $options['primary']           = [];
  2130.         if ($createIndexes) {
  2131.             foreach ($table->getIndexes() as $index) {
  2132.                 if (! $index->isPrimary()) {
  2133.                     $options['indexes'][$index->getQuotedName($this)] = $index;
  2135.                     continue;
  2136.                 }
  2138.                 $options['primary']       = $index->getQuotedColumns($this);
  2139.                 $options['primary_index'] = $index;
  2140.             }
  2142.             foreach ($table->getUniqueConstraints() as $uniqueConstraint) {
  2143.                 $options['uniqueConstraints'][$uniqueConstraint->getQuotedName($this)] = $uniqueConstraint;
  2144.             }
  2145.         }
  2147.         if ($createForeignKeys) {
  2148.             $options['foreignKeys'] = [];
  2150.             foreach ($table->getForeignKeys() as $fkConstraint) {
  2151.                 $options['foreignKeys'][] = $fkConstraint;
  2152.             }
  2153.         }
  2155.         $columnSql = [];
  2156.         $columns   = [];
  2158.         foreach ($table->getColumns() as $column) {
  2159.             if (
  2160.                 $this->_eventManager !== null
  2161.                 && $this->_eventManager->hasListeners(Events::onSchemaCreateTableColumn)
  2162.             ) {
  2163.                 Deprecation::trigger(
  2164.                     'doctrine/dbal',
  2165.                     'https://github.com/doctrine/dbal/issues/5784',
  2166.                     'Subscribing to %s events is deprecated.',
  2167.                     Events::onSchemaCreateTableColumn,
  2168.                 );
  2170.                 $eventArgs = new SchemaCreateTableColumnEventArgs($column, $table, $this);
  2172.                 $this->_eventManager->dispatchEvent(Events::onSchemaCreateTableColumn, $eventArgs);
  2174.                 $columnSql = array_merge($columnSql, $eventArgs->getSql());
  2176.                 if ($eventArgs->isDefaultPrevented()) {
  2177.                     continue;
  2178.                 }
  2179.             }
  2181.             $columnData = $this->columnToArray($column);
  2183.             if (in_array($column->getName(), $options['primary'], true)) {
  2184.                 $columnData['primary'] = true;
  2185.             }
  2187.             $columns[$columnData['name']] = $columnData;
  2188.         }
  2190.         if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaCreateTable)) {
  2191.             Deprecation::trigger(
  2192.                 'doctrine/dbal',
  2193.                 'https://github.com/doctrine/dbal/issues/5784',
  2194.                 'Subscribing to %s events is deprecated.',
  2195.                 Events::onSchemaCreateTable,
  2196.             );
  2198.             $eventArgs = new SchemaCreateTableEventArgs($table, $columns, $options, $this);
  2200.             $this->_eventManager->dispatchEvent(Events::onSchemaCreateTable, $eventArgs);
  2202.             if ($eventArgs->isDefaultPrevented()) {
  2203.                 return array_merge($eventArgs->getSql(), $columnSql);
  2204.             }
  2205.         }
  2207.         $sql = $this->_getCreateTableSQL($tableName, $columns, $options);
  2209.         if ($this->supportsCommentOnStatement()) {
  2210.             if ($table->hasOption('comment')) {
  2211.                 $sql[] = $this->getCommentOnTableSQL($tableName, $table->getOption('comment'));
  2212.             }
  2214.             foreach ($table->getColumns() as $column) {
  2215.                 $comment = $this->getColumnComment($column);
  2217.                 if ($comment === null || $comment === '') {
  2218.                     continue;
  2219.                 }
  2221.                 $sql[] = $this->getCommentOnColumnSQL($tableName, $column->getQuotedName($this), $comment);
  2222.             }
  2223.         }
  2225.         return array_merge($sql, $columnSql);
  2226.     }
  2228.     /**
  2229.      * @param list<Table> $tables
  2230.      *
  2231.      * @return list<string>
  2232.      *
  2233.      * @throws Exception
  2234.      */
  2235.     public function getCreateTablesSQL(array $tables): array
  2236.     {
  2237.         $sql = [];
  2239.         foreach ($tables as $table) {
  2240.             $sql = array_merge($sql, $this->getCreateTableWithoutForeignKeysSQL($table));
  2241.         }
  2243.         foreach ($tables as $table) {
  2244.             foreach ($table->getForeignKeys() as $foreignKey) {
  2245.                 $sql[] = $this->getCreateForeignKeySQL(
  2246.                     $foreignKey,
  2247.                     $table->getQuotedName($this),
  2248.                 );
  2249.             }
  2250.         }
  2252.         return $sql;
  2253.     }
  2255.     /**
  2256.      * @param list<Table> $tables
  2257.      *
  2258.      * @return list<string>
  2259.      */
  2260.     public function getDropTablesSQL(array $tables): array
  2261.     {
  2262.         $sql = [];
  2264.         foreach ($tables as $table) {
  2265.             foreach ($table->getForeignKeys() as $foreignKey) {
  2266.                 $sql[] = $this->getDropForeignKeySQL(
  2267.                     $foreignKey->getQuotedName($this),
  2268.                     $table->getQuotedName($this),
  2269.                 );
  2270.             }
  2271.         }
  2273.         foreach ($tables as $table) {
  2274.             $sql[] = $this->getDropTableSQL($table->getQuotedName($this));
  2275.         }
  2277.         return $sql;
  2278.     }
  2280.     protected function getCommentOnTableSQL(string $tableName, ?string $comment): string
  2281.     {
  2282.         $tableName = new Identifier($tableName);
  2284.         return sprintf(
  2285.             'COMMENT ON TABLE %s IS %s',
  2286.             $tableName->getQuotedName($this),
  2287.             $this->quoteStringLiteral((string) $comment),
  2288.         );
  2289.     }
  2291.     /**
  2292.      * @param string      $tableName
  2293.      * @param string      $columnName
  2294.      * @param string|null $comment
  2295.      *
  2296.      * @return string
  2297.      */
  2298.     public function getCommentOnColumnSQL($tableName, $columnName, $comment)
  2299.     {
  2300.         $tableName  = new Identifier($tableName);
  2301.         $columnName = new Identifier($columnName);
  2303.         return sprintf(
  2304.             'COMMENT ON COLUMN %s.%s IS %s',
  2305.             $tableName->getQuotedName($this),
  2306.             $columnName->getQuotedName($this),
  2307.             $this->quoteStringLiteral((string) $comment),
  2308.         );
  2309.     }
  2311.     /**
  2312.      * Returns the SQL to create inline comment on a column.
  2313.      *
  2314.      * @param string $comment
  2315.      *
  2316.      * @return string
  2317.      *
  2318.      * @throws Exception If not supported on this platform.
  2319.      */
  2320.     public function getInlineColumnCommentSQL($comment)
  2321.     {
  2322.         if (! $this->supportsInlineColumnComments()) {
  2323.             throw Exception::notSupported(__METHOD__);
  2324.         }
  2326.         return 'COMMENT ' . $this->quoteStringLiteral($comment);
  2327.     }
  2329.     /**
  2330.      * Returns the SQL used to create a table.
  2331.      *
  2332.      * @param string    $name
  2333.      * @param mixed[][] $columns
  2334.      * @param mixed[]   $options
  2335.      *
  2336.      * @return string[]
  2337.      */
  2338.     protected function _getCreateTableSQL($name, array $columns, array $options = [])
  2339.     {
  2340.         $columnListSql = $this->getColumnDeclarationListSQL($columns);
  2342.         if (isset($options['uniqueConstraints']) && ! empty($options['uniqueConstraints'])) {
  2343.             foreach ($options['uniqueConstraints'] as $index => $definition) {
  2344.                 $columnListSql .= ', ' . $this->getUniqueConstraintDeclarationSQL($index, $definition);
  2345.             }
  2346.         }
  2348.         if (isset($options['primary']) && ! empty($options['primary'])) {
  2349.             $columnListSql .= ', PRIMARY KEY(' . implode(', ', array_unique(array_values($options['primary']))) . ')';
  2350.         }
  2352.         if (isset($options['indexes']) && ! empty($options['indexes'])) {
  2353.             foreach ($options['indexes'] as $index => $definition) {
  2354.                 $columnListSql .= ', ' . $this->getIndexDeclarationSQL($index, $definition);
  2355.             }
  2356.         }
  2358.         $query = 'CREATE TABLE ' . $name . ' (' . $columnListSql;
  2359.         $check = $this->getCheckDeclarationSQL($columns);
  2361.         if (! empty($check)) {
  2362.             $query .= ', ' . $check;
  2363.         }
  2365.         $query .= ')';
  2367.         $sql = [$query];
  2369.         if (isset($options['foreignKeys'])) {
  2370.             foreach ($options['foreignKeys'] as $definition) {
  2371.                 $sql[] = $this->getCreateForeignKeySQL($definition, $name);
  2372.             }
  2373.         }
  2375.         return $sql;
  2376.     }
  2378.     /** @return string */
  2379.     public function getCreateTemporaryTableSnippetSQL()
  2380.     {
  2381.         return 'CREATE TEMPORARY TABLE';
  2382.     }
  2384.     /**
  2385.      * Generates SQL statements that can be used to apply the diff.
  2386.      *
  2387.      * @return list<string>
  2388.      */
  2389.     public function getAlterSchemaSQL(SchemaDiff $diff): array
  2390.     {
  2391.         return $diff->toSql($this);
  2392.     }
  2394.     /**
  2395.      * Returns the SQL to create a sequence on this platform.
  2396.      *
  2397.      * @return string
  2398.      *
  2399.      * @throws Exception If not supported on this platform.
  2400.      */
  2401.     public function getCreateSequenceSQL(Sequence $sequence)
  2402.     {
  2403.         throw Exception::notSupported(__METHOD__);
  2404.     }
  2406.     /**
  2407.      * Returns the SQL to change a sequence on this platform.
  2408.      *
  2409.      * @return string
  2410.      *
  2411.      * @throws Exception If not supported on this platform.
  2412.      */
  2413.     public function getAlterSequenceSQL(Sequence $sequence)
  2414.     {
  2415.         throw Exception::notSupported(__METHOD__);
  2416.     }
  2418.     /**
  2419.      * Returns the SQL snippet to drop an existing sequence.
  2420.      *
  2421.      * @param Sequence|string $sequence
  2422.      *
  2423.      * @return string
  2424.      *
  2425.      * @throws Exception If not supported on this platform.
  2426.      */
  2427.     public function getDropSequenceSQL($sequence)
  2428.     {
  2429.         if (! $this->supportsSequences()) {
  2430.             throw Exception::notSupported(__METHOD__);
  2431.         }
  2433.         if ($sequence instanceof Sequence) {
  2434.             Deprecation::trigger(
  2435.                 'doctrine/dbal',
  2436.                 'https://github.com/doctrine/dbal/issues/4798',
  2437.                 'Passing $sequence as a Sequence object to %s is deprecated. Pass it as a quoted name instead.',
  2438.                 __METHOD__,
  2439.             );
  2441.             $sequence = $sequence->getQuotedName($this);
  2442.         }
  2444.         return 'DROP SEQUENCE ' . $sequence;
  2445.     }
  2447.     /**
  2448.      * Returns the SQL to create a constraint on a table on this platform.
  2449.      *
  2450.      * @deprecated Use {@see getCreateIndexSQL()}, {@see getCreateForeignKeySQL()}
  2451.      *             or {@see getCreateUniqueConstraintSQL()} instead.
  2452.      *
  2453.      * @param Table|string $table
  2454.      *
  2455.      * @return string
  2456.      *
  2457.      * @throws InvalidArgumentException
  2458.      */
  2459.     public function getCreateConstraintSQL(Constraint $constraint, $table)
  2460.     {
  2461.         if ($table instanceof Table) {
  2462.             Deprecation::trigger(
  2463.                 'doctrine/dbal',
  2464.                 'https://github.com/doctrine/dbal/issues/4798',
  2465.                 'Passing $table as a Table object to %s is deprecated. Pass it as a quoted name instead.',
  2466.                 __METHOD__,
  2467.             );
  2469.             $table = $table->getQuotedName($this);
  2470.         }
  2472.         $query = 'ALTER TABLE ' . $table . ' ADD CONSTRAINT ' . $constraint->getQuotedName($this);
  2474.         $columnList = '(' . implode(', ', $constraint->getQuotedColumns($this)) . ')';
  2476.         $referencesClause = '';
  2477.         if ($constraint instanceof Index) {
  2478.             if ($constraint->isPrimary()) {
  2479.                 $query .= ' PRIMARY KEY';
  2480.             } elseif ($constraint->isUnique()) {
  2481.                 $query .= ' UNIQUE';
  2482.             } else {
  2483.                 throw new InvalidArgumentException(
  2484.                     'Can only create primary or unique constraints, no common indexes with getCreateConstraintSQL().',
  2485.                 );
  2486.             }
  2487.         } elseif ($constraint instanceof UniqueConstraint) {
  2488.             $query .= ' UNIQUE';
  2489.         } elseif ($constraint instanceof ForeignKeyConstraint) {
  2490.             $query .= ' FOREIGN KEY';
  2492.             $referencesClause = ' REFERENCES ' . $constraint->getQuotedForeignTableName($this) .
  2493.                 ' (' . implode(', ', $constraint->getQuotedForeignColumns($this)) . ')';
  2494.         }
  2496.         $query .= ' ' . $columnList . $referencesClause;
  2498.         return $query;
  2499.     }
  2501.     /**
  2502.      * Returns the SQL to create an index on a table on this platform.
  2503.      *
  2504.      * @param Table|string $table The name of the table on which the index is to be created.
  2505.      *
  2506.      * @return string
  2507.      *
  2508.      * @throws InvalidArgumentException
  2509.      */
  2510.     public function getCreateIndexSQL(Index $index, $table)
  2511.     {
  2512.         if ($table instanceof Table) {
  2513.             Deprecation::trigger(
  2514.                 'doctrine/dbal',
  2515.                 'https://github.com/doctrine/dbal/issues/4798',
  2516.                 'Passing $table as a Table object to %s is deprecated. Pass it as a quoted name instead.',
  2517.                 __METHOD__,
  2518.             );
  2520.             $table = $table->getQuotedName($this);
  2521.         }
  2523.         $name    = $index->getQuotedName($this);
  2524.         $columns = $index->getColumns();
  2526.         if (count($columns) === 0) {
  2527.             throw new InvalidArgumentException(sprintf(
  2528.                 'Incomplete or invalid index definition %s on table %s',
  2529.                 $name,
  2530.                 $table,
  2531.             ));
  2532.         }
  2534.         if ($index->isPrimary()) {
  2535.             return $this->getCreatePrimaryKeySQL($index, $table);
  2536.         }
  2538.         $query  = 'CREATE ' . $this->getCreateIndexSQLFlags($index) . 'INDEX ' . $name . ' ON ' . $table;
  2539.         $query .= ' (' . $this->getIndexFieldDeclarationListSQL($index) . ')' . $this->getPartialIndexSQL($index);
  2541.         return $query;
  2542.     }
  2544.     /**
  2545.      * Adds condition for partial index.
  2546.      *
  2547.      * @return string
  2548.      */
  2549.     protected function getPartialIndexSQL(Index $index)
  2550.     {
  2551.         if ($this->supportsPartialIndexes() && $index->hasOption('where')) {
  2552.             return ' WHERE ' . $index->getOption('where');
  2553.         }
  2555.         return '';
  2556.     }
  2558.     /**
  2559.      * Adds additional flags for index generation.
  2560.      *
  2561.      * @return string
  2562.      */
  2563.     protected function getCreateIndexSQLFlags(Index $index)
  2564.     {
  2565.         return $index->isUnique() ? 'UNIQUE ' : '';
  2566.     }
  2568.     /**
  2569.      * Returns the SQL to create an unnamed primary key constraint.
  2570.      *
  2571.      * @param Table|string $table
  2572.      *
  2573.      * @return string
  2574.      */
  2575.     public function getCreatePrimaryKeySQL(Index $index, $table)
  2576.     {
  2577.         if ($table instanceof Table) {
  2578.             Deprecation::trigger(
  2579.                 'doctrine/dbal',
  2580.                 'https://github.com/doctrine/dbal/issues/4798',
  2581.                 'Passing $table as a Table object to %s is deprecated. Pass it as a quoted name instead.',
  2582.                 __METHOD__,
  2583.             );
  2585.             $table = $table->getQuotedName($this);
  2586.         }
  2588.         return 'ALTER TABLE ' . $table . ' ADD PRIMARY KEY (' . $this->getIndexFieldDeclarationListSQL($index) . ')';
  2589.     }
  2591.     /**
  2592.      * Returns the SQL to create a named schema.
  2593.      *
  2594.      * @param string $schemaName
  2595.      *
  2596.      * @return string
  2597.      *
  2598.      * @throws Exception If not supported on this platform.
  2599.      */
  2600.     public function getCreateSchemaSQL($schemaName)
  2601.     {
  2602.         if (! $this->supportsSchemas()) {
  2603.             throw Exception::notSupported(__METHOD__);
  2604.         }
  2606.         return 'CREATE SCHEMA ' . $schemaName;
  2607.     }
  2609.     /**
  2610.      * Returns the SQL to create a unique constraint on a table on this platform.
  2611.      */
  2612.     public function getCreateUniqueConstraintSQL(UniqueConstraint $constraint, string $tableName): string
  2613.     {
  2614.         return $this->getCreateConstraintSQL($constraint, $tableName);
  2615.     }
  2617.     /**
  2618.      * Returns the SQL snippet to drop a schema.
  2619.      *
  2620.      * @throws Exception If not supported on this platform.
  2621.      */
  2622.     public function getDropSchemaSQL(string $schemaName): string
  2623.     {
  2624.         if (! $this->supportsSchemas()) {
  2625.             throw Exception::notSupported(__METHOD__);
  2626.         }
  2628.         return 'DROP SCHEMA ' . $schemaName;
  2629.     }
  2631.     /**
  2632.      * Quotes a string so that it can be safely used as a table or column name,
  2633.      * even if it is a reserved word of the platform. This also detects identifier
  2634.      * chains separated by dot and quotes them independently.
  2635.      *
  2636.      * NOTE: Just because you CAN use quoted identifiers doesn't mean
  2637.      * you SHOULD use them. In general, they end up causing way more
  2638.      * problems than they solve.
  2639.      *
  2640.      * @param string $str The identifier name to be quoted.
  2641.      *
  2642.      * @return string The quoted identifier string.
  2643.      */
  2644.     public function quoteIdentifier($str)
  2645.     {
  2646.         if (strpos($str, '.') !== false) {
  2647.             $parts = array_map([$this, 'quoteSingleIdentifier'], explode('.', $str));
  2649.             return implode('.', $parts);
  2650.         }
  2652.         return $this->quoteSingleIdentifier($str);
  2653.     }
  2655.     /**
  2656.      * Quotes a single identifier (no dot chain separation).
  2657.      *
  2658.      * @param string $str The identifier name to be quoted.
  2659.      *
  2660.      * @return string The quoted identifier string.
  2661.      */
  2662.     public function quoteSingleIdentifier($str)
  2663.     {
  2664.         $c = $this->getIdentifierQuoteCharacter();
  2666.         return $c . str_replace($c, $c . $c, $str) . $c;
  2667.     }
  2669.     /**
  2670.      * Returns the SQL to create a new foreign key.
  2671.      *
  2672.      * @param ForeignKeyConstraint $foreignKey The foreign key constraint.
  2673.      * @param Table|string         $table      The name of the table on which the foreign key is to be created.
  2674.      *
  2675.      * @return string
  2676.      */
  2677.     public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table)
  2678.     {
  2679.         if ($table instanceof Table) {
  2680.             Deprecation::trigger(
  2681.                 'doctrine/dbal',
  2682.                 'https://github.com/doctrine/dbal/issues/4798',
  2683.                 'Passing $table as a Table object to %s is deprecated. Pass it as a quoted name instead.',
  2684.                 __METHOD__,
  2685.             );
  2687.             $table = $table->getQuotedName($this);
  2688.         }
  2690.         return 'ALTER TABLE ' . $table . ' ADD ' . $this->getForeignKeyDeclarationSQL($foreignKey);
  2691.     }
  2693.     /**
  2694.      * Gets the SQL statements for altering an existing table.
  2695.      *
  2696.      * This method returns an array of SQL statements, since some platforms need several statements.
  2697.      *
  2698.      * @return list<string>
  2699.      *
  2700.      * @throws Exception If not supported on this platform.
  2701.      */
  2702.     public function getAlterTableSQL(TableDiff $diff)
  2703.     {
  2704.         throw Exception::notSupported(__METHOD__);
  2705.     }
  2707.     /** @return list<string> */
  2708.     public function getRenameTableSQL(string $oldName, string $newName): array
  2709.     {
  2710.         return [
  2711.             sprintf('ALTER TABLE %s RENAME TO %s', $oldName, $newName),
  2712.         ];
  2713.     }
  2715.     /**
  2716.      * @param mixed[] $columnSql
  2717.      *
  2718.      * @return bool
  2719.      */
  2720.     protected function onSchemaAlterTableAddColumn(Column $column, TableDiff $diff, &$columnSql)
  2721.     {
  2722.         if ($this->_eventManager === null) {
  2723.             return false;
  2724.         }
  2726.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableAddColumn)) {
  2727.             return false;
  2728.         }
  2730.         Deprecation::trigger(
  2731.             'doctrine/dbal',
  2732.             'https://github.com/doctrine/dbal/issues/5784',
  2733.             'Subscribing to %s events is deprecated.',
  2734.             Events::onSchemaAlterTableAddColumn,
  2735.         );
  2737.         $eventArgs = new SchemaAlterTableAddColumnEventArgs($column, $diff, $this);
  2738.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableAddColumn, $eventArgs);
  2740.         $columnSql = array_merge($columnSql, $eventArgs->getSql());
  2742.         return $eventArgs->isDefaultPrevented();
  2743.     }
  2745.     /**
  2746.      * @param string[] $columnSql
  2747.      *
  2748.      * @return bool
  2749.      */
  2750.     protected function onSchemaAlterTableRemoveColumn(Column $column, TableDiff $diff, &$columnSql)
  2751.     {
  2752.         if ($this->_eventManager === null) {
  2753.             return false;
  2754.         }
  2756.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableRemoveColumn)) {
  2757.             return false;
  2758.         }
  2760.         Deprecation::trigger(
  2761.             'doctrine/dbal',
  2762.             'https://github.com/doctrine/dbal/issues/5784',
  2763.             'Subscribing to %s events is deprecated.',
  2764.             Events::onSchemaAlterTableRemoveColumn,
  2765.         );
  2767.         $eventArgs = new SchemaAlterTableRemoveColumnEventArgs($column, $diff, $this);
  2768.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRemoveColumn, $eventArgs);
  2770.         $columnSql = array_merge($columnSql, $eventArgs->getSql());
  2772.         return $eventArgs->isDefaultPrevented();
  2773.     }
  2775.     /**
  2776.      * @param string[] $columnSql
  2777.      *
  2778.      * @return bool
  2779.      */
  2780.     protected function onSchemaAlterTableChangeColumn(ColumnDiff $columnDiff, TableDiff $diff, &$columnSql)
  2781.     {
  2782.         if ($this->_eventManager === null) {
  2783.             return false;
  2784.         }
  2786.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableChangeColumn)) {
  2787.             return false;
  2788.         }
  2790.         Deprecation::trigger(
  2791.             'doctrine/dbal',
  2792.             'https://github.com/doctrine/dbal/issues/5784',
  2793.             'Subscribing to %s events is deprecated.',
  2794.             Events::onSchemaAlterTableChangeColumn,
  2795.         );
  2797.         $eventArgs = new SchemaAlterTableChangeColumnEventArgs($columnDiff, $diff, $this);
  2798.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableChangeColumn, $eventArgs);
  2800.         $columnSql = array_merge($columnSql, $eventArgs->getSql());
  2802.         return $eventArgs->isDefaultPrevented();
  2803.     }
  2805.     /**
  2806.      * @param string   $oldColumnName
  2807.      * @param string[] $columnSql
  2808.      *
  2809.      * @return bool
  2810.      */
  2811.     protected function onSchemaAlterTableRenameColumn($oldColumnName, Column $column, TableDiff $diff, &$columnSql)
  2812.     {
  2813.         if ($this->_eventManager === null) {
  2814.             return false;
  2815.         }
  2817.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableRenameColumn)) {
  2818.             return false;
  2819.         }
  2821.         Deprecation::trigger(
  2822.             'doctrine/dbal',
  2823.             'https://github.com/doctrine/dbal/issues/5784',
  2824.             'Subscribing to %s events is deprecated.',
  2825.             Events::onSchemaAlterTableRenameColumn,
  2826.         );
  2828.         $eventArgs = new SchemaAlterTableRenameColumnEventArgs($oldColumnName, $column, $diff, $this);
  2829.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRenameColumn, $eventArgs);
  2831.         $columnSql = array_merge($columnSql, $eventArgs->getSql());
  2833.         return $eventArgs->isDefaultPrevented();
  2834.     }
  2836.     /**
  2837.      * @param string[] $sql
  2838.      *
  2839.      * @return bool
  2840.      */
  2841.     protected function onSchemaAlterTable(TableDiff $diff, &$sql)
  2842.     {
  2843.         if ($this->_eventManager === null) {
  2844.             return false;
  2845.         }
  2847.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTable)) {
  2848.             return false;
  2849.         }
  2851.         Deprecation::trigger(
  2852.             'doctrine/dbal',
  2853.             'https://github.com/doctrine/dbal/issues/5784',
  2854.             'Subscribing to %s events is deprecated.',
  2855.             Events::onSchemaAlterTable,
  2856.         );
  2858.         $eventArgs = new SchemaAlterTableEventArgs($diff, $this);
  2859.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTable, $eventArgs);
  2861.         $sql = array_merge($sql, $eventArgs->getSql());
  2863.         return $eventArgs->isDefaultPrevented();
  2864.     }
  2866.     /** @return string[] */
  2867.     protected function getPreAlterTableIndexForeignKeySQL(TableDiff $diff)
  2868.     {
  2869.         $tableNameSQL = ($diff->getOldTable() ?? $diff->getName($this))->getQuotedName($this);
  2871.         $sql = [];
  2872.         if ($this->supportsForeignKeyConstraints()) {
  2873.             foreach ($diff->getDroppedForeignKeys() as $foreignKey) {
  2874.                 if ($foreignKey instanceof ForeignKeyConstraint) {
  2875.                     $foreignKey = $foreignKey->getQuotedName($this);
  2876.                 }
  2878.                 $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableNameSQL);
  2879.             }
  2881.             foreach ($diff->getModifiedForeignKeys() as $foreignKey) {
  2882.                 $sql[] = $this->getDropForeignKeySQL($foreignKey->getQuotedName($this), $tableNameSQL);
  2883.             }
  2884.         }
  2886.         foreach ($diff->getDroppedIndexes() as $index) {
  2887.             $sql[] = $this->getDropIndexSQL($index->getQuotedName($this), $tableNameSQL);
  2888.         }
  2890.         foreach ($diff->getModifiedIndexes() as $index) {
  2891.             $sql[] = $this->getDropIndexSQL($index->getQuotedName($this), $tableNameSQL);
  2892.         }
  2894.         return $sql;
  2895.     }
  2897.     /** @return string[] */
  2898.     protected function getPostAlterTableIndexForeignKeySQL(TableDiff $diff)
  2899.     {
  2900.         $sql     = [];
  2901.         $newName = $diff->getNewName();
  2903.         if ($newName !== false) {
  2904.             $tableNameSQL = $newName->getQuotedName($this);
  2905.         } else {
  2906.             $tableNameSQL = ($diff->getOldTable() ?? $diff->getName($this))->getQuotedName($this);
  2907.         }
  2909.         if ($this->supportsForeignKeyConstraints()) {
  2910.             foreach ($diff->getAddedForeignKeys() as $foreignKey) {
  2911.                 $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableNameSQL);
  2912.             }
  2914.             foreach ($diff->getModifiedForeignKeys() as $foreignKey) {
  2915.                 $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableNameSQL);
  2916.             }
  2917.         }
  2919.         foreach ($diff->getAddedIndexes() as $index) {
  2920.             $sql[] = $this->getCreateIndexSQL($index, $tableNameSQL);
  2921.         }
  2923.         foreach ($diff->getModifiedIndexes() as $index) {
  2924.             $sql[] = $this->getCreateIndexSQL($index, $tableNameSQL);
  2925.         }
  2927.         foreach ($diff->getRenamedIndexes() as $oldIndexName => $index) {
  2928.             $oldIndexName = new Identifier($oldIndexName);
  2929.             $sql          = array_merge(
  2930.                 $sql,
  2931.                 $this->getRenameIndexSQL($oldIndexName->getQuotedName($this), $index, $tableNameSQL),
  2932.             );
  2933.         }
  2935.         return $sql;
  2936.     }
  2938.     /**
  2939.      * Returns the SQL for renaming an index on a table.
  2940.      *
  2941.      * @param string $oldIndexName The name of the index to rename from.
  2942.      * @param Index  $index        The definition of the index to rename to.
  2943.      * @param string $tableName    The table to rename the given index on.
  2944.      *
  2945.      * @return string[] The sequence of SQL statements for renaming the given index.
  2946.      */
  2947.     protected function getRenameIndexSQL($oldIndexName, Index $index, $tableName)
  2948.     {
  2949.         return [
  2950.             $this->getDropIndexSQL($oldIndexName, $tableName),
  2951.             $this->getCreateIndexSQL($index, $tableName),
  2952.         ];
  2953.     }
  2955.     /**
  2956.      * Gets declaration of a number of columns in bulk.
  2957.      *
  2958.      * @param mixed[][] $columns A multidimensional associative array.
  2959.      *                           The first dimension determines the column name, while the second
  2960.      *                           dimension is keyed with the name of the properties
  2961.      *                           of the column being declared as array indexes. Currently, the types
  2962.      *                           of supported column properties are as follows:
  2963.      *
  2964.      *      length
  2965.      *          Integer value that determines the maximum length of the text
  2966.      *          column. If this argument is missing the column should be
  2967.      *          declared to have the longest length allowed by the DBMS.
  2968.      *
  2969.      *      default
  2970.      *          Text value to be used as default for this column.
  2971.      *
  2972.      *      notnull
  2973.      *          Boolean flag that indicates whether this column is constrained
  2974.      *          to not be set to null.
  2975.      *      charset
  2976.      *          Text value with the default CHARACTER SET for this column.
  2977.      *      collation
  2978.      *          Text value with the default COLLATION for this column.
  2979.      *      unique
  2980.      *          unique constraint
  2981.      *
  2982.      * @return string
  2983.      */
  2984.     public function getColumnDeclarationListSQL(array $columns)
  2985.     {
  2986.         $declarations = [];
  2988.         foreach ($columns as $name => $column) {
  2989.             $declarations[] = $this->getColumnDeclarationSQL($name, $column);
  2990.         }
  2992.         return implode(', ', $declarations);
  2993.     }
  2995.     /**
  2996.      * Obtains DBMS specific SQL code portion needed to declare a generic type
  2997.      * column to be used in statements like CREATE TABLE.
  2998.      *
  2999.      * @param string  $name   The name the column to be declared.
  3000.      * @param mixed[] $column An associative array with the name of the properties
  3001.      *                        of the column being declared as array indexes. Currently, the types
  3002.      *                        of supported column properties are as follows:
  3003.      *
  3004.      *      length
  3005.      *          Integer value that determines the maximum length of the text
  3006.      *          column. If this argument is missing the column should be
  3007.      *          declared to have the longest length allowed by the DBMS.
  3008.      *
  3009.      *      default
  3010.      *          Text value to be used as default for this column.
  3011.      *
  3012.      *      notnull
  3013.      *          Boolean flag that indicates whether this column is constrained
  3014.      *          to not be set to null.
  3015.      *      charset
  3016.      *          Text value with the default CHARACTER SET for this column.
  3017.      *      collation
  3018.      *          Text value with the default COLLATION for this column.
  3019.      *      unique
  3020.      *          unique constraint
  3021.      *      check
  3022.      *          column check constraint
  3023.      *      columnDefinition
  3024.      *          a string that defines the complete column
  3025.      *
  3026.      * @return string DBMS specific SQL code portion that should be used to declare the column.
  3027.      *
  3028.      * @throws Exception
  3029.      */
  3030.     public function getColumnDeclarationSQL($name, array $column)
  3031.     {
  3032.         if (isset($column['columnDefinition'])) {
  3033.             $declaration = $this->getCustomTypeDeclarationSQL($column);
  3034.         } else {
  3035.             $default = $this->getDefaultValueDeclarationSQL($column);
  3037.             $charset = ! empty($column['charset']) ?
  3038.                 ' ' . $this->getColumnCharsetDeclarationSQL($column['charset']) : '';
  3040.             $collation = ! empty($column['collation']) ?
  3041.                 ' ' . $this->getColumnCollationDeclarationSQL($column['collation']) : '';
  3043.             $notnull = ! empty($column['notnull']) ? ' NOT NULL' : '';
  3045.             if (! empty($column['unique'])) {
  3046.                 Deprecation::trigger(
  3047.                     'doctrine/dbal',
  3048.                     'https://github.com/doctrine/dbal/pull/5656',
  3049.                     'The usage of the "unique" column property is deprecated. Use unique constraints instead.',
  3050.                 );
  3052.                 $unique = ' ' . $this->getUniqueFieldDeclarationSQL();
  3053.             } else {
  3054.                 $unique = '';
  3055.             }
  3057.             if (! empty($column['check'])) {
  3058.                 Deprecation::trigger(
  3059.                     'doctrine/dbal',
  3060.                     'https://github.com/doctrine/dbal/pull/5656',
  3061.                     'The usage of the "check" column property is deprecated.',
  3062.                 );
  3064.                 $check = ' ' . $column['check'];
  3065.             } else {
  3066.                 $check = '';
  3067.             }
  3069.             $typeDecl    = $column['type']->getSQLDeclaration($column, $this);
  3070.             $declaration = $typeDecl . $charset . $default . $notnull . $unique . $check . $collation;
  3072.             if ($this->supportsInlineColumnComments() && isset($column['comment']) && $column['comment'] !== '') {
  3073.                 $declaration .= ' ' . $this->getInlineColumnCommentSQL($column['comment']);
  3074.             }
  3075.         }
  3077.         return $name . ' ' . $declaration;
  3078.     }
  3080.     /**
  3081.      * Returns the SQL snippet that declares a floating point column of arbitrary precision.
  3082.      *
  3083.      * @param mixed[] $column
  3084.      *
  3085.      * @return string
  3086.      */
  3087.     public function getDecimalTypeDeclarationSQL(array $column)
  3088.     {
  3089.         if (empty($column['precision'])) {
  3090.             if (! isset($column['precision'])) {
  3091.                 Deprecation::trigger(
  3092.                     'doctrine/dbal',
  3093.                     'https://github.com/doctrine/dbal/pull/5637',
  3094.                     'Relying on the default decimal column precision is deprecated'
  3095.                         . ', specify the precision explicitly.',
  3096.                 );
  3097.             }
  3099.             $precision = 10;
  3100.         } else {
  3101.             $precision = $column['precision'];
  3102.         }
  3104.         if (empty($column['scale'])) {
  3105.             if (! isset($column['scale'])) {
  3106.                 Deprecation::trigger(
  3107.                     'doctrine/dbal',
  3108.                     'https://github.com/doctrine/dbal/pull/5637',
  3109.                     'Relying on the default decimal column scale is deprecated'
  3110.                         . ', specify the scale explicitly.',
  3111.                 );
  3112.             }
  3114.             $scale = 0;
  3115.         } else {
  3116.             $scale = $column['scale'];
  3117.         }
  3119.         return 'NUMERIC(' . $precision . ', ' . $scale . ')';
  3120.     }
  3122.     /**
  3123.      * Obtains DBMS specific SQL code portion needed to set a default value
  3124.      * declaration to be used in statements like CREATE TABLE.
  3125.      *
  3126.      * @param mixed[] $column The column definition array.
  3127.      *
  3128.      * @return string DBMS specific SQL code portion needed to set a default value.
  3129.      */
  3130.     public function getDefaultValueDeclarationSQL($column)
  3131.     {
  3132.         if (! isset($column['default'])) {
  3133.             return empty($column['notnull']) ? ' DEFAULT NULL' : '';
  3134.         }
  3136.         $default = $column['default'];
  3138.         if (! isset($column['type'])) {
  3139.             return " DEFAULT '" . $default . "'";
  3140.         }
  3142.         $type = $column['type'];
  3144.         if ($type instanceof Types\PhpIntegerMappingType) {
  3145.             return ' DEFAULT ' . $default;
  3146.         }
  3148.         if ($type instanceof Types\PhpDateTimeMappingType && $default === $this->getCurrentTimestampSQL()) {
  3149.             return ' DEFAULT ' . $this->getCurrentTimestampSQL();
  3150.         }
  3152.         if ($type instanceof Types\TimeType && $default === $this->getCurrentTimeSQL()) {
  3153.             return ' DEFAULT ' . $this->getCurrentTimeSQL();
  3154.         }
  3156.         if ($type instanceof Types\DateType && $default === $this->getCurrentDateSQL()) {
  3157.             return ' DEFAULT ' . $this->getCurrentDateSQL();
  3158.         }
  3160.         if ($type instanceof Types\BooleanType) {
  3161.             return ' DEFAULT ' . $this->convertBooleans($default);
  3162.         }
  3164.         return ' DEFAULT ' . $this->quoteStringLiteral($default);
  3165.     }
  3167.     /**
  3168.      * Obtains DBMS specific SQL code portion needed to set a CHECK constraint
  3169.      * declaration to be used in statements like CREATE TABLE.
  3170.      *
  3171.      * @param string[]|mixed[][] $definition The check definition.
  3172.      *
  3173.      * @return string DBMS specific SQL code portion needed to set a CHECK constraint.
  3174.      */
  3175.     public function getCheckDeclarationSQL(array $definition)
  3176.     {
  3177.         $constraints = [];
  3178.         foreach ($definition as $column => $def) {
  3179.             if (is_string($def)) {
  3180.                 $constraints[] = 'CHECK (' . $def . ')';
  3181.             } else {
  3182.                 if (isset($def['min'])) {
  3183.                     $constraints[] = 'CHECK (' . $column . ' >= ' . $def['min'] . ')';
  3184.                 }
  3186.                 if (isset($def['max'])) {
  3187.                     $constraints[] = 'CHECK (' . $column . ' <= ' . $def['max'] . ')';
  3188.                 }
  3189.             }
  3190.         }
  3192.         return implode(', ', $constraints);
  3193.     }
  3195.     /**
  3196.      * Obtains DBMS specific SQL code portion needed to set a unique
  3197.      * constraint declaration to be used in statements like CREATE TABLE.
  3198.      *
  3199.      * @param string           $name       The name of the unique constraint.
  3200.      * @param UniqueConstraint $constraint The unique constraint definition.
  3201.      *
  3202.      * @return string DBMS specific SQL code portion needed to set a constraint.
  3203.      *
  3204.      * @throws InvalidArgumentException
  3205.      */
  3206.     public function getUniqueConstraintDeclarationSQL($name, UniqueConstraint $constraint)
  3207.     {
  3208.         $columns = $constraint->getQuotedColumns($this);
  3209.         $name    = new Identifier($name);
  3211.         if (count($columns) === 0) {
  3212.             throw new InvalidArgumentException("Incomplete definition. 'columns' required.");
  3213.         }
  3215.         $constraintFlags = array_merge(['UNIQUE'], array_map('strtoupper', $constraint->getFlags()));
  3216.         $constraintName  = $name->getQuotedName($this);
  3217.         $columnListNames = $this->getColumnsFieldDeclarationListSQL($columns);
  3219.         return sprintf('CONSTRAINT %s %s (%s)', $constraintName, implode(' ', $constraintFlags), $columnListNames);
  3220.     }
  3222.     /**
  3223.      * Obtains DBMS specific SQL code portion needed to set an index
  3224.      * declaration to be used in statements like CREATE TABLE.
  3225.      *
  3226.      * @param string $name  The name of the index.
  3227.      * @param Index  $index The index definition.
  3228.      *
  3229.      * @return string DBMS specific SQL code portion needed to set an index.
  3230.      *
  3231.      * @throws InvalidArgumentException
  3232.      */
  3233.     public function getIndexDeclarationSQL($name, Index $index)
  3234.     {
  3235.         $columns = $index->getColumns();
  3236.         $name    = new Identifier($name);
  3238.         if (count($columns) === 0) {
  3239.             throw new InvalidArgumentException("Incomplete definition. 'columns' required.");
  3240.         }
  3242.         return $this->getCreateIndexSQLFlags($index) . 'INDEX ' . $name->getQuotedName($this)
  3243.             . ' (' . $this->getIndexFieldDeclarationListSQL($index) . ')' . $this->getPartialIndexSQL($index);
  3244.     }
  3246.     /**
  3247.      * Obtains SQL code portion needed to create a custom column,
  3248.      * e.g. when a column has the "columnDefinition" keyword.
  3249.      * Only "AUTOINCREMENT" and "PRIMARY KEY" are added if appropriate.
  3250.      *
  3251.      * @deprecated
  3252.      *
  3253.      * @param mixed[] $column
  3254.      *
  3255.      * @return string
  3256.      */
  3257.     public function getCustomTypeDeclarationSQL(array $column)
  3258.     {
  3259.         Deprecation::triggerIfCalledFromOutside(
  3260.             'doctrine/dbal',
  3261.             'https://github.com/doctrine/dbal/pull/5527',
  3262.             '%s is deprecated.',
  3263.             __METHOD__,
  3264.         );
  3266.         return $column['columnDefinition'];
  3267.     }
  3269.     /**
  3270.      * Obtains DBMS specific SQL code portion needed to set an index
  3271.      * declaration to be used in statements like CREATE TABLE.
  3272.      *
  3273.      * @deprecated
  3274.      */
  3275.     public function getIndexFieldDeclarationListSQL(Index $index): string
  3276.     {
  3277.         Deprecation::triggerIfCalledFromOutside(
  3278.             'doctrine/dbal',
  3279.             'https://github.com/doctrine/dbal/pull/5527',
  3280.             '%s is deprecated.',
  3281.             __METHOD__,
  3282.         );
  3284.         return implode(', ', $index->getQuotedColumns($this));
  3285.     }
  3287.     /**
  3288.      * Obtains DBMS specific SQL code portion needed to set an index
  3289.      * declaration to be used in statements like CREATE TABLE.
  3290.      *
  3291.      * @deprecated
  3292.      *
  3293.      * @param mixed[] $columns
  3294.      */
  3295.     public function getColumnsFieldDeclarationListSQL(array $columns): string
  3296.     {
  3297.         Deprecation::triggerIfCalledFromOutside(
  3298.             'doctrine/dbal',
  3299.             'https://github.com/doctrine/dbal/pull/5527',
  3300.             '%s is deprecated.',
  3301.             __METHOD__,
  3302.         );
  3304.         $ret = [];
  3306.         foreach ($columns as $column => $definition) {
  3307.             if (is_array($definition)) {
  3308.                 $ret[] = $column;
  3309.             } else {
  3310.                 $ret[] = $definition;
  3311.             }
  3312.         }
  3314.         return implode(', ', $ret);
  3315.     }
  3317.     /**
  3318.      * Returns the required SQL string that fits between CREATE ... TABLE
  3319.      * to create the table as a temporary table.
  3320.      *
  3321.      * Should be overridden in driver classes to return the correct string for the
  3322.      * specific database type.
  3323.      *
  3324.      * The default is to return the string "TEMPORARY" - this will result in a
  3325.      * SQL error for any database that does not support temporary tables, or that
  3326.      * requires a different SQL command from "CREATE TEMPORARY TABLE".
  3327.      *
  3328.      * @deprecated
  3329.      *
  3330.      * @return string The string required to be placed between "CREATE" and "TABLE"
  3331.      *                to generate a temporary table, if possible.
  3332.      */
  3333.     public function getTemporaryTableSQL()
  3334.     {
  3335.         Deprecation::trigger(
  3336.             'doctrine/dbal',
  3337.             'https://github.com/doctrine/dbal/pull/4724',
  3338.             'AbstractPlatform::getTemporaryTableSQL() is deprecated.',
  3339.         );
  3341.         return 'TEMPORARY';
  3342.     }
  3344.     /**
  3345.      * Some vendors require temporary table names to be qualified specially.
  3346.      *
  3347.      * @param string $tableName
  3348.      *
  3349.      * @return string
  3350.      */
  3351.     public function getTemporaryTableName($tableName)
  3352.     {
  3353.         return $tableName;
  3354.     }
  3356.     /**
  3357.      * Obtain DBMS specific SQL code portion needed to set the FOREIGN KEY constraint
  3358.      * of a column declaration to be used in statements like CREATE TABLE.
  3359.      *
  3360.      * @return string DBMS specific SQL code portion needed to set the FOREIGN KEY constraint
  3361.      *                of a column declaration.
  3362.      */
  3363.     public function getForeignKeyDeclarationSQL(ForeignKeyConstraint $foreignKey)
  3364.     {
  3365.         $sql  = $this->getForeignKeyBaseDeclarationSQL($foreignKey);
  3366.         $sql .= $this->getAdvancedForeignKeyOptionsSQL($foreignKey);
  3368.         return $sql;
  3369.     }
  3371.     /**
  3372.      * Returns the FOREIGN KEY query section dealing with non-standard options
  3373.      * as MATCH, INITIALLY DEFERRED, ON UPDATE, ...
  3374.      *
  3375.      * @param ForeignKeyConstraint $foreignKey The foreign key definition.
  3376.      *
  3377.      * @return string
  3378.      */
  3379.     public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey)
  3380.     {
  3381.         $query = '';
  3382.         if ($foreignKey->hasOption('onUpdate')) {
  3383.             $query .= ' ON UPDATE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onUpdate'));
  3384.         }
  3386.         if ($foreignKey->hasOption('onDelete')) {
  3387.             $query .= ' ON DELETE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onDelete'));
  3388.         }
  3390.         return $query;
  3391.     }
  3393.     /**
  3394.      * Returns the given referential action in uppercase if valid, otherwise throws an exception.
  3395.      *
  3396.      * @param string $action The foreign key referential action.
  3397.      *
  3398.      * @return string
  3399.      *
  3400.      * @throws InvalidArgumentException If unknown referential action given.
  3401.      */
  3402.     public function getForeignKeyReferentialActionSQL($action)
  3403.     {
  3404.         $upper = strtoupper($action);
  3405.         switch ($upper) {
  3406.             case 'CASCADE':
  3407.             case 'SET NULL':
  3408.             case 'NO ACTION':
  3409.             case 'RESTRICT':
  3410.             case 'SET DEFAULT':
  3411.                 return $upper;
  3413.             default:
  3414.                 throw new InvalidArgumentException('Invalid foreign key action: ' . $upper);
  3415.         }
  3416.     }
  3418.     /**
  3419.      * Obtains DBMS specific SQL code portion needed to set the FOREIGN KEY constraint
  3420.      * of a column declaration to be used in statements like CREATE TABLE.
  3421.      *
  3422.      * @return string
  3423.      *
  3424.      * @throws InvalidArgumentException
  3425.      */
  3426.     public function getForeignKeyBaseDeclarationSQL(ForeignKeyConstraint $foreignKey)
  3427.     {
  3428.         $sql = '';
  3429.         if (strlen($foreignKey->getName()) > 0) {
  3430.             $sql .= 'CONSTRAINT ' . $foreignKey->getQuotedName($this) . ' ';
  3431.         }
  3433.         $sql .= 'FOREIGN KEY (';
  3435.         if (count($foreignKey->getLocalColumns()) === 0) {
  3436.             throw new InvalidArgumentException("Incomplete definition. 'local' required.");
  3437.         }
  3439.         if (count($foreignKey->getForeignColumns()) === 0) {
  3440.             throw new InvalidArgumentException("Incomplete definition. 'foreign' required.");
  3441.         }
  3443.         if (strlen($foreignKey->getForeignTableName()) === 0) {
  3444.             throw new InvalidArgumentException("Incomplete definition. 'foreignTable' required.");
  3445.         }
  3447.         return $sql . implode(', ', $foreignKey->getQuotedLocalColumns($this))
  3448.             . ') REFERENCES '
  3449.             . $foreignKey->getQuotedForeignTableName($this) . ' ('
  3450.             . implode(', ', $foreignKey->getQuotedForeignColumns($this)) . ')';
  3451.     }
  3453.     /**
  3454.      * Obtains DBMS specific SQL code portion needed to set the UNIQUE constraint
  3455.      * of a column declaration to be used in statements like CREATE TABLE.
  3456.      *
  3457.      * @deprecated Use UNIQUE in SQL instead.
  3458.      *
  3459.      * @return string DBMS specific SQL code portion needed to set the UNIQUE constraint
  3460.      *                of a column declaration.
  3461.      */
  3462.     public function getUniqueFieldDeclarationSQL()
  3463.     {
  3464.         Deprecation::trigger(
  3465.             'doctrine/dbal',
  3466.             'https://github.com/doctrine/dbal/pull/4724',
  3467.             'AbstractPlatform::getUniqueFieldDeclarationSQL() is deprecated. Use UNIQUE in SQL instead.',
  3468.         );
  3470.         return 'UNIQUE';
  3471.     }
  3473.     /**
  3474.      * Obtains DBMS specific SQL code portion needed to set the CHARACTER SET
  3475.      * of a column declaration to be used in statements like CREATE TABLE.
  3476.      *
  3477.      * @param string $charset The name of the charset.
  3478.      *
  3479.      * @return string DBMS specific SQL code portion needed to set the CHARACTER SET
  3480.      *                of a column declaration.
  3481.      */
  3482.     public function getColumnCharsetDeclarationSQL($charset)
  3483.     {
  3484.         return '';
  3485.     }
  3487.     /**
  3488.      * Obtains DBMS specific SQL code portion needed to set the COLLATION
  3489.      * of a column declaration to be used in statements like CREATE TABLE.
  3490.      *
  3491.      * @param string $collation The name of the collation.
  3492.      *
  3493.      * @return string DBMS specific SQL code portion needed to set the COLLATION
  3494.      *                of a column declaration.
  3495.      */
  3496.     public function getColumnCollationDeclarationSQL($collation)
  3497.     {
  3498.         return $this->supportsColumnCollation() ? 'COLLATE ' . $this->quoteSingleIdentifier($collation) : '';
  3499.     }
  3501.     /**
  3502.      * Whether the platform prefers identity columns (eg. autoincrement) for ID generation.
  3503.      * Subclasses should override this method to return TRUE if they prefer identity columns.
  3504.      *
  3505.      * @deprecated
  3506.      *
  3507.      * @return bool
  3508.      */
  3509.     public function prefersIdentityColumns()
  3510.     {
  3511.         Deprecation::trigger(
  3512.             'doctrine/dbal',
  3513.             'https://github.com/doctrine/dbal/pull/1519',
  3514.             'AbstractPlatform::prefersIdentityColumns() is deprecated.',
  3515.         );
  3517.         return false;
  3518.     }
  3520.     /**
  3521.      * Some platforms need the boolean values to be converted.
  3522.      *
  3523.      * The default conversion in this implementation converts to integers (false => 0, true => 1).
  3524.      *
  3525.      * Note: if the input is not a boolean the original input might be returned.
  3526.      *
  3527.      * There are two contexts when converting booleans: Literals and Prepared Statements.
  3528.      * This method should handle the literal case
  3529.      *
  3530.      * @param mixed $item A boolean or an array of them.
  3531.      *
  3532.      * @return mixed A boolean database value or an array of them.
  3533.      */
  3534.     public function convertBooleans($item)
  3535.     {
  3536.         if (is_array($item)) {
  3537.             foreach ($item as $k => $value) {
  3538.                 if (! is_bool($value)) {
  3539.                     continue;
  3540.                 }
  3542.                 $item[$k] = (int) $value;
  3543.             }
  3544.         } elseif (is_bool($item)) {
  3545.             $item = (int) $item;
  3546.         }
  3548.         return $item;
  3549.     }
  3551.     /**
  3552.      * Some platforms have boolean literals that needs to be correctly converted
  3553.      *
  3554.      * The default conversion tries to convert value into bool "(bool)$item"
  3555.      *
  3556.      * @param T $item
  3557.      *
  3558.      * @return (T is null ? null : bool)
  3559.      *
  3560.      * @template T
  3561.      */
  3562.     public function convertFromBoolean($item)
  3563.     {
  3564.         return $item === null ? null : (bool) $item;
  3565.     }
  3567.     /**
  3568.      * This method should handle the prepared statements case. When there is no
  3569.      * distinction, it's OK to use the same method.
  3570.      *
  3571.      * Note: if the input is not a boolean the original input might be returned.
  3572.      *
  3573.      * @param mixed $item A boolean or an array of them.
  3574.      *
  3575.      * @return mixed A boolean database value or an array of them.
  3576.      */
  3577.     public function convertBooleansToDatabaseValue($item)
  3578.     {
  3579.         return $this->convertBooleans($item);
  3580.     }
  3582.     /**
  3583.      * Returns the SQL specific for the platform to get the current date.
  3584.      *
  3585.      * @return string
  3586.      */
  3587.     public function getCurrentDateSQL()
  3588.     {
  3589.         return 'CURRENT_DATE';
  3590.     }
  3592.     /**
  3593.      * Returns the SQL specific for the platform to get the current time.
  3594.      *
  3595.      * @return string
  3596.      */
  3597.     public function getCurrentTimeSQL()
  3598.     {
  3599.         return 'CURRENT_TIME';
  3600.     }
  3602.     /**
  3603.      * Returns the SQL specific for the platform to get the current timestamp
  3604.      *
  3605.      * @return string
  3606.      */
  3607.     public function getCurrentTimestampSQL()
  3608.     {
  3609.         return 'CURRENT_TIMESTAMP';
  3610.     }
  3612.     /**
  3613.      * Returns the SQL for a given transaction isolation level Connection constant.
  3614.      *
  3615.      * @param int $level
  3616.      *
  3617.      * @return string
  3618.      *
  3619.      * @throws InvalidArgumentException
  3620.      */
  3621.     protected function _getTransactionIsolationLevelSQL($level)
  3622.     {
  3623.         switch ($level) {
  3624.             case TransactionIsolationLevel::READ_UNCOMMITTED:
  3625.                 return 'READ UNCOMMITTED';
  3627.             case TransactionIsolationLevel::READ_COMMITTED:
  3628.                 return 'READ COMMITTED';
  3630.             case TransactionIsolationLevel::REPEATABLE_READ:
  3631.                 return 'REPEATABLE READ';
  3633.             case TransactionIsolationLevel::SERIALIZABLE:
  3634.                 return 'SERIALIZABLE';
  3636.             default:
  3637.                 throw new InvalidArgumentException('Invalid isolation level:' . $level);
  3638.         }
  3639.     }
  3641.     /**
  3642.      * @internal The method should be only used from within the {@see AbstractSchemaManager} class hierarchy.
  3643.      *
  3644.      * @return string
  3645.      *
  3646.      * @throws Exception If not supported on this platform.
  3647.      */
  3648.     public function getListDatabasesSQL()
  3649.     {
  3650.         throw Exception::notSupported(__METHOD__);
  3651.     }
  3653.     /**
  3654.      * Returns the SQL statement for retrieving the namespaces defined in the database.
  3655.      *
  3656.      * @deprecated Use {@see AbstractSchemaManager::listSchemaNames()} instead.
  3657.      *
  3658.      * @return string
  3659.      *
  3660.      * @throws Exception If not supported on this platform.
  3661.      */
  3662.     public function getListNamespacesSQL()
  3663.     {
  3664.         Deprecation::triggerIfCalledFromOutside(
  3665.             'doctrine/dbal',
  3666.             'https://github.com/doctrine/dbal/issues/4503',
  3667.             'AbstractPlatform::getListNamespacesSQL() is deprecated,'
  3668.                 . ' use AbstractSchemaManager::listSchemaNames() instead.',
  3669.         );
  3671.         throw Exception::notSupported(__METHOD__);
  3672.     }
  3674.     /**
  3675.      * @internal The method should be only used from within the {@see AbstractSchemaManager} class hierarchy.
  3676.      *
  3677.      * @param string $database
  3678.      *
  3679.      * @return string
  3680.      *
  3681.      * @throws Exception If not supported on this platform.
  3682.      */
  3683.     public function getListSequencesSQL($database)
  3684.     {
  3685.         throw Exception::notSupported(__METHOD__);
  3686.     }
  3688.     /**
  3689.      * @deprecated
  3690.      *
  3691.      * @param string $table
  3692.      *
  3693.      * @return string
  3694.      *
  3695.      * @throws Exception If not supported on this platform.
  3696.      */
  3697.     public function getListTableConstraintsSQL($table)
  3698.     {
  3699.         throw Exception::notSupported(__METHOD__);
  3700.     }
  3702.     /**
  3703.      * @deprecated The SQL used for schema introspection is an implementation detail and should not be relied upon.
  3704.      *
  3705.      * @param string $table
  3706.      * @param string $database
  3707.      *
  3708.      * @return string
  3709.      *
  3710.      * @throws Exception If not supported on this platform.
  3711.      */
  3712.     public function getListTableColumnsSQL($table, $database = null)
  3713.     {
  3714.         throw Exception::notSupported(__METHOD__);
  3715.     }
  3717.     /**
  3718.      * @deprecated The SQL used for schema introspection is an implementation detail and should not be relied upon.
  3719.      *
  3720.      * @return string
  3721.      *
  3722.      * @throws Exception If not supported on this platform.
  3723.      */
  3724.     public function getListTablesSQL()
  3725.     {
  3726.         throw Exception::notSupported(__METHOD__);
  3727.     }
  3729.     /**
  3730.      * @deprecated
  3731.      *
  3732.      * @return string
  3733.      *
  3734.      * @throws Exception If not supported on this platform.
  3735.      */
  3736.     public function getListUsersSQL()
  3737.     {
  3738.         Deprecation::trigger(
  3739.             'doctrine/dbal',
  3740.             'https://github.com/doctrine/dbal/pull/4724',
  3741.             'AbstractPlatform::getListUsersSQL() is deprecated.',
  3742.         );
  3744.         throw Exception::notSupported(__METHOD__);
  3745.     }
  3747.     /**
  3748.      * Returns the SQL to list all views of a database or user.
  3749.      *
  3750.      * @internal The method should be only used from within the {@see AbstractSchemaManager} class hierarchy.
  3751.      *
  3752.      * @param string $database
  3753.      *
  3754.      * @return string
  3755.      *
  3756.      * @throws Exception If not supported on this platform.
  3757.      */
  3758.     public function getListViewsSQL($database)
  3759.     {
  3760.         throw Exception::notSupported(__METHOD__);
  3761.     }
  3763.     /**
  3764.      * @deprecated The SQL used for schema introspection is an implementation detail and should not be relied upon.
  3765.      *
  3766.      * Returns the list of indexes for the current database.
  3767.      *
  3768.      * The current database parameter is optional but will always be passed
  3769.      * when using the SchemaManager API and is the database the given table is in.
  3770.      *
  3771.      * Attention: Some platforms only support currentDatabase when they
  3772.      * are connected with that database. Cross-database information schema
  3773.      * requests may be impossible.
  3774.      *
  3775.      * @param string $table
  3776.      * @param string $database
  3777.      *
  3778.      * @return string
  3779.      *
  3780.      * @throws Exception If not supported on this platform.
  3781.      */
  3782.     public function getListTableIndexesSQL($table, $database = null)
  3783.     {
  3784.         throw Exception::notSupported(__METHOD__);
  3785.     }
  3787.     /**
  3788.      * @deprecated The SQL used for schema introspection is an implementation detail and should not be relied upon.
  3789.      *
  3790.      * @param string $table
  3791.      *
  3792.      * @return string
  3793.      *
  3794.      * @throws Exception If not supported on this platform.
  3795.      */
  3796.     public function getListTableForeignKeysSQL($table)
  3797.     {
  3798.         throw Exception::notSupported(__METHOD__);
  3799.     }
  3801.     /**
  3802.      * @param string $name
  3803.      * @param string $sql
  3804.      *
  3805.      * @return string
  3806.      */
  3807.     public function getCreateViewSQL($name, $sql)
  3808.     {
  3809.         return 'CREATE VIEW ' . $name . ' AS ' . $sql;
  3810.     }
  3812.     /**
  3813.      * @param string $name
  3814.      *
  3815.      * @return string
  3816.      */
  3817.     public function getDropViewSQL($name)
  3818.     {
  3819.         return 'DROP VIEW ' . $name;
  3820.     }
  3822.     /**
  3823.      * @param string $sequence
  3824.      *
  3825.      * @return string
  3826.      *
  3827.      * @throws Exception If not supported on this platform.
  3828.      */
  3829.     public function getSequenceNextValSQL($sequence)
  3830.     {
  3831.         throw Exception::notSupported(__METHOD__);
  3832.     }
  3834.     /**
  3835.      * Returns the SQL to create a new database.
  3836.      *
  3837.      * @param string $name The name of the database that should be created.
  3838.      *
  3839.      * @return string
  3840.      *
  3841.      * @throws Exception If not supported on this platform.
  3842.      */
  3843.     public function getCreateDatabaseSQL($name)
  3844.     {
  3845.         if (! $this->supportsCreateDropDatabase()) {
  3846.             throw Exception::notSupported(__METHOD__);
  3847.         }
  3849.         return 'CREATE DATABASE ' . $name;
  3850.     }
  3852.     /**
  3853.      * Returns the SQL snippet to drop an existing database.
  3854.      *
  3855.      * @param string $name The name of the database that should be dropped.
  3856.      *
  3857.      * @return string
  3858.      */
  3859.     public function getDropDatabaseSQL($name)
  3860.     {
  3861.         if (! $this->supportsCreateDropDatabase()) {
  3862.             throw Exception::notSupported(__METHOD__);
  3863.         }
  3865.         return 'DROP DATABASE ' . $name;
  3866.     }
  3868.     /**
  3869.      * Returns the SQL to set the transaction isolation level.
  3870.      *
  3871.      * @param int $level
  3872.      *
  3873.      * @return string
  3874.      *
  3875.      * @throws Exception If not supported on this platform.
  3876.      */
  3877.     public function getSetTransactionIsolationSQL($level)
  3878.     {
  3879.         throw Exception::notSupported(__METHOD__);
  3880.     }
  3882.     /**
  3883.      * Obtains DBMS specific SQL to be used to create datetime columns in
  3884.      * statements like CREATE TABLE.
  3885.      *
  3886.      * @param mixed[] $column
  3887.      *
  3888.      * @return string
  3889.      *
  3890.      * @throws Exception If not supported on this platform.
  3891.      */
  3892.     public function getDateTimeTypeDeclarationSQL(array $column)
  3893.     {
  3894.         throw Exception::notSupported(__METHOD__);
  3895.     }
  3897.     /**
  3898.      * Obtains DBMS specific SQL to be used to create datetime with timezone offset columns.
  3899.      *
  3900.      * @param mixed[] $column
  3901.      *
  3902.      * @return string
  3903.      */
  3904.     public function getDateTimeTzTypeDeclarationSQL(array $column)
  3905.     {
  3906.         return $this->getDateTimeTypeDeclarationSQL($column);
  3907.     }
  3909.     /**
  3910.      * Obtains DBMS specific SQL to be used to create date columns in statements
  3911.      * like CREATE TABLE.
  3912.      *
  3913.      * @param mixed[] $column
  3914.      *
  3915.      * @return string
  3916.      *
  3917.      * @throws Exception If not supported on this platform.
  3918.      */
  3919.     public function getDateTypeDeclarationSQL(array $column)
  3920.     {
  3921.         throw Exception::notSupported(__METHOD__);
  3922.     }
  3924.     /**
  3925.      * Obtains DBMS specific SQL to be used to create time columns in statements
  3926.      * like CREATE TABLE.
  3927.      *
  3928.      * @param mixed[] $column
  3929.      *
  3930.      * @return string
  3931.      *
  3932.      * @throws Exception If not supported on this platform.
  3933.      */
  3934.     public function getTimeTypeDeclarationSQL(array $column)
  3935.     {
  3936.         throw Exception::notSupported(__METHOD__);
  3937.     }
  3939.     /**
  3940.      * @param mixed[] $column
  3941.      *
  3942.      * @return string
  3943.      */
  3944.     public function getFloatDeclarationSQL(array $column)
  3945.     {
  3946.         return 'DOUBLE PRECISION';
  3947.     }
  3949.     /**
  3950.      * Gets the default transaction isolation level of the platform.
  3951.      *
  3952.      * @see TransactionIsolationLevel
  3953.      *
  3954.      * @return TransactionIsolationLevel::* The default isolation level.
  3955.      */
  3956.     public function getDefaultTransactionIsolationLevel()
  3957.     {
  3958.         return TransactionIsolationLevel::READ_COMMITTED;
  3959.     }
  3961.     /* supports*() methods */
  3963.     /**
  3964.      * Whether the platform supports sequences.
  3965.      *
  3966.      * @return bool
  3967.      */
  3968.     public function supportsSequences()
  3969.     {
  3970.         return false;
  3971.     }
  3973.     /**
  3974.      * Whether the platform supports identity columns.
  3975.      *
  3976.      * Identity columns are columns that receive an auto-generated value from the
  3977.      * database on insert of a row.
  3978.      *
  3979.      * @return bool
  3980.      */
  3981.     public function supportsIdentityColumns()
  3982.     {
  3983.         return false;
  3984.     }
  3986.     /**
  3987.      * Whether the platform emulates identity columns through sequences.
  3988.      *
  3989.      * Some platforms that do not support identity columns natively
  3990.      * but support sequences can emulate identity columns by using
  3991.      * sequences.
  3992.      *
  3993.      * @deprecated
  3994.      *
  3995.      * @return bool
  3996.      */
  3997.     public function usesSequenceEmulatedIdentityColumns()
  3998.     {
  3999.         Deprecation::trigger(
  4000.             'doctrine/dbal',
  4001.             'https://github.com/doctrine/dbal/pull/5513',
  4002.             '%s is deprecated.',
  4003.             __METHOD__,
  4004.         );
  4006.         return false;
  4007.     }
  4009.     /**
  4010.      * Returns the name of the sequence for a particular identity column in a particular table.
  4011.      *
  4012.      * @deprecated
  4013.      *
  4014.      * @see usesSequenceEmulatedIdentityColumns
  4015.      *
  4016.      * @param string $tableName  The name of the table to return the sequence name for.
  4017.      * @param string $columnName The name of the identity column in the table to return the sequence name for.
  4018.      *
  4019.      * @return string
  4020.      *
  4021.      * @throws Exception If not supported on this platform.
  4022.      */
  4023.     public function getIdentitySequenceName($tableName, $columnName)
  4024.     {
  4025.         throw Exception::notSupported(__METHOD__);
  4026.     }
  4028.     /**
  4029.      * Whether the platform supports indexes.
  4030.      *
  4031.      * @deprecated
  4032.      *
  4033.      * @return bool
  4034.      */
  4035.     public function supportsIndexes()
  4036.     {
  4037.         Deprecation::trigger(
  4038.             'doctrine/dbal',
  4039.             'https://github.com/doctrine/dbal/pull/4724',
  4040.             'AbstractPlatform::supportsIndexes() is deprecated.',
  4041.         );
  4043.         return true;
  4044.     }
  4046.     /**
  4047.      * Whether the platform supports partial indexes.
  4048.      *
  4049.      * @return bool
  4050.      */
  4051.     public function supportsPartialIndexes()
  4052.     {
  4053.         return false;
  4054.     }
  4056.     /**
  4057.      * Whether the platform supports indexes with column length definitions.
  4058.      */
  4059.     public function supportsColumnLengthIndexes(): bool
  4060.     {
  4061.         return false;
  4062.     }
  4064.     /**
  4065.      * Whether the platform supports altering tables.
  4066.      *
  4067.      * @deprecated All platforms must implement altering tables.
  4068.      *
  4069.      * @return bool
  4070.      */
  4071.     public function supportsAlterTable()
  4072.     {
  4073.         Deprecation::trigger(
  4074.             'doctrine/dbal',
  4075.             'https://github.com/doctrine/dbal/pull/4724',
  4076.             'AbstractPlatform::supportsAlterTable() is deprecated. All platforms must implement altering tables.',
  4077.         );
  4079.         return true;
  4080.     }
  4082.     /**
  4083.      * Whether the platform supports transactions.
  4084.      *
  4085.      * @deprecated
  4086.      *
  4087.      * @return bool
  4088.      */
  4089.     public function supportsTransactions()
  4090.     {
  4091.         Deprecation::trigger(
  4092.             'doctrine/dbal',
  4093.             'https://github.com/doctrine/dbal/pull/4724',
  4094.             'AbstractPlatform::supportsTransactions() is deprecated.',
  4095.         );
  4097.         return true;
  4098.     }
  4100.     /**
  4101.      * Whether the platform supports savepoints.
  4102.      *
  4103.      * @return bool
  4104.      */
  4105.     public function supportsSavepoints()
  4106.     {
  4107.         return true;
  4108.     }
  4110.     /**
  4111.      * Whether the platform supports releasing savepoints.
  4112.      *
  4113.      * @return bool
  4114.      */
  4115.     public function supportsReleaseSavepoints()
  4116.     {
  4117.         return $this->supportsSavepoints();
  4118.     }
  4120.     /**
  4121.      * Whether the platform supports primary key constraints.
  4122.      *
  4123.      * @deprecated
  4124.      *
  4125.      * @return bool
  4126.      */
  4127.     public function supportsPrimaryConstraints()
  4128.     {
  4129.         Deprecation::trigger(
  4130.             'doctrine/dbal',
  4131.             'https://github.com/doctrine/dbal/pull/4724',
  4132.             'AbstractPlatform::supportsPrimaryConstraints() is deprecated.',
  4133.         );
  4135.         return true;
  4136.     }
  4138.     /**
  4139.      * Whether the platform supports foreign key constraints.
  4140.      *
  4141.      * @deprecated All platforms should support foreign key constraints.
  4142.      *
  4143.      * @return bool
  4144.      */
  4145.     public function supportsForeignKeyConstraints()
  4146.     {
  4147.         Deprecation::triggerIfCalledFromOutside(
  4148.             'doctrine/dbal',
  4149.             'https://github.com/doctrine/dbal/pull/5409',
  4150.             'AbstractPlatform::supportsForeignKeyConstraints() is deprecated.',
  4151.         );
  4153.         return true;
  4154.     }
  4156.     /**
  4157.      * Whether the platform supports database schemas.
  4158.      *
  4159.      * @return bool
  4160.      */
  4161.     public function supportsSchemas()
  4162.     {
  4163.         return false;
  4164.     }
  4166.     /**
  4167.      * Whether this platform can emulate schemas.
  4168.      *
  4169.      * @deprecated
  4170.      *
  4171.      * Platforms that either support or emulate schemas don't automatically
  4172.      * filter a schema for the namespaced elements in {@see AbstractManager::introspectSchema()}.
  4173.      *
  4174.      * @return bool
  4175.      */
  4176.     public function canEmulateSchemas()
  4177.     {
  4178.         Deprecation::trigger(
  4179.             'doctrine/dbal',
  4180.             'https://github.com/doctrine/dbal/pull/4805',
  4181.             'AbstractPlatform::canEmulateSchemas() is deprecated.',
  4182.         );
  4184.         return false;
  4185.     }
  4187.     /**
  4188.      * Returns the default schema name.
  4189.      *
  4190.      * @deprecated
  4191.      *
  4192.      * @return string
  4193.      *
  4194.      * @throws Exception If not supported on this platform.
  4195.      */
  4196.     public function getDefaultSchemaName()
  4197.     {
  4198.         throw Exception::notSupported(__METHOD__);
  4199.     }
  4201.     /**
  4202.      * Whether this platform supports create database.
  4203.      *
  4204.      * Some databases don't allow to create and drop databases at all or only with certain tools.
  4205.      *
  4206.      * @deprecated
  4207.      *
  4208.      * @return bool
  4209.      */
  4210.     public function supportsCreateDropDatabase()
  4211.     {
  4212.         Deprecation::triggerIfCalledFromOutside(
  4213.             'doctrine/dbal',
  4214.             'https://github.com/doctrine/dbal/pull/5513',
  4215.             '%s is deprecated.',
  4216.             __METHOD__,
  4217.         );
  4219.         return true;
  4220.     }
  4222.     /**
  4223.      * Whether the platform supports getting the affected rows of a recent update/delete type query.
  4224.      *
  4225.      * @deprecated
  4226.      *
  4227.      * @return bool
  4228.      */
  4229.     public function supportsGettingAffectedRows()
  4230.     {
  4231.         Deprecation::trigger(
  4232.             'doctrine/dbal',
  4233.             'https://github.com/doctrine/dbal/pull/4724',
  4234.             'AbstractPlatform::supportsGettingAffectedRows() is deprecated.',
  4235.         );
  4237.         return true;
  4238.     }
  4240.     /**
  4241.      * Whether this platform support to add inline column comments as postfix.
  4242.      *
  4243.      * @return bool
  4244.      */
  4245.     public function supportsInlineColumnComments()
  4246.     {
  4247.         return false;
  4248.     }
  4250.     /**
  4251.      * Whether this platform support the proprietary syntax "COMMENT ON asset".
  4252.      *
  4253.      * @return bool
  4254.      */
  4255.     public function supportsCommentOnStatement()
  4256.     {
  4257.         return false;
  4258.     }
  4260.     /**
  4261.      * Does this platform have native guid type.
  4262.      *
  4263.      * @deprecated
  4264.      *
  4265.      * @return bool
  4266.      */
  4267.     public function hasNativeGuidType()
  4268.     {
  4269.         Deprecation::triggerIfCalledFromOutside(
  4270.             'doctrine/dbal',
  4271.             'https://github.com/doctrine/dbal/pull/5509',
  4272.             '%s is deprecated.',
  4273.             __METHOD__,
  4274.         );
  4276.         return false;
  4277.     }
  4279.     /**
  4280.      * Does this platform have native JSON type.
  4281.      *
  4282.      * @deprecated
  4283.      *
  4284.      * @return bool
  4285.      */
  4286.     public function hasNativeJsonType()
  4287.     {
  4288.         Deprecation::triggerIfCalledFromOutside(
  4289.             'doctrine/dbal',
  4290.             'https://github.com/doctrine/dbal/pull/5509',
  4291.             '%s is deprecated.',
  4292.             __METHOD__,
  4293.         );
  4295.         return false;
  4296.     }
  4298.     /**
  4299.      * Whether this platform supports views.
  4300.      *
  4301.      * @deprecated All platforms must implement support for views.
  4302.      *
  4303.      * @return bool
  4304.      */
  4305.     public function supportsViews()
  4306.     {
  4307.         Deprecation::trigger(
  4308.             'doctrine/dbal',
  4309.             'https://github.com/doctrine/dbal/pull/4724',
  4310.             'AbstractPlatform::supportsViews() is deprecated. All platforms must implement support for views.',
  4311.         );
  4313.         return true;
  4314.     }
  4316.     /**
  4317.      * Does this platform support column collation?
  4318.      *
  4319.      * @return bool
  4320.      */
  4321.     public function supportsColumnCollation()
  4322.     {
  4323.         return false;
  4324.     }
  4326.     /**
  4327.      * Gets the format string, as accepted by the date() function, that describes
  4328.      * the format of a stored datetime value of this platform.
  4329.      *
  4330.      * @return string The format string.
  4331.      */
  4332.     public function getDateTimeFormatString()
  4333.     {
  4334.         return 'Y-m-d H:i:s';
  4335.     }
  4337.     /**
  4338.      * Gets the format string, as accepted by the date() function, that describes
  4339.      * the format of a stored datetime with timezone value of this platform.
  4340.      *
  4341.      * @return string The format string.
  4342.      */
  4343.     public function getDateTimeTzFormatString()
  4344.     {
  4345.         return 'Y-m-d H:i:s';
  4346.     }
  4348.     /**
  4349.      * Gets the format string, as accepted by the date() function, that describes
  4350.      * the format of a stored date value of this platform.
  4351.      *
  4352.      * @return string The format string.
  4353.      */
  4354.     public function getDateFormatString()
  4355.     {
  4356.         return 'Y-m-d';
  4357.     }
  4359.     /**
  4360.      * Gets the format string, as accepted by the date() function, that describes
  4361.      * the format of a stored time value of this platform.
  4362.      *
  4363.      * @return string The format string.
  4364.      */
  4365.     public function getTimeFormatString()
  4366.     {
  4367.         return 'H:i:s';
  4368.     }
  4370.     /**
  4371.      * Adds an driver-specific LIMIT clause to the query.
  4372.      *
  4373.      * @param string   $query
  4374.      * @param int|null $limit
  4375.      * @param int      $offset
  4376.      *
  4377.      * @throws Exception
  4378.      */
  4379.     final public function modifyLimitQuery($query, $limit, $offset = 0): string
  4380.     {
  4381.         if ($offset < 0) {
  4382.             throw new Exception(sprintf(
  4383.                 'Offset must be a positive integer or zero, %d given',
  4384.                 $offset,
  4385.             ));
  4386.         }
  4388.         if ($offset > 0 && ! $this->supportsLimitOffset()) {
  4389.             throw new Exception(sprintf(
  4390.                 'Platform %s does not support offset values in limit queries.',
  4391.                 $this->getName(),
  4392.             ));
  4393.         }
  4395.         if ($limit !== null) {
  4396.             $limit = (int) $limit;
  4397.         }
  4399.         return $this->doModifyLimitQuery($query, $limit, (int) $offset);
  4400.     }
  4402.     /**
  4403.      * Adds an platform-specific LIMIT clause to the query.
  4404.      *
  4405.      * @param string   $query
  4406.      * @param int|null $limit
  4407.      * @param int      $offset
  4408.      *
  4409.      * @return string
  4410.      */
  4411.     protected function doModifyLimitQuery($query, $limit, $offset)
  4412.     {
  4413.         if ($limit !== null) {
  4414.             $query .= sprintf(' LIMIT %d', $limit);
  4415.         }
  4417.         if ($offset > 0) {
  4418.             $query .= sprintf(' OFFSET %d', $offset);
  4419.         }
  4421.         return $query;
  4422.     }
  4424.     /**
  4425.      * Whether the database platform support offsets in modify limit clauses.
  4426.      *
  4427.      * @deprecated All platforms must implement support for offsets in modify limit clauses.
  4428.      *
  4429.      * @return bool
  4430.      */
  4431.     public function supportsLimitOffset()
  4432.     {
  4433.         Deprecation::triggerIfCalledFromOutside(
  4434.             'doctrine/dbal',
  4435.             'https://github.com/doctrine/dbal/pull/4724',
  4436.             'AbstractPlatform::supportsViews() is deprecated.'
  4437.             . ' All platforms must implement support for offsets in modify limit clauses.',
  4438.         );
  4440.         return true;
  4441.     }
  4443.     /**
  4444.      * Maximum length of any given database identifier, like tables or column names.
  4445.      *
  4446.      * @return int
  4447.      */
  4448.     public function getMaxIdentifierLength()
  4449.     {
  4450.         return 63;
  4451.     }
  4453.     /**
  4454.      * Returns the insert SQL for an empty insert statement.
  4455.      *
  4456.      * @param string $quotedTableName
  4457.      * @param string $quotedIdentifierColumnName
  4458.      *
  4459.      * @return string
  4460.      */
  4461.     public function getEmptyIdentityInsertSQL($quotedTableName, $quotedIdentifierColumnName)
  4462.     {
  4463.         return 'INSERT INTO ' . $quotedTableName . ' (' . $quotedIdentifierColumnName . ') VALUES (null)';
  4464.     }
  4466.     /**
  4467.      * Generates a Truncate Table SQL statement for a given table.
  4468.      *
  4469.      * Cascade is not supported on many platforms but would optionally cascade the truncate by
  4470.      * following the foreign keys.
  4471.      *
  4472.      * @param string $tableName
  4473.      * @param bool   $cascade
  4474.      *
  4475.      * @return string
  4476.      */
  4477.     public function getTruncateTableSQL($tableName, $cascade = false)
  4478.     {
  4479.         $tableIdentifier = new Identifier($tableName);
  4481.         return 'TRUNCATE ' . $tableIdentifier->getQuotedName($this);
  4482.     }
  4484.     /**
  4485.      * This is for test reasons, many vendors have special requirements for dummy statements.
  4486.      *
  4487.      * @return string
  4488.      */
  4489.     public function getDummySelectSQL()
  4490.     {
  4491.         $expression = func_num_args() > 0 ? func_get_arg(0) : '1';
  4493.         return sprintf('SELECT %s', $expression);
  4494.     }
  4496.     /**
  4497.      * Returns the SQL to create a new savepoint.
  4498.      *
  4499.      * @param string $savepoint
  4500.      *
  4501.      * @return string
  4502.      */
  4503.     public function createSavePoint($savepoint)
  4504.     {
  4505.         return 'SAVEPOINT ' . $savepoint;
  4506.     }
  4508.     /**
  4509.      * Returns the SQL to release a savepoint.
  4510.      *
  4511.      * @param string $savepoint
  4512.      *
  4513.      * @return string
  4514.      */
  4515.     public function releaseSavePoint($savepoint)
  4516.     {
  4517.         return 'RELEASE SAVEPOINT ' . $savepoint;
  4518.     }
  4520.     /**
  4521.      * Returns the SQL to rollback a savepoint.
  4522.      *
  4523.      * @param string $savepoint
  4524.      *
  4525.      * @return string
  4526.      */
  4527.     public function rollbackSavePoint($savepoint)
  4528.     {
  4529.         return 'ROLLBACK TO SAVEPOINT ' . $savepoint;
  4530.     }
  4532.     /**
  4533.      * Returns the keyword list instance of this platform.
  4534.      *
  4535.      * @throws Exception If no keyword list is specified.
  4536.      */
  4537.     final public function getReservedKeywordsList(): KeywordList
  4538.     {
  4539.         // Store the instance so it doesn't need to be generated on every request.
  4540.         return $this->_keywords ??= $this->createReservedKeywordsList();
  4541.     }
  4543.     /**
  4544.      * Creates an instance of the reserved keyword list of this platform.
  4545.      *
  4546.      * This method will become @abstract in DBAL 4.0.0.
  4547.      *
  4548.      * @throws Exception
  4549.      */
  4550.     protected function createReservedKeywordsList(): KeywordList
  4551.     {
  4552.         $class    = $this->getReservedKeywordsClass();
  4553.         $keywords = new $class();
  4554.         if (! $keywords instanceof KeywordList) {
  4555.             throw Exception::notSupported(__METHOD__);
  4556.         }
  4558.         return $keywords;
  4559.     }
  4561.     /**
  4562.      * Returns the class name of the reserved keywords list.
  4563.      *
  4564.      * @deprecated Implement {@see createReservedKeywordsList()} instead.
  4565.      *
  4566.      * @return string
  4567.      * @psalm-return class-string<KeywordList>
  4568.      *
  4569.      * @throws Exception If not supported on this platform.
  4570.      */
  4571.     protected function getReservedKeywordsClass()
  4572.     {
  4573.         Deprecation::triggerIfCalledFromOutside(
  4574.             'doctrine/dbal',
  4575.             'https://github.com/doctrine/dbal/issues/4510',
  4576.             'AbstractPlatform::getReservedKeywordsClass() is deprecated,'
  4577.                 . ' use AbstractPlatform::createReservedKeywordsList() instead.',
  4578.         );
  4580.         throw Exception::notSupported(__METHOD__);
  4581.     }
  4583.     /**
  4584.      * Quotes a literal string.
  4585.      * This method is NOT meant to fix SQL injections!
  4586.      * It is only meant to escape this platform's string literal
  4587.      * quote character inside the given literal string.
  4588.      *
  4589.      * @param string $str The literal string to be quoted.
  4590.      *
  4591.      * @return string The quoted literal string.
  4592.      */
  4593.     public function quoteStringLiteral($str)
  4594.     {
  4595.         $c = $this->getStringLiteralQuoteCharacter();
  4597.         return $c . str_replace($c, $c . $c, $str) . $c;
  4598.     }
  4600.     /**
  4601.      * Gets the character used for string literal quoting.
  4602.      *
  4603.      * @deprecated Use {@see quoteStringLiteral()} to quote string literals instead.
  4604.      *
  4605.      * @return string
  4606.      */
  4607.     public function getStringLiteralQuoteCharacter()
  4608.     {
  4609.         Deprecation::triggerIfCalledFromOutside(
  4610.             'doctrine/dbal',
  4611.             'https://github.com/doctrine/dbal/pull/5388',
  4612.             'AbstractPlatform::getStringLiteralQuoteCharacter() is deprecated.'
  4613.                 . ' Use quoteStringLiteral() instead.',
  4614.         );
  4616.         return "'";
  4617.     }
  4619.     /**
  4620.      * Escapes metacharacters in a string intended to be used with a LIKE
  4621.      * operator.
  4622.      *
  4623.      * @param string $inputString a literal, unquoted string
  4624.      * @param string $escapeChar  should be reused by the caller in the LIKE
  4625.      *                            expression.
  4626.      */
  4627.     final public function escapeStringForLike(string $inputString, string $escapeChar): string
  4628.     {
  4629.         return preg_replace(
  4630.             '~([' . preg_quote($this->getLikeWildcardCharacters() . $escapeChar, '~') . '])~u',
  4631.             addcslashes($escapeChar, '\\') . '$1',
  4632.             $inputString,
  4633.         );
  4634.     }
  4636.     /**
  4637.      * @return array<string,mixed> An associative array with the name of the properties
  4638.      *                             of the column being declared as array indexes.
  4639.      */
  4640.     private function columnToArray(Column $column): array
  4641.     {
  4642.         $name = $column->getQuotedName($this);
  4644.         return array_merge($column->toArray(), [
  4645.             'name' => $name,
  4646.             'version' => $column->hasPlatformOption('version') ? $column->getPlatformOption('version') : false,
  4647.             'comment' => $this->getColumnComment($column),
  4648.         ]);
  4649.     }
  4651.     /** @internal */
  4652.     public function createSQLParser(): Parser
  4653.     {
  4654.         return new Parser(false);
  4655.     }
  4657.     protected function getLikeWildcardCharacters(): string
  4658.     {
  4659.         return '%_';
  4660.     }
  4662.     /**
  4663.      * Compares the definitions of the given columns in the context of this platform.
  4664.      *
  4665.      * @throws Exception
  4666.      */
  4667.     public function columnsEqual(Column $column1, Column $column2): bool
  4668.     {
  4669.         $column1Array = $this->columnToArray($column1);
  4670.         $column2Array = $this->columnToArray($column2);
  4672.         // ignore explicit columnDefinition since it's not set on the Column generated by the SchemaManager
  4673.         unset($column1Array['columnDefinition']);
  4674.         unset($column2Array['columnDefinition']);
  4676.         if (
  4677.             $this->getColumnDeclarationSQL('', $column1Array)
  4678.             !== $this->getColumnDeclarationSQL('', $column2Array)
  4679.         ) {
  4680.             return false;
  4681.         }
  4683.         if (! $this->columnDeclarationsMatch($column1, $column2)) {
  4684.             return false;
  4685.         }
  4687.         // If the platform supports inline comments, all comparison is already done above
  4688.         if ($this->supportsInlineColumnComments()) {
  4689.             return true;
  4690.         }
  4692.         if ($column1->getComment() !== $column2->getComment()) {
  4693.             return false;
  4694.         }
  4696.         return $column1->getType() === $column2->getType();
  4697.     }
  4699.     /**
  4700.      * Whether the database data type matches that expected for the doctrine type for the given colunms.
  4701.      */
  4702.     private function columnDeclarationsMatch(Column $column1, Column $column2): bool
  4703.     {
  4704.         return ! (
  4705.             $column1->hasPlatformOption('declarationMismatch') ||
  4706.             $column2->hasPlatformOption('declarationMismatch')
  4707.         );
  4708.     }
  4710.     /**
  4711.      * Creates the schema manager that can be used to inspect and change the underlying
  4712.      * database schema according to the dialect of the platform.
  4713.      *
  4714.      * @throws Exception
  4715.      *
  4716.      * @abstract
  4717.      */
  4718.     public function createSchemaManager(Connection $connection): AbstractSchemaManager
  4719.     {
  4720.         throw Exception::notSupported(__METHOD__);
  4721.     }
  4722. }