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

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Platforms;
  5. use Doctrine\Common\EventManager;
  6. use Doctrine\DBAL\Event\SchemaAlterTableAddColumnEventArgs;
  7. use Doctrine\DBAL\Event\SchemaAlterTableChangeColumnEventArgs;
  8. use Doctrine\DBAL\Event\SchemaAlterTableEventArgs;
  9. use Doctrine\DBAL\Event\SchemaAlterTableRemoveColumnEventArgs;
  10. use Doctrine\DBAL\Event\SchemaAlterTableRenameColumnEventArgs;
  11. use Doctrine\DBAL\Event\SchemaCreateTableColumnEventArgs;
  12. use Doctrine\DBAL\Event\SchemaCreateTableEventArgs;
  13. use Doctrine\DBAL\Event\SchemaDropTableEventArgs;
  14. use Doctrine\DBAL\Events;
  15. use Doctrine\DBAL\Exception;
  16. use Doctrine\DBAL\Exception\InvalidLockMode;
  17. use Doctrine\DBAL\LockMode;
  18. use Doctrine\DBAL\Platforms\Keywords\KeywordList;
  19. use Doctrine\DBAL\Schema\Column;
  20. use Doctrine\DBAL\Schema\ColumnDiff;
  21. use Doctrine\DBAL\Schema\Constraint;
  22. use Doctrine\DBAL\Schema\ForeignKeyConstraint;
  23. use Doctrine\DBAL\Schema\Identifier;
  24. use Doctrine\DBAL\Schema\Index;
  25. use Doctrine\DBAL\Schema\Sequence;
  26. use Doctrine\DBAL\Schema\Table;
  27. use Doctrine\DBAL\Schema\TableDiff;
  28. use Doctrine\DBAL\Schema\UniqueConstraint;
  29. use Doctrine\DBAL\SQL\Parser;
  30. use Doctrine\DBAL\TransactionIsolationLevel;
  31. use Doctrine\DBAL\Types;
  32. use Doctrine\DBAL\Types\Type;
  33. use Doctrine\Deprecations\Deprecation;
  34. use InvalidArgumentException;
  35. use UnexpectedValueException;
  37. use function addcslashes;
  38. use function array_map;
  39. use function array_merge;
  40. use function array_unique;
  41. use function array_values;
  42. use function assert;
  43. use function count;
  44. use function explode;
  45. use function func_get_arg;
  46. use function func_get_args;
  47. use function func_num_args;
  48. use function implode;
  49. use function in_array;
  50. use function is_array;
  51. use function is_bool;
  52. use function is_int;
  53. use function is_string;
  54. use function preg_quote;
  55. use function preg_replace;
  56. use function sprintf;
  57. use function str_replace;
  58. use function strlen;
  59. use function strpos;
  60. use function strtolower;
  61. use function strtoupper;
  63. /**
  64.  * Base class for all DatabasePlatforms. The DatabasePlatforms are the central
  65.  * point of abstraction of platform-specific behaviors, features and SQL dialects.
  66.  * They are a passive source of information.
  67.  *
  68.  * @todo Remove any unnecessary methods.
  69.  */
  70. abstract class AbstractPlatform
  71. {
  72.     public const CREATE_INDEXES = 1;
  74.     public const CREATE_FOREIGNKEYS = 2;
  76.     /** @var string[]|null */
  77.     protected $doctrineTypeMapping;
  79.     /**
  80.      * Contains a list of all columns that should generate parseable column comments for type-detection
  81.      * in reverse engineering scenarios.
  82.      *
  83.      * @deprecated This property is deprecated and will be removed in Doctrine DBAL 4.0.
  84.      *
  85.      * @var string[]|null
  86.      */
  87.     protected $doctrineTypeComments;
  89.     /** @var EventManager|null */
  90.     protected $_eventManager;
  92.     /**
  93.      * Holds the KeywordList instance for the current platform.
  94.      *
  95.      * @var KeywordList|null
  96.      */
  97.     protected $_keywords;
  99.     /**
  100.      * Sets the EventManager used by the Platform.
  101.      *
  102.      * @return void
  103.      */
  104.     public function setEventManager(EventManager $eventManager)
  105.     {
  106.         $this->_eventManager = $eventManager;
  107.     }
  109.     /**
  110.      * Gets the EventManager used by the Platform.
  111.      *
  112.      * @return EventManager|null
  113.      */
  114.     public function getEventManager()
  115.     {
  116.         return $this->_eventManager;
  117.     }
  119.     /**
  120.      * Returns the SQL snippet that declares a boolean column.
  121.      *
  122.      * @param mixed[] $column
  123.      *
  124.      * @return string
  125.      */
  126.     abstract public function getBooleanTypeDeclarationSQL(array $column);
  128.     /**
  129.      * Returns the SQL snippet that declares a 4 byte integer column.
  130.      *
  131.      * @param mixed[] $column
  132.      *
  133.      * @return string
  134.      */
  135.     abstract public function getIntegerTypeDeclarationSQL(array $column);
  137.     /**
  138.      * Returns the SQL snippet that declares an 8 byte integer column.
  139.      *
  140.      * @param mixed[] $column
  141.      *
  142.      * @return string
  143.      */
  144.     abstract public function getBigIntTypeDeclarationSQL(array $column);
  146.     /**
  147.      * Returns the SQL snippet that declares a 2 byte integer column.
  148.      *
  149.      * @param mixed[] $column
  150.      *
  151.      * @return string
  152.      */
  153.     abstract public function getSmallIntTypeDeclarationSQL(array $column);
  155.     /**
  156.      * Returns the SQL snippet that declares common properties of an integer column.
  157.      *
  158.      * @param mixed[] $column
  159.      *
  160.      * @return string
  161.      */
  162.     abstract protected function _getCommonIntegerTypeDeclarationSQL(array $column);
  164.     /**
  165.      * Lazy load Doctrine Type Mappings.
  166.      *
  167.      * @return void
  168.      */
  169.     abstract protected function initializeDoctrineTypeMappings();
  171.     /**
  172.      * Initializes Doctrine Type Mappings with the platform defaults
  173.      * and with all additional type mappings.
  174.      */
  175.     private function initializeAllDoctrineTypeMappings(): void
  176.     {
  177.         $this->initializeDoctrineTypeMappings();
  179.         foreach (Type::getTypesMap() as $typeName => $className) {
  180.             foreach (Type::getType($typeName)->getMappedDatabaseTypes($this) as $dbType) {
  181.                 $this->doctrineTypeMapping[$dbType] = $typeName;
  182.             }
  183.         }
  184.     }
  186.     /**
  187.      * Returns the SQL snippet used to declare a column that can
  188.      * store characters in the ASCII character set
  189.      *
  190.      * @param mixed[] $column
  191.      */
  192.     public function getAsciiStringTypeDeclarationSQL(array $column): string
  193.     {
  194.         return $this->getVarcharTypeDeclarationSQL($column);
  195.     }
  197.     /**
  198.      * Returns the SQL snippet used to declare a VARCHAR column type.
  199.      *
  200.      * @param mixed[] $column
  201.      *
  202.      * @return string
  203.      */
  204.     public function getVarcharTypeDeclarationSQL(array $column)
  205.     {
  206.         if (! isset($column['length'])) {
  207.             $column['length'] = $this->getVarcharDefaultLength();
  208.         }
  210.         $fixed = $column['fixed'] ?? false;
  212.         $maxLength = $fixed
  213.             ? $this->getCharMaxLength()
  214.             : $this->getVarcharMaxLength();
  216.         if ($column['length'] > $maxLength) {
  217.             return $this->getClobTypeDeclarationSQL($column);
  218.         }
  220.         return $this->getVarcharTypeDeclarationSQLSnippet($column['length'], $fixed);
  221.     }
  223.     /**
  224.      * Returns the SQL snippet used to declare a BINARY/VARBINARY column type.
  225.      *
  226.      * @param mixed[] $column The column definition.
  227.      *
  228.      * @return string
  229.      */
  230.     public function getBinaryTypeDeclarationSQL(array $column)
  231.     {
  232.         if (! isset($column['length'])) {
  233.             $column['length'] = $this->getBinaryDefaultLength();
  234.         }
  236.         $fixed = $column['fixed'] ?? false;
  238.         $maxLength = $this->getBinaryMaxLength();
  240.         if ($column['length'] > $maxLength) {
  241.             if ($maxLength > 0) {
  242.                 Deprecation::trigger(
  243.                     'doctrine/dbal',
  244.                     'https://github.com/doctrine/dbal/issues/3187',
  245.                     'Binary column length %d is greater than supported by the platform (%d).'
  246.                         . ' Reduce the column length or use a BLOB column instead.',
  247.                     $column['length'],
  248.                     $maxLength
  249.                 );
  250.             }
  252.             return $this->getBlobTypeDeclarationSQL($column);
  253.         }
  255.         return $this->getBinaryTypeDeclarationSQLSnippet($column['length'], $fixed);
  256.     }
  258.     /**
  259.      * Returns the SQL snippet to declare a GUID/UUID column.
  260.      *
  261.      * By default this maps directly to a CHAR(36) and only maps to more
  262.      * special datatypes when the underlying databases support this datatype.
  263.      *
  264.      * @param mixed[] $column
  265.      *
  266.      * @return string
  267.      */
  268.     public function getGuidTypeDeclarationSQL(array $column)
  269.     {
  270.         $column['length'] = 36;
  271.         $column['fixed']  = true;
  273.         return $this->getVarcharTypeDeclarationSQL($column);
  274.     }
  276.     /**
  277.      * Returns the SQL snippet to declare a JSON column.
  278.      *
  279.      * By default this maps directly to a CLOB and only maps to more
  280.      * special datatypes when the underlying databases support this datatype.
  281.      *
  282.      * @param mixed[] $column
  283.      *
  284.      * @return string
  285.      */
  286.     public function getJsonTypeDeclarationSQL(array $column)
  287.     {
  288.         return $this->getClobTypeDeclarationSQL($column);
  289.     }
  291.     /**
  292.      * @param int|false $length
  293.      * @param bool      $fixed
  294.      *
  295.      * @return string
  296.      *
  297.      * @throws Exception If not supported on this platform.
  298.      */
  299.     protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed)
  300.     {
  301.         throw Exception::notSupported('VARCHARs not supported by Platform.');
  302.     }
  304.     /**
  305.      * Returns the SQL snippet used to declare a BINARY/VARBINARY column type.
  306.      *
  307.      * @param int|false $length The length of the column.
  308.      * @param bool      $fixed  Whether the column length is fixed.
  309.      *
  310.      * @return string
  311.      *
  312.      * @throws Exception If not supported on this platform.
  313.      */
  314.     protected function getBinaryTypeDeclarationSQLSnippet($length, $fixed)
  315.     {
  316.         throw Exception::notSupported('BINARY/VARBINARY column types are not supported by this platform.');
  317.     }
  319.     /**
  320.      * Returns the SQL snippet used to declare a CLOB column type.
  321.      *
  322.      * @param mixed[] $column
  323.      *
  324.      * @return string
  325.      */
  326.     abstract public function getClobTypeDeclarationSQL(array $column);
  328.     /**
  329.      * Returns the SQL Snippet used to declare a BLOB column type.
  330.      *
  331.      * @param mixed[] $column
  332.      *
  333.      * @return string
  334.      */
  335.     abstract public function getBlobTypeDeclarationSQL(array $column);
  337.     /**
  338.      * Gets the name of the platform.
  339.      *
  340.      * @deprecated Identify platforms by their class.
  341.      *
  342.      * @return string
  343.      */
  344.     abstract public function getName();
  346.     /**
  347.      * Registers a doctrine type to be used in conjunction with a column type of this platform.
  348.      *
  349.      * @param string $dbType
  350.      * @param string $doctrineType
  351.      *
  352.      * @return void
  353.      *
  354.      * @throws Exception If the type is not found.
  355.      */
  356.     public function registerDoctrineTypeMapping($dbType, $doctrineType)
  357.     {
  358.         if ($this->doctrineTypeMapping === null) {
  359.             $this->initializeAllDoctrineTypeMappings();
  360.         }
  362.         if (! Types\Type::hasType($doctrineType)) {
  363.             throw Exception::typeNotFound($doctrineType);
  364.         }
  366.         $dbType                             = strtolower($dbType);
  367.         $this->doctrineTypeMapping[$dbType] = $doctrineType;
  369.         $doctrineType = Type::getType($doctrineType);
  371.         if (! $doctrineType->requiresSQLCommentHint($this)) {
  372.             return;
  373.         }
  375.         $this->markDoctrineTypeCommented($doctrineType);
  376.     }
  378.     /**
  379.      * Gets the Doctrine type that is mapped for the given database column type.
  380.      *
  381.      * @param string $dbType
  382.      *
  383.      * @return string
  384.      *
  385.      * @throws Exception
  386.      */
  387.     public function getDoctrineTypeMapping($dbType)
  388.     {
  389.         if ($this->doctrineTypeMapping === null) {
  390.             $this->initializeAllDoctrineTypeMappings();
  391.         }
  393.         $dbType = strtolower($dbType);
  395.         if (! isset($this->doctrineTypeMapping[$dbType])) {
  396.             throw new Exception(
  397.                 'Unknown database type ' . $dbType . ' requested, ' . static::class . ' may not support it.'
  398.             );
  399.         }
  401.         return $this->doctrineTypeMapping[$dbType];
  402.     }
  404.     /**
  405.      * Checks if a database type is currently supported by this platform.
  406.      *
  407.      * @param string $dbType
  408.      *
  409.      * @return bool
  410.      */
  411.     public function hasDoctrineTypeMappingFor($dbType)
  412.     {
  413.         if ($this->doctrineTypeMapping === null) {
  414.             $this->initializeAllDoctrineTypeMappings();
  415.         }
  417.         $dbType = strtolower($dbType);
  419.         return isset($this->doctrineTypeMapping[$dbType]);
  420.     }
  422.     /**
  423.      * Initializes the Doctrine Type comments instance variable for in_array() checks.
  424.      *
  425.      * @deprecated This API will be removed in Doctrine DBAL 4.0.
  426.      *
  427.      * @return void
  428.      */
  429.     protected function initializeCommentedDoctrineTypes()
  430.     {
  431.         Deprecation::triggerIfCalledFromOutside(
  432.             'doctrine/dbal',
  433.             'https://github.com/doctrine/dbal/pull/5058',
  434.             '%s is deprecated and will be removed in Doctrine DBAL 4.0.',
  435.             __METHOD__
  436.         );
  438.         $this->doctrineTypeComments = [];
  440.         foreach (Type::getTypesMap() as $typeName => $className) {
  441.             $type = Type::getType($typeName);
  443.             if (! $type->requiresSQLCommentHint($this)) {
  444.                 continue;
  445.             }
  447.             $this->doctrineTypeComments[] = $typeName;
  448.         }
  449.     }
  451.     /**
  452.      * Is it necessary for the platform to add a parsable type comment to allow reverse engineering the given type?
  453.      *
  454.      * @deprecated Use {@link Type::requiresSQLCommentHint()} instead.
  455.      *
  456.      * @return bool
  457.      */
  458.     public function isCommentedDoctrineType(Type $doctrineType)
  459.     {
  460.         Deprecation::triggerIfCalledFromOutside(
  461.             'doctrine/dbal',
  462.             'https://github.com/doctrine/dbal/pull/5058',
  463.             '%s is deprecated and will be removed in Doctrine DBAL 4.0. Use Type::requiresSQLCommentHint() instead.',
  464.             __METHOD__
  465.         );
  467.         if ($this->doctrineTypeComments === null) {
  468.             $this->initializeCommentedDoctrineTypes();
  469.         }
  471.         return $doctrineType->requiresSQLCommentHint($this);
  472.     }
  474.     /**
  475.      * Marks this type as to be commented in ALTER TABLE and CREATE TABLE statements.
  476.      *
  477.      * @param string|Type $doctrineType
  478.      *
  479.      * @return void
  480.      */
  481.     public function markDoctrineTypeCommented($doctrineType)
  482.     {
  483.         Deprecation::triggerIfCalledFromOutside(
  484.             'doctrine/dbal',
  485.             'https://github.com/doctrine/dbal/pull/5058',
  486.             '%s is deprecated and will be removed in Doctrine DBAL 4.0. Use Type::requiresSQLCommentHint() instead.',
  487.             __METHOD__
  488.         );
  490.         if ($this->doctrineTypeComments === null) {
  491.             $this->initializeCommentedDoctrineTypes();
  492.         }
  494.         assert(is_array($this->doctrineTypeComments));
  496.         $this->doctrineTypeComments[] = $doctrineType instanceof Type ? $doctrineType->getName() : $doctrineType;
  497.     }
  499.     /**
  500.      * Gets the comment to append to a column comment that helps parsing this type in reverse engineering.
  501.      *
  502.      * @return string
  503.      */
  504.     public function getDoctrineTypeComment(Type $doctrineType)
  505.     {
  506.         return '(DC2Type:' . $doctrineType->getName() . ')';
  507.     }
  509.     /**
  510.      * Gets the comment of a passed column modified by potential doctrine type comment hints.
  511.      *
  512.      * @return string|null
  513.      */
  514.     protected function getColumnComment(Column $column)
  515.     {
  516.         $comment = $column->getComment();
  518.         if ($column->getType()->requiresSQLCommentHint($this)) {
  519.             $comment .= $this->getDoctrineTypeComment($column->getType());
  520.         }
  522.         return $comment;
  523.     }
  525.     /**
  526.      * Gets the character used for identifier quoting.
  527.      *
  528.      * @return string
  529.      */
  530.     public function getIdentifierQuoteCharacter()
  531.     {
  532.         return '"';
  533.     }
  535.     /**
  536.      * Gets the string portion that starts an SQL comment.
  537.      *
  538.      * @deprecated
  539.      *
  540.      * @return string
  541.      */
  542.     public function getSqlCommentStartString()
  543.     {
  544.         Deprecation::trigger(
  545.             'doctrine/dbal',
  546.             'https://github.com/doctrine/dbal/pulls/4724',
  547.             'AbstractPlatform::getSqlCommentStartString() is deprecated.'
  548.         );
  550.         return '--';
  551.     }
  553.     /**
  554.      * Gets the string portion that ends an SQL comment.
  555.      *
  556.      * @deprecated
  557.      *
  558.      * @return string
  559.      */
  560.     public function getSqlCommentEndString()
  561.     {
  562.         Deprecation::trigger(
  563.             'doctrine/dbal',
  564.             'https://github.com/doctrine/dbal/pulls/4724',
  565.             'AbstractPlatform::getSqlCommentEndString() is deprecated.'
  566.         );
  568.         return "\n";
  569.     }
  571.     /**
  572.      * Gets the maximum length of a char column.
  573.      *
  574.      * @deprecated
  575.      */
  576.     public function getCharMaxLength(): int
  577.     {
  578.         Deprecation::triggerIfCalledFromOutside(
  579.             'doctrine/dbal',
  580.             'https://github.com/doctrine/dbal/issues/3263',
  581.             'AbstractPlatform::getCharMaxLength() is deprecated.'
  582.         );
  584.         return $this->getVarcharMaxLength();
  585.     }
  587.     /**
  588.      * Gets the maximum length of a varchar column.
  589.      *
  590.      * @deprecated
  591.      *
  592.      * @return int
  593.      */
  594.     public function getVarcharMaxLength()
  595.     {
  596.         Deprecation::triggerIfCalledFromOutside(
  597.             'doctrine/dbal',
  598.             'https://github.com/doctrine/dbal/issues/3263',
  599.             'AbstractPlatform::getVarcharMaxLength() is deprecated.'
  600.         );
  602.         return 4000;
  603.     }
  605.     /**
  606.      * Gets the default length of a varchar column.
  607.      *
  608.      * @deprecated
  609.      *
  610.      * @return int
  611.      */
  612.     public function getVarcharDefaultLength()
  613.     {
  614.         Deprecation::triggerIfCalledFromOutside(
  615.             'doctrine/dbal',
  616.             'https://github.com/doctrine/dbal/issues/3263',
  617.             'Relying on the default varchar column length is deprecated, specify the length explicitly.'
  618.         );
  620.         return 255;
  621.     }
  623.     /**
  624.      * Gets the maximum length of a binary column.
  625.      *
  626.      * @deprecated
  627.      *
  628.      * @return int
  629.      */
  630.     public function getBinaryMaxLength()
  631.     {
  632.         Deprecation::triggerIfCalledFromOutside(
  633.             'doctrine/dbal',
  634.             'https://github.com/doctrine/dbal/issues/3263',
  635.             'AbstractPlatform::getBinaryMaxLength() is deprecated.'
  636.         );
  638.         return 4000;
  639.     }
  641.     /**
  642.      * Gets the default length of a binary column.
  643.      *
  644.      * @deprecated
  645.      *
  646.      * @return int
  647.      */
  648.     public function getBinaryDefaultLength()
  649.     {
  650.         Deprecation::trigger(
  651.             'doctrine/dbal',
  652.             'https://github.com/doctrine/dbal/issues/3263',
  653.             'Relying on the default binary column length is deprecated, specify the length explicitly.'
  654.         );
  656.         return 255;
  657.     }
  659.     /**
  660.      * Gets all SQL wildcard characters of the platform.
  661.      *
  662.      * @deprecated Use {@see AbstractPlatform::getLikeWildcardCharacters()} instead.
  663.      *
  664.      * @return string[]
  665.      */
  666.     public function getWildcards()
  667.     {
  668.         Deprecation::trigger(
  669.             'doctrine/dbal',
  670.             'https://github.com/doctrine/dbal/pulls/4724',
  671.             'AbstractPlatform::getWildcards() is deprecated.'
  672.             . ' Use AbstractPlatform::getLikeWildcardCharacters() instead.'
  673.         );
  675.         return ['%', '_'];
  676.     }
  678.     /**
  679.      * Returns the regular expression operator.
  680.      *
  681.      * @return string
  682.      *
  683.      * @throws Exception If not supported on this platform.
  684.      */
  685.     public function getRegexpExpression()
  686.     {
  687.         throw Exception::notSupported(__METHOD__);
  688.     }
  690.     /**
  691.      * Returns the SQL snippet to get the average value of a column.
  692.      *
  693.      * @deprecated Use AVG() in SQL instead.
  694.      *
  695.      * @param string $column The column to use.
  696.      *
  697.      * @return string Generated SQL including an AVG aggregate function.
  698.      */
  699.     public function getAvgExpression($column)
  700.     {
  701.         Deprecation::trigger(
  702.             'doctrine/dbal',
  703.             'https://github.com/doctrine/dbal/pulls/4724',
  704.             'AbstractPlatform::getAvgExpression() is deprecated. Use AVG() in SQL instead.'
  705.         );
  707.         return 'AVG(' . $column . ')';
  708.     }
  710.     /**
  711.      * Returns the SQL snippet to get the number of rows (without a NULL value) of a column.
  712.      *
  713.      * If a '*' is used instead of a column the number of selected rows is returned.
  714.      *
  715.      * @deprecated Use COUNT() in SQL instead.
  716.      *
  717.      * @param string|int $column The column to use.
  718.      *
  719.      * @return string Generated SQL including a COUNT aggregate function.
  720.      */
  721.     public function getCountExpression($column)
  722.     {
  723.         Deprecation::trigger(
  724.             'doctrine/dbal',
  725.             'https://github.com/doctrine/dbal/pulls/4724',
  726.             'AbstractPlatform::getCountExpression() is deprecated. Use COUNT() in SQL instead.'
  727.         );
  729.         return 'COUNT(' . $column . ')';
  730.     }
  732.     /**
  733.      * Returns the SQL snippet to get the highest value of a column.
  734.      *
  735.      * @deprecated Use MAX() in SQL instead.
  736.      *
  737.      * @param string $column The column to use.
  738.      *
  739.      * @return string Generated SQL including a MAX aggregate function.
  740.      */
  741.     public function getMaxExpression($column)
  742.     {
  743.         Deprecation::trigger(
  744.             'doctrine/dbal',
  745.             'https://github.com/doctrine/dbal/pulls/4724',
  746.             'AbstractPlatform::getMaxExpression() is deprecated. Use MAX() in SQL instead.'
  747.         );
  749.         return 'MAX(' . $column . ')';
  750.     }
  752.     /**
  753.      * Returns the SQL snippet to get the lowest value of a column.
  754.      *
  755.      * @deprecated Use MIN() in SQL instead.
  756.      *
  757.      * @param string $column The column to use.
  758.      *
  759.      * @return string Generated SQL including a MIN aggregate function.
  760.      */
  761.     public function getMinExpression($column)
  762.     {
  763.         Deprecation::trigger(
  764.             'doctrine/dbal',
  765.             'https://github.com/doctrine/dbal/pulls/4724',
  766.             'AbstractPlatform::getMinExpression() is deprecated. Use MIN() in SQL instead.'
  767.         );
  769.         return 'MIN(' . $column . ')';
  770.     }
  772.     /**
  773.      * Returns the SQL snippet to get the total sum of a column.
  774.      *
  775.      * @deprecated Use SUM() in SQL instead.
  776.      *
  777.      * @param string $column The column to use.
  778.      *
  779.      * @return string Generated SQL including a SUM aggregate function.
  780.      */
  781.     public function getSumExpression($column)
  782.     {
  783.         Deprecation::trigger(
  784.             'doctrine/dbal',
  785.             'https://github.com/doctrine/dbal/pulls/4724',
  786.             'AbstractPlatform::getSumExpression() is deprecated. Use SUM() in SQL instead.'
  787.         );
  789.         return 'SUM(' . $column . ')';
  790.     }
  792.     // scalar functions
  794.     /**
  795.      * Returns the SQL snippet to get the md5 sum of a column.
  796.      *
  797.      * Note: Not SQL92, but common functionality.
  798.      *
  799.      * @deprecated
  800.      *
  801.      * @param string $column
  802.      *
  803.      * @return string
  804.      */
  805.     public function getMd5Expression($column)
  806.     {
  807.         Deprecation::trigger(
  808.             'doctrine/dbal',
  809.             'https://github.com/doctrine/dbal/pulls/4724',
  810.             'AbstractPlatform::getMd5Expression() is deprecated.'
  811.         );
  813.         return 'MD5(' . $column . ')';
  814.     }
  816.     /**
  817.      * Returns the SQL snippet to get the length of a text column in characters.
  818.      *
  819.      * @param string $column
  820.      *
  821.      * @return string
  822.      */
  823.     public function getLengthExpression($column)
  824.     {
  825.         return 'LENGTH(' . $column . ')';
  826.     }
  828.     /**
  829.      * Returns the SQL snippet to get the squared value of a column.
  830.      *
  831.      * @deprecated Use SQRT() in SQL instead.
  832.      *
  833.      * @param string $column The column to use.
  834.      *
  835.      * @return string Generated SQL including an SQRT aggregate function.
  836.      */
  837.     public function getSqrtExpression($column)
  838.     {
  839.         Deprecation::trigger(
  840.             'doctrine/dbal',
  841.             'https://github.com/doctrine/dbal/pulls/4724',
  842.             'AbstractPlatform::getSqrtExpression() is deprecated. Use SQRT() in SQL instead.'
  843.         );
  845.         return 'SQRT(' . $column . ')';
  846.     }
  848.     /**
  849.      * Returns the SQL snippet to round a numeric column to the number of decimals specified.
  850.      *
  851.      * @deprecated Use ROUND() in SQL instead.
  852.      *
  853.      * @param string     $column
  854.      * @param string|int $decimals
  855.      *
  856.      * @return string
  857.      */
  858.     public function getRoundExpression($column, $decimals = 0)
  859.     {
  860.         Deprecation::trigger(
  861.             'doctrine/dbal',
  862.             'https://github.com/doctrine/dbal/pulls/4724',
  863.             'AbstractPlatform::getRoundExpression() is deprecated. Use ROUND() in SQL instead.'
  864.         );
  866.         return 'ROUND(' . $column . ', ' . $decimals . ')';
  867.     }
  869.     /**
  870.      * Returns the SQL snippet to get the remainder of the division operation $expression1 / $expression2.
  871.      *
  872.      * @param string $expression1
  873.      * @param string $expression2
  874.      *
  875.      * @return string
  876.      */
  877.     public function getModExpression($expression1, $expression2)
  878.     {
  879.         return 'MOD(' . $expression1 . ', ' . $expression2 . ')';
  880.     }
  882.     /**
  883.      * Returns the SQL snippet to trim a string.
  884.      *
  885.      * @param string      $str  The expression to apply the trim to.
  886.      * @param int         $mode The position of the trim (leading/trailing/both).
  887.      * @param string|bool $char The char to trim, has to be quoted already. Defaults to space.
  888.      *
  889.      * @return string
  890.      */
  891.     public function getTrimExpression($str, $mode = TrimMode::UNSPECIFIED, $char = false)
  892.     {
  893.         $expression = '';
  895.         switch ($mode) {
  896.             case TrimMode::LEADING:
  897.                 $expression = 'LEADING ';
  898.                 break;
  900.             case TrimMode::TRAILING:
  901.                 $expression = 'TRAILING ';
  902.                 break;
  904.             case TrimMode::BOTH:
  905.                 $expression = 'BOTH ';
  906.                 break;
  907.         }
  909.         if ($char !== false) {
  910.             $expression .= $char . ' ';
  911.         }
  913.         if ($mode !== TrimMode::UNSPECIFIED || $char !== false) {
  914.             $expression .= 'FROM ';
  915.         }
  917.         return 'TRIM(' . $expression . $str . ')';
  918.     }
  920.     /**
  921.      * Returns the SQL snippet to trim trailing space characters from the expression.
  922.      *
  923.      * @deprecated Use RTRIM() in SQL instead.
  924.      *
  925.      * @param string $str Literal string or column name.
  926.      *
  927.      * @return string
  928.      */
  929.     public function getRtrimExpression($str)
  930.     {
  931.         Deprecation::trigger(
  932.             'doctrine/dbal',
  933.             'https://github.com/doctrine/dbal/pulls/4724',
  934.             'AbstractPlatform::getRtrimExpression() is deprecated. Use RTRIM() in SQL instead.'
  935.         );
  937.         return 'RTRIM(' . $str . ')';
  938.     }
  940.     /**
  941.      * Returns the SQL snippet to trim leading space characters from the expression.
  942.      *
  943.      * @deprecated Use LTRIM() in SQL instead.
  944.      *
  945.      * @param string $str Literal string or column name.
  946.      *
  947.      * @return string
  948.      */
  949.     public function getLtrimExpression($str)
  950.     {
  951.         Deprecation::trigger(
  952.             'doctrine/dbal',
  953.             'https://github.com/doctrine/dbal/pulls/4724',
  954.             'AbstractPlatform::getLtrimExpression() is deprecated. Use LTRIM() in SQL instead.'
  955.         );
  957.         return 'LTRIM(' . $str . ')';
  958.     }
  960.     /**
  961.      * Returns the SQL snippet to change all characters from the expression to uppercase,
  962.      * according to the current character set mapping.
  963.      *
  964.      * @deprecated Use UPPER() in SQL instead.
  965.      *
  966.      * @param string $str Literal string or column name.
  967.      *
  968.      * @return string
  969.      */
  970.     public function getUpperExpression($str)
  971.     {
  972.         Deprecation::trigger(
  973.             'doctrine/dbal',
  974.             'https://github.com/doctrine/dbal/pulls/4724',
  975.             'AbstractPlatform::getUpperExpression() is deprecated. Use UPPER() in SQL instead.'
  976.         );
  978.         return 'UPPER(' . $str . ')';
  979.     }
  981.     /**
  982.      * Returns the SQL snippet to change all characters from the expression to lowercase,
  983.      * according to the current character set mapping.
  984.      *
  985.      * @deprecated Use LOWER() in SQL instead.
  986.      *
  987.      * @param string $str Literal string or column name.
  988.      *
  989.      * @return string
  990.      */
  991.     public function getLowerExpression($str)
  992.     {
  993.         Deprecation::trigger(
  994.             'doctrine/dbal',
  995.             'https://github.com/doctrine/dbal/pulls/4724',
  996.             'AbstractPlatform::getLowerExpression() is deprecated. Use LOWER() in SQL instead.'
  997.         );
  999.         return 'LOWER(' . $str . ')';
  1000.     }
  1002.     /**
  1003.      * Returns the SQL snippet to get the position of the first occurrence of substring $substr in string $str.
  1004.      *
  1005.      * @param string           $str      Literal string.
  1006.      * @param string           $substr   Literal string to find.
  1007.      * @param string|int|false $startPos Position to start at, beginning of string by default.
  1008.      *
  1009.      * @return string
  1010.      *
  1011.      * @throws Exception If not supported on this platform.
  1012.      */
  1013.     public function getLocateExpression($str, $substr, $startPos = false)
  1014.     {
  1015.         throw Exception::notSupported(__METHOD__);
  1016.     }
  1018.     /**
  1019.      * Returns the SQL snippet to get the current system date.
  1020.      *
  1021.      * @deprecated Generate dates within the application.
  1022.      *
  1023.      * @return string
  1024.      */
  1025.     public function getNowExpression()
  1026.     {
  1027.         Deprecation::trigger(
  1028.             'doctrine/dbal',
  1029.             'https://github.com/doctrine/dbal/pull/4753',
  1030.             'AbstractPlatform::getNowExpression() is deprecated. Generate dates within the application.'
  1031.         );
  1033.         return 'NOW()';
  1034.     }
  1036.     /**
  1037.      * Returns a SQL snippet to get a substring inside an SQL statement.
  1038.      *
  1039.      * Note: Not SQL92, but common functionality.
  1040.      *
  1041.      * SQLite only supports the 2 parameter variant of this function.
  1042.      *
  1043.      * @param string          $string An sql string literal or column name/alias.
  1044.      * @param string|int      $start  Where to start the substring portion.
  1045.      * @param string|int|null $length The substring portion length.
  1046.      *
  1047.      * @return string
  1048.      */
  1049.     public function getSubstringExpression($string, $start, $length = null)
  1050.     {
  1051.         if ($length === null) {
  1052.             return 'SUBSTRING(' . $string . ' FROM ' . $start . ')';
  1053.         }
  1055.         return 'SUBSTRING(' . $string . ' FROM ' . $start . ' FOR ' . $length . ')';
  1056.     }
  1058.     /**
  1059.      * Returns a SQL snippet to concatenate the given expressions.
  1060.      *
  1061.      * Accepts an arbitrary number of string parameters. Each parameter must contain an expression.
  1062.      *
  1063.      * @return string
  1064.      */
  1065.     public function getConcatExpression()
  1066.     {
  1067.         return implode(' || ', func_get_args());
  1068.     }
  1070.     /**
  1071.      * Returns the SQL for a logical not.
  1072.      *
  1073.      * Example:
  1074.      * <code>
  1075.      * $q = new Doctrine_Query();
  1076.      * $e = $q->expr;
  1077.      * $q->select('*')->from('table')
  1078.      *   ->where($e->eq('id', $e->not('null'));
  1079.      * </code>
  1080.      *
  1081.      * @deprecated Use NOT() in SQL instead.
  1082.      *
  1083.      * @param string $expression
  1084.      *
  1085.      * @return string The logical expression.
  1086.      */
  1087.     public function getNotExpression($expression)
  1088.     {
  1089.         Deprecation::trigger(
  1090.             'doctrine/dbal',
  1091.             'https://github.com/doctrine/dbal/pulls/4724',
  1092.             'AbstractPlatform::getNotExpression() is deprecated. Use NOT() in SQL instead.'
  1093.         );
  1095.         return 'NOT(' . $expression . ')';
  1096.     }
  1098.     /**
  1099.      * Returns the SQL that checks if an expression is null.
  1100.      *
  1101.      * @deprecated Use IS NULL in SQL instead.
  1102.      *
  1103.      * @param string $expression The expression that should be compared to null.
  1104.      *
  1105.      * @return string The logical expression.
  1106.      */
  1107.     public function getIsNullExpression($expression)
  1108.     {
  1109.         Deprecation::trigger(
  1110.             'doctrine/dbal',
  1111.             'https://github.com/doctrine/dbal/pulls/4724',
  1112.             'AbstractPlatform::getIsNullExpression() is deprecated. Use IS NULL in SQL instead.'
  1113.         );
  1115.         return $expression . ' IS NULL';
  1116.     }
  1118.     /**
  1119.      * Returns the SQL that checks if an expression is not null.
  1120.      *
  1121.      * @deprecated Use IS NOT NULL in SQL instead.
  1122.      *
  1123.      * @param string $expression The expression that should be compared to null.
  1124.      *
  1125.      * @return string The logical expression.
  1126.      */
  1127.     public function getIsNotNullExpression($expression)
  1128.     {
  1129.         Deprecation::trigger(
  1130.             'doctrine/dbal',
  1131.             'https://github.com/doctrine/dbal/pulls/4724',
  1132.             'AbstractPlatform::getIsNotNullExpression() is deprecated. Use IS NOT NULL in SQL instead.'
  1133.         );
  1135.         return $expression . ' IS NOT NULL';
  1136.     }
  1138.     /**
  1139.      * Returns the SQL that checks if an expression evaluates to a value between two values.
  1140.      *
  1141.      * The parameter $expression is checked if it is between $value1 and $value2.
  1142.      *
  1143.      * Note: There is a slight difference in the way BETWEEN works on some databases.
  1144.      * http://www.w3schools.com/sql/sql_between.asp. If you want complete database
  1145.      * independence you should avoid using between().
  1146.      *
  1147.      * @deprecated Use BETWEEN in SQL instead.
  1148.      *
  1149.      * @param string $expression The value to compare to.
  1150.      * @param string $value1     The lower value to compare with.
  1151.      * @param string $value2     The higher value to compare with.
  1152.      *
  1153.      * @return string The logical expression.
  1154.      */
  1155.     public function getBetweenExpression($expression, $value1, $value2)
  1156.     {
  1157.         Deprecation::trigger(
  1158.             'doctrine/dbal',
  1159.             'https://github.com/doctrine/dbal/pulls/4724',
  1160.             'AbstractPlatform::getBetweenExpression() is deprecated. Use BETWEEN in SQL instead.'
  1161.         );
  1163.         return $expression . ' BETWEEN ' . $value1 . ' AND ' . $value2;
  1164.     }
  1166.     /**
  1167.      * Returns the SQL to get the arccosine of a value.
  1168.      *
  1169.      * @deprecated Use ACOS() in SQL instead.
  1170.      *
  1171.      * @param string $value
  1172.      *
  1173.      * @return string
  1174.      */
  1175.     public function getAcosExpression($value)
  1176.     {
  1177.         Deprecation::trigger(
  1178.             'doctrine/dbal',
  1179.             'https://github.com/doctrine/dbal/pulls/4724',
  1180.             'AbstractPlatform::getAcosExpression() is deprecated. Use ACOS() in SQL instead.'
  1181.         );
  1183.         return 'ACOS(' . $value . ')';
  1184.     }
  1186.     /**
  1187.      * Returns the SQL to get the sine of a value.
  1188.      *
  1189.      * @deprecated Use SIN() in SQL instead.
  1190.      *
  1191.      * @param string $value
  1192.      *
  1193.      * @return string
  1194.      */
  1195.     public function getSinExpression($value)
  1196.     {
  1197.         Deprecation::trigger(
  1198.             'doctrine/dbal',
  1199.             'https://github.com/doctrine/dbal/pulls/4724',
  1200.             'AbstractPlatform::getSinExpression() is deprecated. Use SIN() in SQL instead.'
  1201.         );
  1203.         return 'SIN(' . $value . ')';
  1204.     }
  1206.     /**
  1207.      * Returns the SQL to get the PI value.
  1208.      *
  1209.      * @deprecated Use PI() in SQL instead.
  1210.      *
  1211.      * @return string
  1212.      */
  1213.     public function getPiExpression()
  1214.     {
  1215.         Deprecation::trigger(
  1216.             'doctrine/dbal',
  1217.             'https://github.com/doctrine/dbal/pulls/4724',
  1218.             'AbstractPlatform::getPiExpression() is deprecated. Use PI() in SQL instead.'
  1219.         );
  1221.         return 'PI()';
  1222.     }
  1224.     /**
  1225.      * Returns the SQL to get the cosine of a value.
  1226.      *
  1227.      * @deprecated Use COS() in SQL instead.
  1228.      *
  1229.      * @param string $value
  1230.      *
  1231.      * @return string
  1232.      */
  1233.     public function getCosExpression($value)
  1234.     {
  1235.         Deprecation::trigger(
  1236.             'doctrine/dbal',
  1237.             'https://github.com/doctrine/dbal/pulls/4724',
  1238.             'AbstractPlatform::getCosExpression() is deprecated. Use COS() in SQL instead.'
  1239.         );
  1241.         return 'COS(' . $value . ')';
  1242.     }
  1244.     /**
  1245.      * Returns the SQL to calculate the difference in days between the two passed dates.
  1246.      *
  1247.      * Computes diff = date1 - date2.
  1248.      *
  1249.      * @param string $date1
  1250.      * @param string $date2
  1251.      *
  1252.      * @return string
  1253.      *
  1254.      * @throws Exception If not supported on this platform.
  1255.      */
  1256.     public function getDateDiffExpression($date1, $date2)
  1257.     {
  1258.         throw Exception::notSupported(__METHOD__);
  1259.     }
  1261.     /**
  1262.      * Returns the SQL to add the number of given seconds to a date.
  1263.      *
  1264.      * @param string $date
  1265.      * @param int    $seconds
  1266.      *
  1267.      * @return string
  1268.      *
  1269.      * @throws Exception If not supported on this platform.
  1270.      */
  1271.     public function getDateAddSecondsExpression($date, $seconds)
  1272.     {
  1273.         return $this->getDateArithmeticIntervalExpression($date, '+', $seconds, DateIntervalUnit::SECOND);
  1274.     }
  1276.     /**
  1277.      * Returns the SQL to subtract the number of given seconds from a date.
  1278.      *
  1279.      * @param string $date
  1280.      * @param int    $seconds
  1281.      *
  1282.      * @return string
  1283.      *
  1284.      * @throws Exception If not supported on this platform.
  1285.      */
  1286.     public function getDateSubSecondsExpression($date, $seconds)
  1287.     {
  1288.         return $this->getDateArithmeticIntervalExpression($date, '-', $seconds, DateIntervalUnit::SECOND);
  1289.     }
  1291.     /**
  1292.      * Returns the SQL to add the number of given minutes to a date.
  1293.      *
  1294.      * @param string $date
  1295.      * @param int    $minutes
  1296.      *
  1297.      * @return string
  1298.      *
  1299.      * @throws Exception If not supported on this platform.
  1300.      */
  1301.     public function getDateAddMinutesExpression($date, $minutes)
  1302.     {
  1303.         return $this->getDateArithmeticIntervalExpression($date, '+', $minutes, DateIntervalUnit::MINUTE);
  1304.     }
  1306.     /**
  1307.      * Returns the SQL to subtract the number of given minutes from a date.
  1308.      *
  1309.      * @param string $date
  1310.      * @param int    $minutes
  1311.      *
  1312.      * @return string
  1313.      *
  1314.      * @throws Exception If not supported on this platform.
  1315.      */
  1316.     public function getDateSubMinutesExpression($date, $minutes)
  1317.     {
  1318.         return $this->getDateArithmeticIntervalExpression($date, '-', $minutes, DateIntervalUnit::MINUTE);
  1319.     }
  1321.     /**
  1322.      * Returns the SQL to add the number of given hours to a date.
  1323.      *
  1324.      * @param string $date
  1325.      * @param int    $hours
  1326.      *
  1327.      * @return string
  1328.      *
  1329.      * @throws Exception If not supported on this platform.
  1330.      */
  1331.     public function getDateAddHourExpression($date, $hours)
  1332.     {
  1333.         return $this->getDateArithmeticIntervalExpression($date, '+', $hours, DateIntervalUnit::HOUR);
  1334.     }
  1336.     /**
  1337.      * Returns the SQL to subtract the number of given hours to a date.
  1338.      *
  1339.      * @param string $date
  1340.      * @param int    $hours
  1341.      *
  1342.      * @return string
  1343.      *
  1344.      * @throws Exception If not supported on this platform.
  1345.      */
  1346.     public function getDateSubHourExpression($date, $hours)
  1347.     {
  1348.         return $this->getDateArithmeticIntervalExpression($date, '-', $hours, DateIntervalUnit::HOUR);
  1349.     }
  1351.     /**
  1352.      * Returns the SQL to add the number of given days to a date.
  1353.      *
  1354.      * @param string $date
  1355.      * @param int    $days
  1356.      *
  1357.      * @return string
  1358.      *
  1359.      * @throws Exception If not supported on this platform.
  1360.      */
  1361.     public function getDateAddDaysExpression($date, $days)
  1362.     {
  1363.         return $this->getDateArithmeticIntervalExpression($date, '+', $days, DateIntervalUnit::DAY);
  1364.     }
  1366.     /**
  1367.      * Returns the SQL to subtract the number of given days to a date.
  1368.      *
  1369.      * @param string $date
  1370.      * @param int    $days
  1371.      *
  1372.      * @return string
  1373.      *
  1374.      * @throws Exception If not supported on this platform.
  1375.      */
  1376.     public function getDateSubDaysExpression($date, $days)
  1377.     {
  1378.         return $this->getDateArithmeticIntervalExpression($date, '-', $days, DateIntervalUnit::DAY);
  1379.     }
  1381.     /**
  1382.      * Returns the SQL to add the number of given weeks to a date.
  1383.      *
  1384.      * @param string $date
  1385.      * @param int    $weeks
  1386.      *
  1387.      * @return string
  1388.      *
  1389.      * @throws Exception If not supported on this platform.
  1390.      */
  1391.     public function getDateAddWeeksExpression($date, $weeks)
  1392.     {
  1393.         return $this->getDateArithmeticIntervalExpression($date, '+', $weeks, DateIntervalUnit::WEEK);
  1394.     }
  1396.     /**
  1397.      * Returns the SQL to subtract the number of given weeks from a date.
  1398.      *
  1399.      * @param string $date
  1400.      * @param int    $weeks
  1401.      *
  1402.      * @return string
  1403.      *
  1404.      * @throws Exception If not supported on this platform.
  1405.      */
  1406.     public function getDateSubWeeksExpression($date, $weeks)
  1407.     {
  1408.         return $this->getDateArithmeticIntervalExpression($date, '-', $weeks, DateIntervalUnit::WEEK);
  1409.     }
  1411.     /**
  1412.      * Returns the SQL to add the number of given months to a date.
  1413.      *
  1414.      * @param string $date
  1415.      * @param int    $months
  1416.      *
  1417.      * @return string
  1418.      *
  1419.      * @throws Exception If not supported on this platform.
  1420.      */
  1421.     public function getDateAddMonthExpression($date, $months)
  1422.     {
  1423.         return $this->getDateArithmeticIntervalExpression($date, '+', $months, DateIntervalUnit::MONTH);
  1424.     }
  1426.     /**
  1427.      * Returns the SQL to subtract the number of given months to a date.
  1428.      *
  1429.      * @param string $date
  1430.      * @param int    $months
  1431.      *
  1432.      * @return string
  1433.      *
  1434.      * @throws Exception If not supported on this platform.
  1435.      */
  1436.     public function getDateSubMonthExpression($date, $months)
  1437.     {
  1438.         return $this->getDateArithmeticIntervalExpression($date, '-', $months, DateIntervalUnit::MONTH);
  1439.     }
  1441.     /**
  1442.      * Returns the SQL to add the number of given quarters to a date.
  1443.      *
  1444.      * @param string $date
  1445.      * @param int    $quarters
  1446.      *
  1447.      * @return string
  1448.      *
  1449.      * @throws Exception If not supported on this platform.
  1450.      */
  1451.     public function getDateAddQuartersExpression($date, $quarters)
  1452.     {
  1453.         return $this->getDateArithmeticIntervalExpression($date, '+', $quarters, DateIntervalUnit::QUARTER);
  1454.     }
  1456.     /**
  1457.      * Returns the SQL to subtract the number of given quarters from a date.
  1458.      *
  1459.      * @param string $date
  1460.      * @param int    $quarters
  1461.      *
  1462.      * @return string
  1463.      *
  1464.      * @throws Exception If not supported on this platform.
  1465.      */
  1466.     public function getDateSubQuartersExpression($date, $quarters)
  1467.     {
  1468.         return $this->getDateArithmeticIntervalExpression($date, '-', $quarters, DateIntervalUnit::QUARTER);
  1469.     }
  1471.     /**
  1472.      * Returns the SQL to add the number of given years to a date.
  1473.      *
  1474.      * @param string $date
  1475.      * @param int    $years
  1476.      *
  1477.      * @return string
  1478.      *
  1479.      * @throws Exception If not supported on this platform.
  1480.      */
  1481.     public function getDateAddYearsExpression($date, $years)
  1482.     {
  1483.         return $this->getDateArithmeticIntervalExpression($date, '+', $years, DateIntervalUnit::YEAR);
  1484.     }
  1486.     /**
  1487.      * Returns the SQL to subtract the number of given years from a date.
  1488.      *
  1489.      * @param string $date
  1490.      * @param int    $years
  1491.      *
  1492.      * @return string
  1493.      *
  1494.      * @throws Exception If not supported on this platform.
  1495.      */
  1496.     public function getDateSubYearsExpression($date, $years)
  1497.     {
  1498.         return $this->getDateArithmeticIntervalExpression($date, '-', $years, DateIntervalUnit::YEAR);
  1499.     }
  1501.     /**
  1502.      * Returns the SQL for a date arithmetic expression.
  1503.      *
  1504.      * @param string $date     The column or literal representing a date to perform the arithmetic operation on.
  1505.      * @param string $operator The arithmetic operator (+ or -).
  1506.      * @param int    $interval The interval that shall be calculated into the date.
  1507.      * @param string $unit     The unit of the interval that shall be calculated into the date.
  1508.      *                         One of the DATE_INTERVAL_UNIT_* constants.
  1509.      *
  1510.      * @return string
  1511.      *
  1512.      * @throws Exception If not supported on this platform.
  1513.      */
  1514.     protected function getDateArithmeticIntervalExpression($date, $operator, $interval, $unit)
  1515.     {
  1516.         throw Exception::notSupported(__METHOD__);
  1517.     }
  1519.     /**
  1520.      * Returns the SQL bit AND comparison expression.
  1521.      *
  1522.      * @param string $value1
  1523.      * @param string $value2
  1524.      *
  1525.      * @return string
  1526.      */
  1527.     public function getBitAndComparisonExpression($value1, $value2)
  1528.     {
  1529.         return '(' . $value1 . ' & ' . $value2 . ')';
  1530.     }
  1532.     /**
  1533.      * Returns the SQL bit OR comparison expression.
  1534.      *
  1535.      * @param string $value1
  1536.      * @param string $value2
  1537.      *
  1538.      * @return string
  1539.      */
  1540.     public function getBitOrComparisonExpression($value1, $value2)
  1541.     {
  1542.         return '(' . $value1 . ' | ' . $value2 . ')';
  1543.     }
  1545.     /**
  1546.      * Returns the SQL expression which represents the currently selected database.
  1547.      */
  1548.     abstract public function getCurrentDatabaseExpression(): string;
  1550.     /**
  1551.      * Returns the FOR UPDATE expression.
  1552.      *
  1553.      * @return string
  1554.      */
  1555.     public function getForUpdateSQL()
  1556.     {
  1557.         return 'FOR UPDATE';
  1558.     }
  1560.     /**
  1561.      * Honors that some SQL vendors such as MsSql use table hints for locking instead of the
  1562.      * ANSI SQL FOR UPDATE specification.
  1563.      *
  1564.      * @param string $fromClause The FROM clause to append the hint for the given lock mode to
  1565.      * @param int    $lockMode   One of the Doctrine\DBAL\LockMode::* constants
  1566.      * @psalm-param LockMode::* $lockMode
  1567.      */
  1568.     public function appendLockHint(string $fromClause, int $lockMode): string
  1569.     {
  1570.         switch ($lockMode) {
  1571.             case LockMode::NONE:
  1572.             case LockMode::OPTIMISTIC:
  1573.             case LockMode::PESSIMISTIC_READ:
  1574.             case LockMode::PESSIMISTIC_WRITE:
  1575.                 return $fromClause;
  1577.             default:
  1578.                 throw InvalidLockMode::fromLockMode($lockMode);
  1579.         }
  1580.     }
  1582.     /**
  1583.      * Returns the SQL snippet to append to any SELECT statement which locks rows in shared read lock.
  1584.      *
  1585.      * This defaults to the ANSI SQL "FOR UPDATE", which is an exclusive lock (Write). Some database
  1586.      * vendors allow to lighten this constraint up to be a real read lock.
  1587.      *
  1588.      * @return string
  1589.      */
  1590.     public function getReadLockSQL()
  1591.     {
  1592.         return $this->getForUpdateSQL();
  1593.     }
  1595.     /**
  1596.      * Returns the SQL snippet to append to any SELECT statement which obtains an exclusive lock on the rows.
  1597.      *
  1598.      * The semantics of this lock mode should equal the SELECT .. FOR UPDATE of the ANSI SQL standard.
  1599.      *
  1600.      * @return string
  1601.      */
  1602.     public function getWriteLockSQL()
  1603.     {
  1604.         return $this->getForUpdateSQL();
  1605.     }
  1607.     /**
  1608.      * Returns the SQL snippet to drop an existing table.
  1609.      *
  1610.      * @param Table|string $table
  1611.      *
  1612.      * @return string
  1613.      *
  1614.      * @throws InvalidArgumentException
  1615.      */
  1616.     public function getDropTableSQL($table)
  1617.     {
  1618.         $tableArg = $table;
  1620.         if ($table instanceof Table) {
  1621.             $table = $table->getQuotedName($this);
  1622.         }
  1624.         if (! is_string($table)) {
  1625.             throw new InvalidArgumentException(
  1626.                 __METHOD__ . '() expects $table parameter to be string or ' . Table::class . '.'
  1627.             );
  1628.         }
  1630.         if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaDropTable)) {
  1631.             $eventArgs = new SchemaDropTableEventArgs($tableArg, $this);
  1632.             $this->_eventManager->dispatchEvent(Events::onSchemaDropTable, $eventArgs);
  1634.             if ($eventArgs->isDefaultPrevented()) {
  1635.                 $sql = $eventArgs->getSql();
  1637.                 if ($sql === null) {
  1638.                     throw new UnexpectedValueException('Default implementation of DROP TABLE was overridden with NULL');
  1639.                 }
  1641.                 return $sql;
  1642.             }
  1643.         }
  1645.         return 'DROP TABLE ' . $table;
  1646.     }
  1648.     /**
  1649.      * Returns the SQL to safely drop a temporary table WITHOUT implicitly committing an open transaction.
  1650.      *
  1651.      * @param Table|string $table
  1652.      *
  1653.      * @return string
  1654.      */
  1655.     public function getDropTemporaryTableSQL($table)
  1656.     {
  1657.         return $this->getDropTableSQL($table);
  1658.     }
  1660.     /**
  1661.      * Returns the SQL to drop an index from a table.
  1662.      *
  1663.      * @param Index|string      $index
  1664.      * @param Table|string|null $table
  1665.      *
  1666.      * @return string
  1667.      *
  1668.      * @throws InvalidArgumentException
  1669.      */
  1670.     public function getDropIndexSQL($index, $table = null)
  1671.     {
  1672.         if ($index instanceof Index) {
  1673.             $index = $index->getQuotedName($this);
  1674.         } elseif (! is_string($index)) {
  1675.             throw new InvalidArgumentException(
  1676.                 __METHOD__ . '() expects $index parameter to be string or ' . Index::class . '.'
  1677.             );
  1678.         }
  1680.         return 'DROP INDEX ' . $index;
  1681.     }
  1683.     /**
  1684.      * Returns the SQL to drop a constraint.
  1685.      *
  1686.      * @internal The method should be only used from within the {@see AbstractPlatform} class hierarchy.
  1687.      *
  1688.      * @param Constraint|string $constraint
  1689.      * @param Table|string      $table
  1690.      *
  1691.      * @return string
  1692.      */
  1693.     public function getDropConstraintSQL($constraint, $table)
  1694.     {
  1695.         if (! $constraint instanceof Constraint) {
  1696.             $constraint = new Identifier($constraint);
  1697.         }
  1699.         if (! $table instanceof Table) {
  1700.             $table = new Identifier($table);
  1701.         }
  1703.         $constraint = $constraint->getQuotedName($this);
  1704.         $table      = $table->getQuotedName($this);
  1706.         return 'ALTER TABLE ' . $table . ' DROP CONSTRAINT ' . $constraint;
  1707.     }
  1709.     /**
  1710.      * Returns the SQL to drop a foreign key.
  1711.      *
  1712.      * @param ForeignKeyConstraint|string $foreignKey
  1713.      * @param Table|string                $table
  1714.      *
  1715.      * @return string
  1716.      */
  1717.     public function getDropForeignKeySQL($foreignKey, $table)
  1718.     {
  1719.         if (! $foreignKey instanceof ForeignKeyConstraint) {
  1720.             $foreignKey = new Identifier($foreignKey);
  1721.         }
  1723.         if (! $table instanceof Table) {
  1724.             $table = new Identifier($table);
  1725.         }
  1727.         $foreignKey = $foreignKey->getQuotedName($this);
  1728.         $table      = $table->getQuotedName($this);
  1730.         return 'ALTER TABLE ' . $table . ' DROP FOREIGN KEY ' . $foreignKey;
  1731.     }
  1733.     /**
  1734.      * Returns the SQL to drop a unique constraint.
  1735.      */
  1736.     public function getDropUniqueConstraintSQL(string $name, string $tableName): string
  1737.     {
  1738.         return $this->getDropConstraintSQL($name, $tableName);
  1739.     }
  1741.     /**
  1742.      * Returns the SQL statement(s) to create a table with the specified name, columns and constraints
  1743.      * on this platform.
  1744.      *
  1745.      * @param int $createFlags
  1746.      *
  1747.      * @return string[] The sequence of SQL statements.
  1748.      *
  1749.      * @throws Exception
  1750.      * @throws InvalidArgumentException
  1751.      */
  1752.     public function getCreateTableSQL(Table $table, $createFlags = self::CREATE_INDEXES)
  1753.     {
  1754.         if (! is_int($createFlags)) {
  1755.             throw new InvalidArgumentException(
  1756.                 'Second argument of AbstractPlatform::getCreateTableSQL() has to be integer.'
  1757.             );
  1758.         }
  1760.         if (count($table->getColumns()) === 0) {
  1761.             throw Exception::noColumnsSpecifiedForTable($table->getName());
  1762.         }
  1764.         $tableName                    = $table->getQuotedName($this);
  1765.         $options                      = $table->getOptions();
  1766.         $options['uniqueConstraints'] = [];
  1767.         $options['indexes']           = [];
  1768.         $options['primary']           = [];
  1770.         if (($createFlags & self::CREATE_INDEXES) > 0) {
  1771.             foreach ($table->getIndexes() as $index) {
  1772.                 if (! $index->isPrimary()) {
  1773.                     $options['indexes'][$index->getQuotedName($this)] = $index;
  1775.                     continue;
  1776.                 }
  1778.                 $options['primary']       = $index->getQuotedColumns($this);
  1779.                 $options['primary_index'] = $index;
  1780.             }
  1782.             foreach ($table->getUniqueConstraints() as $uniqueConstraint) {
  1783.                 $options['uniqueConstraints'][$uniqueConstraint->getQuotedName($this)] = $uniqueConstraint;
  1784.             }
  1785.         }
  1787.         if (($createFlags & self::CREATE_FOREIGNKEYS) > 0) {
  1788.             $options['foreignKeys'] = [];
  1790.             foreach ($table->getForeignKeys() as $fkConstraint) {
  1791.                 $options['foreignKeys'][] = $fkConstraint;
  1792.             }
  1793.         }
  1795.         $columnSql = [];
  1796.         $columns   = [];
  1798.         foreach ($table->getColumns() as $column) {
  1799.             if (
  1800.                 $this->_eventManager !== null
  1801.                 && $this->_eventManager->hasListeners(Events::onSchemaCreateTableColumn)
  1802.             ) {
  1803.                 $eventArgs = new SchemaCreateTableColumnEventArgs($column, $table, $this);
  1805.                 $this->_eventManager->dispatchEvent(Events::onSchemaCreateTableColumn, $eventArgs);
  1807.                 $columnSql = array_merge($columnSql, $eventArgs->getSql());
  1809.                 if ($eventArgs->isDefaultPrevented()) {
  1810.                     continue;
  1811.                 }
  1812.             }
  1814.             $columnData = $this->columnToArray($column);
  1816.             if (in_array($column->getName(), $options['primary'], true)) {
  1817.                 $columnData['primary'] = true;
  1818.             }
  1820.             $columns[$columnData['name']] = $columnData;
  1821.         }
  1823.         if ($this->_eventManager !== null && $this->_eventManager->hasListeners(Events::onSchemaCreateTable)) {
  1824.             $eventArgs = new SchemaCreateTableEventArgs($table, $columns, $options, $this);
  1826.             $this->_eventManager->dispatchEvent(Events::onSchemaCreateTable, $eventArgs);
  1828.             if ($eventArgs->isDefaultPrevented()) {
  1829.                 return array_merge($eventArgs->getSql(), $columnSql);
  1830.             }
  1831.         }
  1833.         $sql = $this->_getCreateTableSQL($tableName, $columns, $options);
  1835.         if ($this->supportsCommentOnStatement()) {
  1836.             if ($table->hasOption('comment')) {
  1837.                 $sql[] = $this->getCommentOnTableSQL($tableName, $table->getOption('comment'));
  1838.             }
  1840.             foreach ($table->getColumns() as $column) {
  1841.                 $comment = $this->getColumnComment($column);
  1843.                 if ($comment === null || $comment === '') {
  1844.                     continue;
  1845.                 }
  1847.                 $sql[] = $this->getCommentOnColumnSQL($tableName, $column->getQuotedName($this), $comment);
  1848.             }
  1849.         }
  1851.         return array_merge($sql, $columnSql);
  1852.     }
  1854.     protected function getCommentOnTableSQL(string $tableName, ?string $comment): string
  1855.     {
  1856.         $tableName = new Identifier($tableName);
  1858.         return sprintf(
  1859.             'COMMENT ON TABLE %s IS %s',
  1860.             $tableName->getQuotedName($this),
  1861.             $this->quoteStringLiteral((string) $comment)
  1862.         );
  1863.     }
  1865.     /**
  1866.      * @param string      $tableName
  1867.      * @param string      $columnName
  1868.      * @param string|null $comment
  1869.      *
  1870.      * @return string
  1871.      */
  1872.     public function getCommentOnColumnSQL($tableName, $columnName, $comment)
  1873.     {
  1874.         $tableName  = new Identifier($tableName);
  1875.         $columnName = new Identifier($columnName);
  1877.         return sprintf(
  1878.             'COMMENT ON COLUMN %s.%s IS %s',
  1879.             $tableName->getQuotedName($this),
  1880.             $columnName->getQuotedName($this),
  1881.             $this->quoteStringLiteral((string) $comment)
  1882.         );
  1883.     }
  1885.     /**
  1886.      * Returns the SQL to create inline comment on a column.
  1887.      *
  1888.      * @param string $comment
  1889.      *
  1890.      * @return string
  1891.      *
  1892.      * @throws Exception If not supported on this platform.
  1893.      */
  1894.     public function getInlineColumnCommentSQL($comment)
  1895.     {
  1896.         if (! $this->supportsInlineColumnComments()) {
  1897.             throw Exception::notSupported(__METHOD__);
  1898.         }
  1900.         return 'COMMENT ' . $this->quoteStringLiteral($comment);
  1901.     }
  1903.     /**
  1904.      * Returns the SQL used to create a table.
  1905.      *
  1906.      * @param string    $name
  1907.      * @param mixed[][] $columns
  1908.      * @param mixed[]   $options
  1909.      *
  1910.      * @return string[]
  1911.      */
  1912.     protected function _getCreateTableSQL($name, array $columns, array $options = [])
  1913.     {
  1914.         $columnListSql = $this->getColumnDeclarationListSQL($columns);
  1916.         if (isset($options['uniqueConstraints']) && ! empty($options['uniqueConstraints'])) {
  1917.             foreach ($options['uniqueConstraints'] as $index => $definition) {
  1918.                 $columnListSql .= ', ' . $this->getUniqueConstraintDeclarationSQL($index, $definition);
  1919.             }
  1920.         }
  1922.         if (isset($options['primary']) && ! empty($options['primary'])) {
  1923.             $columnListSql .= ', PRIMARY KEY(' . implode(', ', array_unique(array_values($options['primary']))) . ')';
  1924.         }
  1926.         if (isset($options['indexes']) && ! empty($options['indexes'])) {
  1927.             foreach ($options['indexes'] as $index => $definition) {
  1928.                 $columnListSql .= ', ' . $this->getIndexDeclarationSQL($index, $definition);
  1929.             }
  1930.         }
  1932.         $query = 'CREATE TABLE ' . $name . ' (' . $columnListSql;
  1933.         $check = $this->getCheckDeclarationSQL($columns);
  1935.         if (! empty($check)) {
  1936.             $query .= ', ' . $check;
  1937.         }
  1939.         $query .= ')';
  1941.         $sql = [$query];
  1943.         if (isset($options['foreignKeys'])) {
  1944.             foreach ((array) $options['foreignKeys'] as $definition) {
  1945.                 $sql[] = $this->getCreateForeignKeySQL($definition, $name);
  1946.             }
  1947.         }
  1949.         return $sql;
  1950.     }
  1952.     /**
  1953.      * @return string
  1954.      */
  1955.     public function getCreateTemporaryTableSnippetSQL()
  1956.     {
  1957.         return 'CREATE TEMPORARY TABLE';
  1958.     }
  1960.     /**
  1961.      * Returns the SQL to create a sequence on this platform.
  1962.      *
  1963.      * @return string
  1964.      *
  1965.      * @throws Exception If not supported on this platform.
  1966.      */
  1967.     public function getCreateSequenceSQL(Sequence $sequence)
  1968.     {
  1969.         throw Exception::notSupported(__METHOD__);
  1970.     }
  1972.     /**
  1973.      * Returns the SQL to change a sequence on this platform.
  1974.      *
  1975.      * @return string
  1976.      *
  1977.      * @throws Exception If not supported on this platform.
  1978.      */
  1979.     public function getAlterSequenceSQL(Sequence $sequence)
  1980.     {
  1981.         throw Exception::notSupported(__METHOD__);
  1982.     }
  1984.     /**
  1985.      * Returns the SQL snippet to drop an existing sequence.
  1986.      *
  1987.      * @param Sequence|string $sequence
  1988.      *
  1989.      * @return string
  1990.      *
  1991.      * @throws Exception If not supported on this platform.
  1992.      */
  1993.     public function getDropSequenceSQL($sequence)
  1994.     {
  1995.         if (! $this->supportsSequences()) {
  1996.             throw Exception::notSupported(__METHOD__);
  1997.         }
  1999.         if ($sequence instanceof Sequence) {
  2000.             $sequence = $sequence->getQuotedName($this);
  2001.         }
  2003.         return 'DROP SEQUENCE ' . $sequence;
  2004.     }
  2006.     /**
  2007.      * Returns the SQL to create a constraint on a table on this platform.
  2008.      *
  2009.      * @deprecated Use {@see getCreateIndexSQL()}, {@see getCreateForeignKeySQL()}
  2010.      *             or {@see getCreateUniqueConstraintSQL()} instead.
  2011.      *
  2012.      * @param Table|string $table
  2013.      *
  2014.      * @return string
  2015.      *
  2016.      * @throws InvalidArgumentException
  2017.      */
  2018.     public function getCreateConstraintSQL(Constraint $constraint, $table)
  2019.     {
  2020.         if ($table instanceof Table) {
  2021.             $table = $table->getQuotedName($this);
  2022.         }
  2024.         $query = 'ALTER TABLE ' . $table . ' ADD CONSTRAINT ' . $constraint->getQuotedName($this);
  2026.         $columnList = '(' . implode(', ', $constraint->getQuotedColumns($this)) . ')';
  2028.         $referencesClause = '';
  2029.         if ($constraint instanceof Index) {
  2030.             if ($constraint->isPrimary()) {
  2031.                 $query .= ' PRIMARY KEY';
  2032.             } elseif ($constraint->isUnique()) {
  2033.                 $query .= ' UNIQUE';
  2034.             } else {
  2035.                 throw new InvalidArgumentException(
  2036.                     'Can only create primary or unique constraints, no common indexes with getCreateConstraintSQL().'
  2037.                 );
  2038.             }
  2039.         } elseif ($constraint instanceof UniqueConstraint) {
  2040.             $query .= ' UNIQUE';
  2041.         } elseif ($constraint instanceof ForeignKeyConstraint) {
  2042.             $query .= ' FOREIGN KEY';
  2044.             $referencesClause = ' REFERENCES ' . $constraint->getQuotedForeignTableName($this) .
  2045.                 ' (' . implode(', ', $constraint->getQuotedForeignColumns($this)) . ')';
  2046.         }
  2048.         $query .= ' ' . $columnList . $referencesClause;
  2050.         return $query;
  2051.     }
  2053.     /**
  2054.      * Returns the SQL to create an index on a table on this platform.
  2055.      *
  2056.      * @param Table|string $table The name of the table on which the index is to be created.
  2057.      *
  2058.      * @return string
  2059.      *
  2060.      * @throws InvalidArgumentException
  2061.      */
  2062.     public function getCreateIndexSQL(Index $index, $table)
  2063.     {
  2064.         if ($table instanceof Table) {
  2065.             $table = $table->getQuotedName($this);
  2066.         }
  2068.         $name    = $index->getQuotedName($this);
  2069.         $columns = $index->getColumns();
  2071.         if (count($columns) === 0) {
  2072.             throw new InvalidArgumentException("Incomplete definition. 'columns' required.");
  2073.         }
  2075.         if ($index->isPrimary()) {
  2076.             return $this->getCreatePrimaryKeySQL($index, $table);
  2077.         }
  2079.         $query  = 'CREATE ' . $this->getCreateIndexSQLFlags($index) . 'INDEX ' . $name . ' ON ' . $table;
  2080.         $query .= ' (' . $this->getIndexFieldDeclarationListSQL($index) . ')' . $this->getPartialIndexSQL($index);
  2082.         return $query;
  2083.     }
  2085.     /**
  2086.      * Adds condition for partial index.
  2087.      *
  2088.      * @return string
  2089.      */
  2090.     protected function getPartialIndexSQL(Index $index)
  2091.     {
  2092.         if ($this->supportsPartialIndexes() && $index->hasOption('where')) {
  2093.             return ' WHERE ' . $index->getOption('where');
  2094.         }
  2096.         return '';
  2097.     }
  2099.     /**
  2100.      * Adds additional flags for index generation.
  2101.      *
  2102.      * @return string
  2103.      */
  2104.     protected function getCreateIndexSQLFlags(Index $index)
  2105.     {
  2106.         return $index->isUnique() ? 'UNIQUE ' : '';
  2107.     }
  2109.     /**
  2110.      * Returns the SQL to create an unnamed primary key constraint.
  2111.      *
  2112.      * @param Table|string $table
  2113.      *
  2114.      * @return string
  2115.      */
  2116.     public function getCreatePrimaryKeySQL(Index $index, $table)
  2117.     {
  2118.         if ($table instanceof Table) {
  2119.             $table = $table->getQuotedName($this);
  2120.         }
  2122.         return 'ALTER TABLE ' . $table . ' ADD PRIMARY KEY (' . $this->getIndexFieldDeclarationListSQL($index) . ')';
  2123.     }
  2125.     /**
  2126.      * Returns the SQL to create a named schema.
  2127.      *
  2128.      * @param string $schemaName
  2129.      *
  2130.      * @return string
  2131.      *
  2132.      * @throws Exception If not supported on this platform.
  2133.      */
  2134.     public function getCreateSchemaSQL($schemaName)
  2135.     {
  2136.         if (! $this->supportsSchemas()) {
  2137.             throw Exception::notSupported(__METHOD__);
  2138.         }
  2140.         return 'CREATE SCHEMA ' . $schemaName;
  2141.     }
  2143.     /**
  2144.      * Returns the SQL to create a unique constraint on a table on this platform.
  2145.      */
  2146.     public function getCreateUniqueConstraintSQL(UniqueConstraint $constraint, string $tableName): string
  2147.     {
  2148.         return $this->getCreateConstraintSQL($constraint, $tableName);
  2149.     }
  2151.     /**
  2152.      * Returns the SQL snippet to drop a schema.
  2153.      *
  2154.      * @throws Exception If not supported on this platform.
  2155.      */
  2156.     public function getDropSchemaSQL(string $schemaName): string
  2157.     {
  2158.         if (! $this->supportsSchemas()) {
  2159.             throw Exception::notSupported(__METHOD__);
  2160.         }
  2162.         return 'DROP SCHEMA ' . $schemaName;
  2163.     }
  2165.     /**
  2166.      * Quotes a string so that it can be safely used as a table or column name,
  2167.      * even if it is a reserved word of the platform. This also detects identifier
  2168.      * chains separated by dot and quotes them independently.
  2169.      *
  2170.      * NOTE: Just because you CAN use quoted identifiers doesn't mean
  2171.      * you SHOULD use them. In general, they end up causing way more
  2172.      * problems than they solve.
  2173.      *
  2174.      * @param string $str The identifier name to be quoted.
  2175.      *
  2176.      * @return string The quoted identifier string.
  2177.      */
  2178.     public function quoteIdentifier($str)
  2179.     {
  2180.         if (strpos($str, '.') !== false) {
  2181.             $parts = array_map([$this, 'quoteSingleIdentifier'], explode('.', $str));
  2183.             return implode('.', $parts);
  2184.         }
  2186.         return $this->quoteSingleIdentifier($str);
  2187.     }
  2189.     /**
  2190.      * Quotes a single identifier (no dot chain separation).
  2191.      *
  2192.      * @param string $str The identifier name to be quoted.
  2193.      *
  2194.      * @return string The quoted identifier string.
  2195.      */
  2196.     public function quoteSingleIdentifier($str)
  2197.     {
  2198.         $c = $this->getIdentifierQuoteCharacter();
  2200.         return $c . str_replace($c, $c . $c, $str) . $c;
  2201.     }
  2203.     /**
  2204.      * Returns the SQL to create a new foreign key.
  2205.      *
  2206.      * @param ForeignKeyConstraint $foreignKey The foreign key constraint.
  2207.      * @param Table|string         $table      The name of the table on which the foreign key is to be created.
  2208.      *
  2209.      * @return string
  2210.      */
  2211.     public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table)
  2212.     {
  2213.         if ($table instanceof Table) {
  2214.             $table = $table->getQuotedName($this);
  2215.         }
  2217.         return 'ALTER TABLE ' . $table . ' ADD ' . $this->getForeignKeyDeclarationSQL($foreignKey);
  2218.     }
  2220.     /**
  2221.      * Gets the SQL statements for altering an existing table.
  2222.      *
  2223.      * This method returns an array of SQL statements, since some platforms need several statements.
  2224.      *
  2225.      * @return string[]
  2226.      *
  2227.      * @throws Exception If not supported on this platform.
  2228.      */
  2229.     public function getAlterTableSQL(TableDiff $diff)
  2230.     {
  2231.         throw Exception::notSupported(__METHOD__);
  2232.     }
  2234.     /**
  2235.      * @param mixed[] $columnSql
  2236.      *
  2237.      * @return bool
  2238.      */
  2239.     protected function onSchemaAlterTableAddColumn(Column $column, TableDiff $diff, &$columnSql)
  2240.     {
  2241.         if ($this->_eventManager === null) {
  2242.             return false;
  2243.         }
  2245.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableAddColumn)) {
  2246.             return false;
  2247.         }
  2249.         $eventArgs = new SchemaAlterTableAddColumnEventArgs($column, $diff, $this);
  2250.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableAddColumn, $eventArgs);
  2252.         $columnSql = array_merge($columnSql, $eventArgs->getSql());
  2254.         return $eventArgs->isDefaultPrevented();
  2255.     }
  2257.     /**
  2258.      * @param string[] $columnSql
  2259.      *
  2260.      * @return bool
  2261.      */
  2262.     protected function onSchemaAlterTableRemoveColumn(Column $column, TableDiff $diff, &$columnSql)
  2263.     {
  2264.         if ($this->_eventManager === null) {
  2265.             return false;
  2266.         }
  2268.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableRemoveColumn)) {
  2269.             return false;
  2270.         }
  2272.         $eventArgs = new SchemaAlterTableRemoveColumnEventArgs($column, $diff, $this);
  2273.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRemoveColumn, $eventArgs);
  2275.         $columnSql = array_merge($columnSql, $eventArgs->getSql());
  2277.         return $eventArgs->isDefaultPrevented();
  2278.     }
  2280.     /**
  2281.      * @param string[] $columnSql
  2282.      *
  2283.      * @return bool
  2284.      */
  2285.     protected function onSchemaAlterTableChangeColumn(ColumnDiff $columnDiff, TableDiff $diff, &$columnSql)
  2286.     {
  2287.         if ($this->_eventManager === null) {
  2288.             return false;
  2289.         }
  2291.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableChangeColumn)) {
  2292.             return false;
  2293.         }
  2295.         $eventArgs = new SchemaAlterTableChangeColumnEventArgs($columnDiff, $diff, $this);
  2296.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableChangeColumn, $eventArgs);
  2298.         $columnSql = array_merge($columnSql, $eventArgs->getSql());
  2300.         return $eventArgs->isDefaultPrevented();
  2301.     }
  2303.     /**
  2304.      * @param string   $oldColumnName
  2305.      * @param string[] $columnSql
  2306.      *
  2307.      * @return bool
  2308.      */
  2309.     protected function onSchemaAlterTableRenameColumn($oldColumnName, Column $column, TableDiff $diff, &$columnSql)
  2310.     {
  2311.         if ($this->_eventManager === null) {
  2312.             return false;
  2313.         }
  2315.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTableRenameColumn)) {
  2316.             return false;
  2317.         }
  2319.         $eventArgs = new SchemaAlterTableRenameColumnEventArgs($oldColumnName, $column, $diff, $this);
  2320.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTableRenameColumn, $eventArgs);
  2322.         $columnSql = array_merge($columnSql, $eventArgs->getSql());
  2324.         return $eventArgs->isDefaultPrevented();
  2325.     }
  2327.     /**
  2328.      * @param string[] $sql
  2329.      *
  2330.      * @return bool
  2331.      */
  2332.     protected function onSchemaAlterTable(TableDiff $diff, &$sql)
  2333.     {
  2334.         if ($this->_eventManager === null) {
  2335.             return false;
  2336.         }
  2338.         if (! $this->_eventManager->hasListeners(Events::onSchemaAlterTable)) {
  2339.             return false;
  2340.         }
  2342.         $eventArgs = new SchemaAlterTableEventArgs($diff, $this);
  2343.         $this->_eventManager->dispatchEvent(Events::onSchemaAlterTable, $eventArgs);
  2345.         $sql = array_merge($sql, $eventArgs->getSql());
  2347.         return $eventArgs->isDefaultPrevented();
  2348.     }
  2350.     /**
  2351.      * @return string[]
  2352.      */
  2353.     protected function getPreAlterTableIndexForeignKeySQL(TableDiff $diff)
  2354.     {
  2355.         $tableName = $diff->getName($this)->getQuotedName($this);
  2357.         $sql = [];
  2358.         if ($this->supportsForeignKeyConstraints()) {
  2359.             foreach ($diff->removedForeignKeys as $foreignKey) {
  2360.                 $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableName);
  2361.             }
  2363.             foreach ($diff->changedForeignKeys as $foreignKey) {
  2364.                 $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableName);
  2365.             }
  2366.         }
  2368.         foreach ($diff->removedIndexes as $index) {
  2369.             $sql[] = $this->getDropIndexSQL($index, $tableName);
  2370.         }
  2372.         foreach ($diff->changedIndexes as $index) {
  2373.             $sql[] = $this->getDropIndexSQL($index, $tableName);
  2374.         }
  2376.         return $sql;
  2377.     }
  2379.     /**
  2380.      * @return string[]
  2381.      */
  2382.     protected function getPostAlterTableIndexForeignKeySQL(TableDiff $diff)
  2383.     {
  2384.         $sql     = [];
  2385.         $newName = $diff->getNewName();
  2387.         if ($newName !== false) {
  2388.             $tableName = $newName->getQuotedName($this);
  2389.         } else {
  2390.             $tableName = $diff->getName($this)->getQuotedName($this);
  2391.         }
  2393.         if ($this->supportsForeignKeyConstraints()) {
  2394.             foreach ($diff->addedForeignKeys as $foreignKey) {
  2395.                 $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableName);
  2396.             }
  2398.             foreach ($diff->changedForeignKeys as $foreignKey) {
  2399.                 $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableName);
  2400.             }
  2401.         }
  2403.         foreach ($diff->addedIndexes as $index) {
  2404.             $sql[] = $this->getCreateIndexSQL($index, $tableName);
  2405.         }
  2407.         foreach ($diff->changedIndexes as $index) {
  2408.             $sql[] = $this->getCreateIndexSQL($index, $tableName);
  2409.         }
  2411.         foreach ($diff->renamedIndexes as $oldIndexName => $index) {
  2412.             $oldIndexName = new Identifier($oldIndexName);
  2413.             $sql          = array_merge(
  2414.                 $sql,
  2415.                 $this->getRenameIndexSQL($oldIndexName->getQuotedName($this), $index, $tableName)
  2416.             );
  2417.         }
  2419.         return $sql;
  2420.     }
  2422.     /**
  2423.      * Returns the SQL for renaming an index on a table.
  2424.      *
  2425.      * @param string $oldIndexName The name of the index to rename from.
  2426.      * @param Index  $index        The definition of the index to rename to.
  2427.      * @param string $tableName    The table to rename the given index on.
  2428.      *
  2429.      * @return string[] The sequence of SQL statements for renaming the given index.
  2430.      */
  2431.     protected function getRenameIndexSQL($oldIndexName, Index $index, $tableName)
  2432.     {
  2433.         return [
  2434.             $this->getDropIndexSQL($oldIndexName, $tableName),
  2435.             $this->getCreateIndexSQL($index, $tableName),
  2436.         ];
  2437.     }
  2439.     /**
  2440.      * Gets declaration of a number of columns in bulk.
  2441.      *
  2442.      * @param mixed[][] $columns A multidimensional associative array.
  2443.      *                           The first dimension determines the column name, while the second
  2444.      *                           dimension is keyed with the name of the properties
  2445.      *                           of the column being declared as array indexes. Currently, the types
  2446.      *                           of supported column properties are as follows:
  2447.      *
  2448.      *      length
  2449.      *          Integer value that determines the maximum length of the text
  2450.      *          column. If this argument is missing the column should be
  2451.      *          declared to have the longest length allowed by the DBMS.
  2452.      *
  2453.      *      default
  2454.      *          Text value to be used as default for this column.
  2455.      *
  2456.      *      notnull
  2457.      *          Boolean flag that indicates whether this column is constrained
  2458.      *          to not be set to null.
  2459.      *      charset
  2460.      *          Text value with the default CHARACTER SET for this column.
  2461.      *      collation
  2462.      *          Text value with the default COLLATION for this column.
  2463.      *      unique
  2464.      *          unique constraint
  2465.      *
  2466.      * @return string
  2467.      */
  2468.     public function getColumnDeclarationListSQL(array $columns)
  2469.     {
  2470.         $declarations = [];
  2472.         foreach ($columns as $name => $column) {
  2473.             $declarations[] = $this->getColumnDeclarationSQL($name, $column);
  2474.         }
  2476.         return implode(', ', $declarations);
  2477.     }
  2479.     /**
  2480.      * Obtains DBMS specific SQL code portion needed to declare a generic type
  2481.      * column to be used in statements like CREATE TABLE.
  2482.      *
  2483.      * @param string  $name   The name the column to be declared.
  2484.      * @param mixed[] $column An associative array with the name of the properties
  2485.      *                        of the column being declared as array indexes. Currently, the types
  2486.      *                        of supported column properties are as follows:
  2487.      *
  2488.      *      length
  2489.      *          Integer value that determines the maximum length of the text
  2490.      *          column. If this argument is missing the column should be
  2491.      *          declared to have the longest length allowed by the DBMS.
  2492.      *
  2493.      *      default
  2494.      *          Text value to be used as default for this column.
  2495.      *
  2496.      *      notnull
  2497.      *          Boolean flag that indicates whether this column is constrained
  2498.      *          to not be set to null.
  2499.      *      charset
  2500.      *          Text value with the default CHARACTER SET for this column.
  2501.      *      collation
  2502.      *          Text value with the default COLLATION for this column.
  2503.      *      unique
  2504.      *          unique constraint
  2505.      *      check
  2506.      *          column check constraint
  2507.      *      columnDefinition
  2508.      *          a string that defines the complete column
  2509.      *
  2510.      * @return string DBMS specific SQL code portion that should be used to declare the column.
  2511.      *
  2512.      * @throws Exception
  2513.      */
  2514.     public function getColumnDeclarationSQL($name, array $column)
  2515.     {
  2516.         if (isset($column['columnDefinition'])) {
  2517.             $declaration = $this->getCustomTypeDeclarationSQL($column);
  2518.         } else {
  2519.             $default = $this->getDefaultValueDeclarationSQL($column);
  2521.             $charset = ! empty($column['charset']) ?
  2522.                 ' ' . $this->getColumnCharsetDeclarationSQL($column['charset']) : '';
  2524.             $collation = ! empty($column['collation']) ?
  2525.                 ' ' . $this->getColumnCollationDeclarationSQL($column['collation']) : '';
  2527.             $notnull = ! empty($column['notnull']) ? ' NOT NULL' : '';
  2529.             $unique = ! empty($column['unique']) ?
  2530.                 ' ' . $this->getUniqueFieldDeclarationSQL() : '';
  2532.             $check = ! empty($column['check']) ? ' ' . $column['check'] : '';
  2534.             $typeDecl    = $column['type']->getSQLDeclaration($column, $this);
  2535.             $declaration = $typeDecl . $charset . $default . $notnull . $unique . $check . $collation;
  2537.             if ($this->supportsInlineColumnComments() && isset($column['comment']) && $column['comment'] !== '') {
  2538.                 $declaration .= ' ' . $this->getInlineColumnCommentSQL($column['comment']);
  2539.             }
  2540.         }
  2542.         return $name . ' ' . $declaration;
  2543.     }
  2545.     /**
  2546.      * Returns the SQL snippet that declares a floating point column of arbitrary precision.
  2547.      *
  2548.      * @param mixed[] $column
  2549.      *
  2550.      * @return string
  2551.      */
  2552.     public function getDecimalTypeDeclarationSQL(array $column)
  2553.     {
  2554.         $column['precision'] = ! isset($column['precision']) || empty($column['precision'])
  2555.             ? 10 : $column['precision'];
  2556.         $column['scale']     = ! isset($column['scale']) || empty($column['scale'])
  2557.             ? 0 : $column['scale'];
  2559.         return 'NUMERIC(' . $column['precision'] . ', ' . $column['scale'] . ')';
  2560.     }
  2562.     /**
  2563.      * Obtains DBMS specific SQL code portion needed to set a default value
  2564.      * declaration to be used in statements like CREATE TABLE.
  2565.      *
  2566.      * @param mixed[] $column The column definition array.
  2567.      *
  2568.      * @return string DBMS specific SQL code portion needed to set a default value.
  2569.      */
  2570.     public function getDefaultValueDeclarationSQL($column)
  2571.     {
  2572.         if (! isset($column['default'])) {
  2573.             return empty($column['notnull']) ? ' DEFAULT NULL' : '';
  2574.         }
  2576.         $default = $column['default'];
  2578.         if (! isset($column['type'])) {
  2579.             return " DEFAULT '" . $default . "'";
  2580.         }
  2582.         $type = $column['type'];
  2584.         if ($type instanceof Types\PhpIntegerMappingType) {
  2585.             return ' DEFAULT ' . $default;
  2586.         }
  2588.         if ($type instanceof Types\PhpDateTimeMappingType && $default === $this->getCurrentTimestampSQL()) {
  2589.             return ' DEFAULT ' . $this->getCurrentTimestampSQL();
  2590.         }
  2592.         if ($type instanceof Types\TimeType && $default === $this->getCurrentTimeSQL()) {
  2593.             return ' DEFAULT ' . $this->getCurrentTimeSQL();
  2594.         }
  2596.         if ($type instanceof Types\DateType && $default === $this->getCurrentDateSQL()) {
  2597.             return ' DEFAULT ' . $this->getCurrentDateSQL();
  2598.         }
  2600.         if ($type instanceof Types\BooleanType) {
  2601.             return ' DEFAULT ' . $this->convertBooleans($default);
  2602.         }
  2604.         return ' DEFAULT ' . $this->quoteStringLiteral($default);
  2605.     }
  2607.     /**
  2608.      * Obtains DBMS specific SQL code portion needed to set a CHECK constraint
  2609.      * declaration to be used in statements like CREATE TABLE.
  2610.      *
  2611.      * @param string[]|mixed[][] $definition The check definition.
  2612.      *
  2613.      * @return string DBMS specific SQL code portion needed to set a CHECK constraint.
  2614.      */
  2615.     public function getCheckDeclarationSQL(array $definition)
  2616.     {
  2617.         $constraints = [];
  2618.         foreach ($definition as $column => $def) {
  2619.             if (is_string($def)) {
  2620.                 $constraints[] = 'CHECK (' . $def . ')';
  2621.             } else {
  2622.                 if (isset($def['min'])) {
  2623.                     $constraints[] = 'CHECK (' . $column . ' >= ' . $def['min'] . ')';
  2624.                 }
  2626.                 if (isset($def['max'])) {
  2627.                     $constraints[] = 'CHECK (' . $column . ' <= ' . $def['max'] . ')';
  2628.                 }
  2629.             }
  2630.         }
  2632.         return implode(', ', $constraints);
  2633.     }
  2635.     /**
  2636.      * Obtains DBMS specific SQL code portion needed to set a unique
  2637.      * constraint declaration to be used in statements like CREATE TABLE.
  2638.      *
  2639.      * @param string           $name       The name of the unique constraint.
  2640.      * @param UniqueConstraint $constraint The unique constraint definition.
  2641.      *
  2642.      * @return string DBMS specific SQL code portion needed to set a constraint.
  2643.      *
  2644.      * @throws InvalidArgumentException
  2645.      */
  2646.     public function getUniqueConstraintDeclarationSQL($name, UniqueConstraint $constraint)
  2647.     {
  2648.         $columns = $constraint->getQuotedColumns($this);
  2649.         $name    = new Identifier($name);
  2651.         if (count($columns) === 0) {
  2652.             throw new InvalidArgumentException("Incomplete definition. 'columns' required.");
  2653.         }
  2655.         $constraintFlags = array_merge(['UNIQUE'], array_map('strtoupper', $constraint->getFlags()));
  2656.         $constraintName  = $name->getQuotedName($this);
  2657.         $columnListNames = $this->getColumnsFieldDeclarationListSQL($columns);
  2659.         return sprintf('CONSTRAINT %s %s (%s)', $constraintName, implode(' ', $constraintFlags), $columnListNames);
  2660.     }
  2662.     /**
  2663.      * Obtains DBMS specific SQL code portion needed to set an index
  2664.      * declaration to be used in statements like CREATE TABLE.
  2665.      *
  2666.      * @param string $name  The name of the index.
  2667.      * @param Index  $index The index definition.
  2668.      *
  2669.      * @return string DBMS specific SQL code portion needed to set an index.
  2670.      *
  2671.      * @throws InvalidArgumentException
  2672.      */
  2673.     public function getIndexDeclarationSQL($name, Index $index)
  2674.     {
  2675.         $columns = $index->getColumns();
  2676.         $name    = new Identifier($name);
  2678.         if (count($columns) === 0) {
  2679.             throw new InvalidArgumentException("Incomplete definition. 'columns' required.");
  2680.         }
  2682.         return $this->getCreateIndexSQLFlags($index) . 'INDEX ' . $name->getQuotedName($this)
  2683.             . ' (' . $this->getIndexFieldDeclarationListSQL($index) . ')' . $this->getPartialIndexSQL($index);
  2684.     }
  2686.     /**
  2687.      * Obtains SQL code portion needed to create a custom column,
  2688.      * e.g. when a column has the "columnDefinition" keyword.
  2689.      * Only "AUTOINCREMENT" and "PRIMARY KEY" are added if appropriate.
  2690.      *
  2691.      * @param mixed[] $column
  2692.      *
  2693.      * @return string
  2694.      */
  2695.     public function getCustomTypeDeclarationSQL(array $column)
  2696.     {
  2697.         return $column['columnDefinition'];
  2698.     }
  2700.     /**
  2701.      * Obtains DBMS specific SQL code portion needed to set an index
  2702.      * declaration to be used in statements like CREATE TABLE.
  2703.      */
  2704.     public function getIndexFieldDeclarationListSQL(Index $index): string
  2705.     {
  2706.         return implode(', ', $index->getQuotedColumns($this));
  2707.     }
  2709.     /**
  2710.      * Obtains DBMS specific SQL code portion needed to set an index
  2711.      * declaration to be used in statements like CREATE TABLE.
  2712.      *
  2713.      * @param mixed[] $columns
  2714.      */
  2715.     public function getColumnsFieldDeclarationListSQL(array $columns): string
  2716.     {
  2717.         $ret = [];
  2719.         foreach ($columns as $column => $definition) {
  2720.             if (is_array($definition)) {
  2721.                 $ret[] = $column;
  2722.             } else {
  2723.                 $ret[] = $definition;
  2724.             }
  2725.         }
  2727.         return implode(', ', $ret);
  2728.     }
  2730.     /**
  2731.      * Returns the required SQL string that fits between CREATE ... TABLE
  2732.      * to create the table as a temporary table.
  2733.      *
  2734.      * Should be overridden in driver classes to return the correct string for the
  2735.      * specific database type.
  2736.      *
  2737.      * The default is to return the string "TEMPORARY" - this will result in a
  2738.      * SQL error for any database that does not support temporary tables, or that
  2739.      * requires a different SQL command from "CREATE TEMPORARY TABLE".
  2740.      *
  2741.      * @deprecated
  2742.      *
  2743.      * @return string The string required to be placed between "CREATE" and "TABLE"
  2744.      *                to generate a temporary table, if possible.
  2745.      */
  2746.     public function getTemporaryTableSQL()
  2747.     {
  2748.         Deprecation::trigger(
  2749.             'doctrine/dbal',
  2750.             'https://github.com/doctrine/dbal/pulls/4724',
  2751.             'AbstractPlatform::getTemporaryTableSQL() is deprecated.'
  2752.         );
  2754.         return 'TEMPORARY';
  2755.     }
  2757.     /**
  2758.      * Some vendors require temporary table names to be qualified specially.
  2759.      *
  2760.      * @param string $tableName
  2761.      *
  2762.      * @return string
  2763.      */
  2764.     public function getTemporaryTableName($tableName)
  2765.     {
  2766.         return $tableName;
  2767.     }
  2769.     /**
  2770.      * Obtain DBMS specific SQL code portion needed to set the FOREIGN KEY constraint
  2771.      * of a column declaration to be used in statements like CREATE TABLE.
  2772.      *
  2773.      * @return string DBMS specific SQL code portion needed to set the FOREIGN KEY constraint
  2774.      *                of a column declaration.
  2775.      */
  2776.     public function getForeignKeyDeclarationSQL(ForeignKeyConstraint $foreignKey)
  2777.     {
  2778.         $sql  = $this->getForeignKeyBaseDeclarationSQL($foreignKey);
  2779.         $sql .= $this->getAdvancedForeignKeyOptionsSQL($foreignKey);
  2781.         return $sql;
  2782.     }
  2784.     /**
  2785.      * Returns the FOREIGN KEY query section dealing with non-standard options
  2786.      * as MATCH, INITIALLY DEFERRED, ON UPDATE, ...
  2787.      *
  2788.      * @param ForeignKeyConstraint $foreignKey The foreign key definition.
  2789.      *
  2790.      * @return string
  2791.      */
  2792.     public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey)
  2793.     {
  2794.         $query = '';
  2795.         if ($foreignKey->hasOption('onUpdate')) {
  2796.             $query .= ' ON UPDATE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onUpdate'));
  2797.         }
  2799.         if ($foreignKey->hasOption('onDelete')) {
  2800.             $query .= ' ON DELETE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onDelete'));
  2801.         }
  2803.         return $query;
  2804.     }
  2806.     /**
  2807.      * Returns the given referential action in uppercase if valid, otherwise throws an exception.
  2808.      *
  2809.      * @param string $action The foreign key referential action.
  2810.      *
  2811.      * @return string
  2812.      *
  2813.      * @throws InvalidArgumentException If unknown referential action given.
  2814.      */
  2815.     public function getForeignKeyReferentialActionSQL($action)
  2816.     {
  2817.         $upper = strtoupper($action);
  2818.         switch ($upper) {
  2819.             case 'CASCADE':
  2820.             case 'SET NULL':
  2821.             case 'NO ACTION':
  2822.             case 'RESTRICT':
  2823.             case 'SET DEFAULT':
  2824.                 return $upper;
  2826.             default:
  2827.                 throw new InvalidArgumentException('Invalid foreign key action: ' . $upper);
  2828.         }
  2829.     }
  2831.     /**
  2832.      * Obtains DBMS specific SQL code portion needed to set the FOREIGN KEY constraint
  2833.      * of a column declaration to be used in statements like CREATE TABLE.
  2834.      *
  2835.      * @return string
  2836.      *
  2837.      * @throws InvalidArgumentException
  2838.      */
  2839.     public function getForeignKeyBaseDeclarationSQL(ForeignKeyConstraint $foreignKey)
  2840.     {
  2841.         $sql = '';
  2842.         if (strlen($foreignKey->getName()) > 0) {
  2843.             $sql .= 'CONSTRAINT ' . $foreignKey->getQuotedName($this) . ' ';
  2844.         }
  2846.         $sql .= 'FOREIGN KEY (';
  2848.         if (count($foreignKey->getLocalColumns()) === 0) {
  2849.             throw new InvalidArgumentException("Incomplete definition. 'local' required.");
  2850.         }
  2852.         if (count($foreignKey->getForeignColumns()) === 0) {
  2853.             throw new InvalidArgumentException("Incomplete definition. 'foreign' required.");
  2854.         }
  2856.         if (strlen($foreignKey->getForeignTableName()) === 0) {
  2857.             throw new InvalidArgumentException("Incomplete definition. 'foreignTable' required.");
  2858.         }
  2860.         return $sql . implode(', ', $foreignKey->getQuotedLocalColumns($this))
  2861.             . ') REFERENCES '
  2862.             . $foreignKey->getQuotedForeignTableName($this) . ' ('
  2863.             . implode(', ', $foreignKey->getQuotedForeignColumns($this)) . ')';
  2864.     }
  2866.     /**
  2867.      * Obtains DBMS specific SQL code portion needed to set the UNIQUE constraint
  2868.      * of a column declaration to be used in statements like CREATE TABLE.
  2869.      *
  2870.      * @deprecated Use UNIQUE in SQL instead.
  2871.      *
  2872.      * @return string DBMS specific SQL code portion needed to set the UNIQUE constraint
  2873.      *                of a column declaration.
  2874.      */
  2875.     public function getUniqueFieldDeclarationSQL()
  2876.     {
  2877.         Deprecation::trigger(
  2878.             'doctrine/dbal',
  2879.             'https://github.com/doctrine/dbal/pulls/4724',
  2880.             'AbstractPlatform::getUniqueFieldDeclarationSQL() is deprecated. Use UNIQUE in SQL instead.'
  2881.         );
  2883.         return 'UNIQUE';
  2884.     }
  2886.     /**
  2887.      * Obtains DBMS specific SQL code portion needed to set the CHARACTER SET
  2888.      * of a column declaration to be used in statements like CREATE TABLE.
  2889.      *
  2890.      * @param string $charset The name of the charset.
  2891.      *
  2892.      * @return string DBMS specific SQL code portion needed to set the CHARACTER SET
  2893.      *                of a column declaration.
  2894.      */
  2895.     public function getColumnCharsetDeclarationSQL($charset)
  2896.     {
  2897.         return '';
  2898.     }
  2900.     /**
  2901.      * Obtains DBMS specific SQL code portion needed to set the COLLATION
  2902.      * of a column declaration to be used in statements like CREATE TABLE.
  2903.      *
  2904.      * @param string $collation The name of the collation.
  2905.      *
  2906.      * @return string DBMS specific SQL code portion needed to set the COLLATION
  2907.      *                of a column declaration.
  2908.      */
  2909.     public function getColumnCollationDeclarationSQL($collation)
  2910.     {
  2911.         return $this->supportsColumnCollation() ? 'COLLATE ' . $collation : '';
  2912.     }
  2914.     /**
  2915.      * Whether the platform prefers identity columns (eg. autoincrement) for ID generation.
  2916.      * Subclasses should override this method to return TRUE if they prefer identity columns.
  2917.      *
  2918.      * @deprecated
  2919.      *
  2920.      * @return bool
  2921.      */
  2922.     public function prefersIdentityColumns()
  2923.     {
  2924.         Deprecation::trigger(
  2925.             'doctrine/dbal',
  2926.             'https://github.com/doctrine/dbal/pulls/1519',
  2927.             'AbstractPlatform::prefersIdentityColumns() is deprecated.'
  2928.         );
  2930.         return false;
  2931.     }
  2933.     /**
  2934.      * Some platforms need the boolean values to be converted.
  2935.      *
  2936.      * The default conversion in this implementation converts to integers (false => 0, true => 1).
  2937.      *
  2938.      * Note: if the input is not a boolean the original input might be returned.
  2939.      *
  2940.      * There are two contexts when converting booleans: Literals and Prepared Statements.
  2941.      * This method should handle the literal case
  2942.      *
  2943.      * @param mixed $item A boolean or an array of them.
  2944.      *
  2945.      * @return mixed A boolean database value or an array of them.
  2946.      */
  2947.     public function convertBooleans($item)
  2948.     {
  2949.         if (is_array($item)) {
  2950.             foreach ($item as $k => $value) {
  2951.                 if (! is_bool($value)) {
  2952.                     continue;
  2953.                 }
  2955.                 $item[$k] = (int) $value;
  2956.             }
  2957.         } elseif (is_bool($item)) {
  2958.             $item = (int) $item;
  2959.         }
  2961.         return $item;
  2962.     }
  2964.     /**
  2965.      * Some platforms have boolean literals that needs to be correctly converted
  2966.      *
  2967.      * The default conversion tries to convert value into bool "(bool)$item"
  2968.      *
  2969.      * @param mixed $item
  2970.      *
  2971.      * @return bool|null
  2972.      */
  2973.     public function convertFromBoolean($item)
  2974.     {
  2975.         return $item === null ? null : (bool) $item;
  2976.     }
  2978.     /**
  2979.      * This method should handle the prepared statements case. When there is no
  2980.      * distinction, it's OK to use the same method.
  2981.      *
  2982.      * Note: if the input is not a boolean the original input might be returned.
  2983.      *
  2984.      * @param mixed $item A boolean or an array of them.
  2985.      *
  2986.      * @return mixed A boolean database value or an array of them.
  2987.      */
  2988.     public function convertBooleansToDatabaseValue($item)
  2989.     {
  2990.         return $this->convertBooleans($item);
  2991.     }
  2993.     /**
  2994.      * Returns the SQL specific for the platform to get the current date.
  2995.      *
  2996.      * @return string
  2997.      */
  2998.     public function getCurrentDateSQL()
  2999.     {
  3000.         return 'CURRENT_DATE';
  3001.     }
  3003.     /**
  3004.      * Returns the SQL specific for the platform to get the current time.
  3005.      *
  3006.      * @return string
  3007.      */
  3008.     public function getCurrentTimeSQL()
  3009.     {
  3010.         return 'CURRENT_TIME';
  3011.     }
  3013.     /**
  3014.      * Returns the SQL specific for the platform to get the current timestamp
  3015.      *
  3016.      * @return string
  3017.      */
  3018.     public function getCurrentTimestampSQL()
  3019.     {
  3020.         return 'CURRENT_TIMESTAMP';
  3021.     }
  3023.     /**
  3024.      * Returns the SQL for a given transaction isolation level Connection constant.
  3025.      *
  3026.      * @param int $level
  3027.      *
  3028.      * @return string
  3029.      *
  3030.      * @throws InvalidArgumentException
  3031.      */
  3032.     protected function _getTransactionIsolationLevelSQL($level)
  3033.     {
  3034.         switch ($level) {
  3035.             case TransactionIsolationLevel::READ_UNCOMMITTED:
  3036.                 return 'READ UNCOMMITTED';
  3038.             case TransactionIsolationLevel::READ_COMMITTED:
  3039.                 return 'READ COMMITTED';
  3041.             case TransactionIsolationLevel::REPEATABLE_READ:
  3042.                 return 'REPEATABLE READ';
  3044.             case TransactionIsolationLevel::SERIALIZABLE:
  3045.                 return 'SERIALIZABLE';
  3047.             default:
  3048.                 throw new InvalidArgumentException('Invalid isolation level:' . $level);
  3049.         }
  3050.     }
  3052.     /**
  3053.      * @return string
  3054.      *
  3055.      * @throws Exception If not supported on this platform.
  3056.      */
  3057.     public function getListDatabasesSQL()
  3058.     {
  3059.         throw Exception::notSupported(__METHOD__);
  3060.     }
  3062.     /**
  3063.      * Returns the SQL statement for retrieving the namespaces defined in the database.
  3064.      *
  3065.      * @deprecated Use {@see AbstractSchemaManager::listSchemaNames()} instead.
  3066.      *
  3067.      * @return string
  3068.      *
  3069.      * @throws Exception If not supported on this platform.
  3070.      */
  3071.     public function getListNamespacesSQL()
  3072.     {
  3073.         Deprecation::triggerIfCalledFromOutside(
  3074.             'doctrine/dbal',
  3075.             'https://github.com/doctrine/dbal/issues/4503',
  3076.             'AbstractPlatform::getListNamespacesSQL() is deprecated,'
  3077.                 . ' use AbstractSchemaManager::listSchemaNames() instead.'
  3078.         );
  3080.         throw Exception::notSupported(__METHOD__);
  3081.     }
  3083.     /**
  3084.      * @param string $database
  3085.      *
  3086.      * @return string
  3087.      *
  3088.      * @throws Exception If not supported on this platform.
  3089.      */
  3090.     public function getListSequencesSQL($database)
  3091.     {
  3092.         throw Exception::notSupported(__METHOD__);
  3093.     }
  3095.     /**
  3096.      * @param string $table
  3097.      *
  3098.      * @return string
  3099.      *
  3100.      * @throws Exception If not supported on this platform.
  3101.      */
  3102.     public function getListTableConstraintsSQL($table)
  3103.     {
  3104.         throw Exception::notSupported(__METHOD__);
  3105.     }
  3107.     /**
  3108.      * @param string $table
  3109.      * @param string $database
  3110.      *
  3111.      * @return string
  3112.      *
  3113.      * @throws Exception If not supported on this platform.
  3114.      */
  3115.     public function getListTableColumnsSQL($table, $database = null)
  3116.     {
  3117.         throw Exception::notSupported(__METHOD__);
  3118.     }
  3120.     /**
  3121.      * @return string
  3122.      *
  3123.      * @throws Exception If not supported on this platform.
  3124.      */
  3125.     public function getListTablesSQL()
  3126.     {
  3127.         throw Exception::notSupported(__METHOD__);
  3128.     }
  3130.     /**
  3131.      * @deprecated
  3132.      *
  3133.      * @return string
  3134.      *
  3135.      * @throws Exception If not supported on this platform.
  3136.      */
  3137.     public function getListUsersSQL()
  3138.     {
  3139.         Deprecation::trigger(
  3140.             'doctrine/dbal',
  3141.             'https://github.com/doctrine/dbal/pulls/4724',
  3142.             'AbstractPlatform::getListUsersSQL() is deprecated.'
  3143.         );
  3145.         throw Exception::notSupported(__METHOD__);
  3146.     }
  3148.     /**
  3149.      * Returns the SQL to list all views of a database or user.
  3150.      *
  3151.      * @param string $database
  3152.      *
  3153.      * @return string
  3154.      *
  3155.      * @throws Exception If not supported on this platform.
  3156.      */
  3157.     public function getListViewsSQL($database)
  3158.     {
  3159.         throw Exception::notSupported(__METHOD__);
  3160.     }
  3162.     /**
  3163.      * Returns the list of indexes for the current database.
  3164.      *
  3165.      * The current database parameter is optional but will always be passed
  3166.      * when using the SchemaManager API and is the database the given table is in.
  3167.      *
  3168.      * Attention: Some platforms only support currentDatabase when they
  3169.      * are connected with that database. Cross-database information schema
  3170.      * requests may be impossible.
  3171.      *
  3172.      * @param string $table
  3173.      * @param string $database
  3174.      *
  3175.      * @return string
  3176.      *
  3177.      * @throws Exception If not supported on this platform.
  3178.      */
  3179.     public function getListTableIndexesSQL($table, $database = null)
  3180.     {
  3181.         throw Exception::notSupported(__METHOD__);
  3182.     }
  3184.     /**
  3185.      * @param string $table
  3186.      *
  3187.      * @return string
  3188.      *
  3189.      * @throws Exception If not supported on this platform.
  3190.      */
  3191.     public function getListTableForeignKeysSQL($table)
  3192.     {
  3193.         throw Exception::notSupported(__METHOD__);
  3194.     }
  3196.     /**
  3197.      * @param string $name
  3198.      * @param string $sql
  3199.      *
  3200.      * @return string
  3201.      */
  3202.     public function getCreateViewSQL($name, $sql)
  3203.     {
  3204.         return 'CREATE VIEW ' . $name . ' AS ' . $sql;
  3205.     }
  3207.     /**
  3208.      * @param string $name
  3209.      *
  3210.      * @return string
  3211.      */
  3212.     public function getDropViewSQL($name)
  3213.     {
  3214.         return 'DROP VIEW ' . $name;
  3215.     }
  3217.     /**
  3218.      * @param string $sequence
  3219.      *
  3220.      * @return string
  3221.      *
  3222.      * @throws Exception If not supported on this platform.
  3223.      */
  3224.     public function getSequenceNextValSQL($sequence)
  3225.     {
  3226.         throw Exception::notSupported(__METHOD__);
  3227.     }
  3229.     /**
  3230.      * Returns the SQL to create a new database.
  3231.      *
  3232.      * @param string $name The name of the database that should be created.
  3233.      *
  3234.      * @return string
  3235.      *
  3236.      * @throws Exception If not supported on this platform.
  3237.      */
  3238.     public function getCreateDatabaseSQL($name)
  3239.     {
  3240.         if (! $this->supportsCreateDropDatabase()) {
  3241.             throw Exception::notSupported(__METHOD__);
  3242.         }
  3244.         return 'CREATE DATABASE ' . $name;
  3245.     }
  3247.     /**
  3248.      * Returns the SQL snippet to drop an existing database.
  3249.      *
  3250.      * @param string $name The name of the database that should be dropped.
  3251.      *
  3252.      * @return string
  3253.      */
  3254.     public function getDropDatabaseSQL($name)
  3255.     {
  3256.         if (! $this->supportsCreateDropDatabase()) {
  3257.             throw Exception::notSupported(__METHOD__);
  3258.         }
  3260.         return 'DROP DATABASE ' . $name;
  3261.     }
  3263.     /**
  3264.      * Returns the SQL to set the transaction isolation level.
  3265.      *
  3266.      * @param int $level
  3267.      *
  3268.      * @return string
  3269.      *
  3270.      * @throws Exception If not supported on this platform.
  3271.      */
  3272.     public function getSetTransactionIsolationSQL($level)
  3273.     {
  3274.         throw Exception::notSupported(__METHOD__);
  3275.     }
  3277.     /**
  3278.      * Obtains DBMS specific SQL to be used to create datetime columns in
  3279.      * statements like CREATE TABLE.
  3280.      *
  3281.      * @param mixed[] $column
  3282.      *
  3283.      * @return string
  3284.      *
  3285.      * @throws Exception If not supported on this platform.
  3286.      */
  3287.     public function getDateTimeTypeDeclarationSQL(array $column)
  3288.     {
  3289.         throw Exception::notSupported(__METHOD__);
  3290.     }
  3292.     /**
  3293.      * Obtains DBMS specific SQL to be used to create datetime with timezone offset columns.
  3294.      *
  3295.      * @param mixed[] $column
  3296.      *
  3297.      * @return string
  3298.      */
  3299.     public function getDateTimeTzTypeDeclarationSQL(array $column)
  3300.     {
  3301.         return $this->getDateTimeTypeDeclarationSQL($column);
  3302.     }
  3304.     /**
  3305.      * Obtains DBMS specific SQL to be used to create date columns in statements
  3306.      * like CREATE TABLE.
  3307.      *
  3308.      * @param mixed[] $column
  3309.      *
  3310.      * @return string
  3311.      *
  3312.      * @throws Exception If not supported on this platform.
  3313.      */
  3314.     public function getDateTypeDeclarationSQL(array $column)
  3315.     {
  3316.         throw Exception::notSupported(__METHOD__);
  3317.     }
  3319.     /**
  3320.      * Obtains DBMS specific SQL to be used to create time columns in statements
  3321.      * like CREATE TABLE.
  3322.      *
  3323.      * @param mixed[] $column
  3324.      *
  3325.      * @return string
  3326.      *
  3327.      * @throws Exception If not supported on this platform.
  3328.      */
  3329.     public function getTimeTypeDeclarationSQL(array $column)
  3330.     {
  3331.         throw Exception::notSupported(__METHOD__);
  3332.     }
  3334.     /**
  3335.      * @param mixed[] $column
  3336.      *
  3337.      * @return string
  3338.      */
  3339.     public function getFloatDeclarationSQL(array $column)
  3340.     {
  3341.         return 'DOUBLE PRECISION';
  3342.     }
  3344.     /**
  3345.      * Gets the default transaction isolation level of the platform.
  3346.      *
  3347.      * @see TransactionIsolationLevel
  3348.      *
  3349.      * @return int The default isolation level.
  3350.      */
  3351.     public function getDefaultTransactionIsolationLevel()
  3352.     {
  3353.         return TransactionIsolationLevel::READ_COMMITTED;
  3354.     }
  3356.     /* supports*() methods */
  3358.     /**
  3359.      * Whether the platform supports sequences.
  3360.      *
  3361.      * @return bool
  3362.      */
  3363.     public function supportsSequences()
  3364.     {
  3365.         return false;
  3366.     }
  3368.     /**
  3369.      * Whether the platform supports identity columns.
  3370.      *
  3371.      * Identity columns are columns that receive an auto-generated value from the
  3372.      * database on insert of a row.
  3373.      *
  3374.      * @return bool
  3375.      */
  3376.     public function supportsIdentityColumns()
  3377.     {
  3378.         return false;
  3379.     }
  3381.     /**
  3382.      * Whether the platform emulates identity columns through sequences.
  3383.      *
  3384.      * Some platforms that do not support identity columns natively
  3385.      * but support sequences can emulate identity columns by using
  3386.      * sequences.
  3387.      *
  3388.      * @return bool
  3389.      */
  3390.     public function usesSequenceEmulatedIdentityColumns()
  3391.     {
  3392.         return false;
  3393.     }
  3395.     /**
  3396.      * Returns the name of the sequence for a particular identity column in a particular table.
  3397.      *
  3398.      * @see usesSequenceEmulatedIdentityColumns
  3399.      *
  3400.      * @param string $tableName  The name of the table to return the sequence name for.
  3401.      * @param string $columnName The name of the identity column in the table to return the sequence name for.
  3402.      *
  3403.      * @return string
  3404.      *
  3405.      * @throws Exception If not supported on this platform.
  3406.      */
  3407.     public function getIdentitySequenceName($tableName, $columnName)
  3408.     {
  3409.         throw Exception::notSupported(__METHOD__);
  3410.     }
  3412.     /**
  3413.      * Whether the platform supports indexes.
  3414.      *
  3415.      * @deprecated
  3416.      *
  3417.      * @return bool
  3418.      */
  3419.     public function supportsIndexes()
  3420.     {
  3421.         Deprecation::trigger(
  3422.             'doctrine/dbal',
  3423.             'https://github.com/doctrine/dbal/pulls/4724',
  3424.             'AbstractPlatform::supportsIndexes() is deprecated.'
  3425.         );
  3427.         return true;
  3428.     }
  3430.     /**
  3431.      * Whether the platform supports partial indexes.
  3432.      *
  3433.      * @return bool
  3434.      */
  3435.     public function supportsPartialIndexes()
  3436.     {
  3437.         return false;
  3438.     }
  3440.     /**
  3441.      * Whether the platform supports indexes with column length definitions.
  3442.      */
  3443.     public function supportsColumnLengthIndexes(): bool
  3444.     {
  3445.         return false;
  3446.     }
  3448.     /**
  3449.      * Whether the platform supports altering tables.
  3450.      *
  3451.      * @deprecated All platforms must implement altering tables.
  3452.      *
  3453.      * @return bool
  3454.      */
  3455.     public function supportsAlterTable()
  3456.     {
  3457.         Deprecation::trigger(
  3458.             'doctrine/dbal',
  3459.             'https://github.com/doctrine/dbal/pulls/4724',
  3460.             'AbstractPlatform::supportsAlterTable() is deprecated. All platforms must implement altering tables.'
  3461.         );
  3463.         return true;
  3464.     }
  3466.     /**
  3467.      * Whether the platform supports transactions.
  3468.      *
  3469.      * @deprecated
  3470.      *
  3471.      * @return bool
  3472.      */
  3473.     public function supportsTransactions()
  3474.     {
  3475.         Deprecation::trigger(
  3476.             'doctrine/dbal',
  3477.             'https://github.com/doctrine/dbal/pulls/4724',
  3478.             'AbstractPlatform::supportsTransactions() is deprecated.'
  3479.         );
  3481.         return true;
  3482.     }
  3484.     /**
  3485.      * Whether the platform supports savepoints.
  3486.      *
  3487.      * @return bool
  3488.      */
  3489.     public function supportsSavepoints()
  3490.     {
  3491.         return true;
  3492.     }
  3494.     /**
  3495.      * Whether the platform supports releasing savepoints.
  3496.      *
  3497.      * @return bool
  3498.      */
  3499.     public function supportsReleaseSavepoints()
  3500.     {
  3501.         return $this->supportsSavepoints();
  3502.     }
  3504.     /**
  3505.      * Whether the platform supports primary key constraints.
  3506.      *
  3507.      * @deprecated
  3508.      *
  3509.      * @return bool
  3510.      */
  3511.     public function supportsPrimaryConstraints()
  3512.     {
  3513.         Deprecation::trigger(
  3514.             'doctrine/dbal',
  3515.             'https://github.com/doctrine/dbal/pulls/4724',
  3516.             'AbstractPlatform::supportsPrimaryConstraints() is deprecated.'
  3517.         );
  3519.         return true;
  3520.     }
  3522.     /**
  3523.      * Whether the platform supports foreign key constraints.
  3524.      *
  3525.      * @return bool
  3526.      */
  3527.     public function supportsForeignKeyConstraints()
  3528.     {
  3529.         return true;
  3530.     }
  3532.     /**
  3533.      * Whether the platform supports database schemas.
  3534.      *
  3535.      * @return bool
  3536.      */
  3537.     public function supportsSchemas()
  3538.     {
  3539.         return false;
  3540.     }
  3542.     /**
  3543.      * Whether this platform can emulate schemas.
  3544.      *
  3545.      * @deprecated
  3546.      *
  3547.      * Platforms that either support or emulate schemas don't automatically
  3548.      * filter a schema for the namespaced elements in {@see AbstractManager::createSchema()}.
  3549.      *
  3550.      * @return bool
  3551.      */
  3552.     public function canEmulateSchemas()
  3553.     {
  3554.         Deprecation::trigger(
  3555.             'doctrine/dbal',
  3556.             'https://github.com/doctrine/dbal/pull/4805',
  3557.             'AbstractPlatform::canEmulateSchemas() is deprecated.'
  3558.         );
  3560.         return false;
  3561.     }
  3563.     /**
  3564.      * Returns the default schema name.
  3565.      *
  3566.      * @return string
  3567.      *
  3568.      * @throws Exception If not supported on this platform.
  3569.      */
  3570.     public function getDefaultSchemaName()
  3571.     {
  3572.         throw Exception::notSupported(__METHOD__);
  3573.     }
  3575.     /**
  3576.      * Whether this platform supports create database.
  3577.      *
  3578.      * Some databases don't allow to create and drop databases at all or only with certain tools.
  3579.      *
  3580.      * @return bool
  3581.      */
  3582.     public function supportsCreateDropDatabase()
  3583.     {
  3584.         return true;
  3585.     }
  3587.     /**
  3588.      * Whether the platform supports getting the affected rows of a recent update/delete type query.
  3589.      *
  3590.      * @deprecated
  3591.      *
  3592.      * @return bool
  3593.      */
  3594.     public function supportsGettingAffectedRows()
  3595.     {
  3596.         Deprecation::trigger(
  3597.             'doctrine/dbal',
  3598.             'https://github.com/doctrine/dbal/pulls/4724',
  3599.             'AbstractPlatform::supportsGettingAffectedRows() is deprecated.'
  3600.         );
  3602.         return true;
  3603.     }
  3605.     /**
  3606.      * Whether this platform support to add inline column comments as postfix.
  3607.      *
  3608.      * @return bool
  3609.      */
  3610.     public function supportsInlineColumnComments()
  3611.     {
  3612.         return false;
  3613.     }
  3615.     /**
  3616.      * Whether this platform support the proprietary syntax "COMMENT ON asset".
  3617.      *
  3618.      * @return bool
  3619.      */
  3620.     public function supportsCommentOnStatement()
  3621.     {
  3622.         return false;
  3623.     }
  3625.     /**
  3626.      * Does this platform have native guid type.
  3627.      *
  3628.      * @return bool
  3629.      */
  3630.     public function hasNativeGuidType()
  3631.     {
  3632.         return false;
  3633.     }
  3635.     /**
  3636.      * Does this platform have native JSON type.
  3637.      *
  3638.      * @return bool
  3639.      */
  3640.     public function hasNativeJsonType()
  3641.     {
  3642.         return false;
  3643.     }
  3645.     /**
  3646.      * Whether this platform supports views.
  3647.      *
  3648.      * @deprecated All platforms must implement support for views.
  3649.      *
  3650.      * @return bool
  3651.      */
  3652.     public function supportsViews()
  3653.     {
  3654.         Deprecation::trigger(
  3655.             'doctrine/dbal',
  3656.             'https://github.com/doctrine/dbal/pulls/4724',
  3657.             'AbstractPlatform::supportsViews() is deprecated. All platforms must implement support for views.'
  3658.         );
  3660.         return true;
  3661.     }
  3663.     /**
  3664.      * Does this platform support column collation?
  3665.      *
  3666.      * @return bool
  3667.      */
  3668.     public function supportsColumnCollation()
  3669.     {
  3670.         return false;
  3671.     }
  3673.     /**
  3674.      * Gets the format string, as accepted by the date() function, that describes
  3675.      * the format of a stored datetime value of this platform.
  3676.      *
  3677.      * @return string The format string.
  3678.      */
  3679.     public function getDateTimeFormatString()
  3680.     {
  3681.         return 'Y-m-d H:i:s';
  3682.     }
  3684.     /**
  3685.      * Gets the format string, as accepted by the date() function, that describes
  3686.      * the format of a stored datetime with timezone value of this platform.
  3687.      *
  3688.      * @return string The format string.
  3689.      */
  3690.     public function getDateTimeTzFormatString()
  3691.     {
  3692.         return 'Y-m-d H:i:s';
  3693.     }
  3695.     /**
  3696.      * Gets the format string, as accepted by the date() function, that describes
  3697.      * the format of a stored date value of this platform.
  3698.      *
  3699.      * @return string The format string.
  3700.      */
  3701.     public function getDateFormatString()
  3702.     {
  3703.         return 'Y-m-d';
  3704.     }
  3706.     /**
  3707.      * Gets the format string, as accepted by the date() function, that describes
  3708.      * the format of a stored time value of this platform.
  3709.      *
  3710.      * @return string The format string.
  3711.      */
  3712.     public function getTimeFormatString()
  3713.     {
  3714.         return 'H:i:s';
  3715.     }
  3717.     /**
  3718.      * Adds an driver-specific LIMIT clause to the query.
  3719.      *
  3720.      * @param string   $query
  3721.      * @param int|null $limit
  3722.      * @param int      $offset
  3723.      *
  3724.      * @throws Exception
  3725.      */
  3726.     final public function modifyLimitQuery($query, $limit, $offset = 0): string
  3727.     {
  3728.         if ($offset < 0) {
  3729.             throw new Exception(sprintf(
  3730.                 'Offset must be a positive integer or zero, %d given',
  3731.                 $offset
  3732.             ));
  3733.         }
  3735.         if ($offset > 0 && ! $this->supportsLimitOffset()) {
  3736.             throw new Exception(sprintf(
  3737.                 'Platform %s does not support offset values in limit queries.',
  3738.                 $this->getName()
  3739.             ));
  3740.         }
  3742.         if ($limit !== null) {
  3743.             $limit = (int) $limit;
  3744.         }
  3746.         return $this->doModifyLimitQuery($query, $limit, (int) $offset);
  3747.     }
  3749.     /**
  3750.      * Adds an platform-specific LIMIT clause to the query.
  3751.      *
  3752.      * @param string   $query
  3753.      * @param int|null $limit
  3754.      * @param int      $offset
  3755.      *
  3756.      * @return string
  3757.      */
  3758.     protected function doModifyLimitQuery($query, $limit, $offset)
  3759.     {
  3760.         if ($limit !== null) {
  3761.             $query .= sprintf(' LIMIT %d', $limit);
  3762.         }
  3764.         if ($offset > 0) {
  3765.             $query .= sprintf(' OFFSET %d', $offset);
  3766.         }
  3768.         return $query;
  3769.     }
  3771.     /**
  3772.      * Whether the database platform support offsets in modify limit clauses.
  3773.      *
  3774.      * @deprecated All platforms must implement support for offsets in modify limit clauses.
  3775.      *
  3776.      * @return bool
  3777.      */
  3778.     public function supportsLimitOffset()
  3779.     {
  3780.         Deprecation::triggerIfCalledFromOutside(
  3781.             'doctrine/dbal',
  3782.             'https://github.com/doctrine/dbal/pulls/4724',
  3783.             'AbstractPlatform::supportsViews() is deprecated.'
  3784.             . ' All platforms must implement support for offsets in modify limit clauses.'
  3785.         );
  3787.         return true;
  3788.     }
  3790.     /**
  3791.      * Maximum length of any given database identifier, like tables or column names.
  3792.      *
  3793.      * @return int
  3794.      */
  3795.     public function getMaxIdentifierLength()
  3796.     {
  3797.         return 63;
  3798.     }
  3800.     /**
  3801.      * Returns the insert SQL for an empty insert statement.
  3802.      *
  3803.      * @param string $quotedTableName
  3804.      * @param string $quotedIdentifierColumnName
  3805.      *
  3806.      * @return string
  3807.      */
  3808.     public function getEmptyIdentityInsertSQL($quotedTableName, $quotedIdentifierColumnName)
  3809.     {
  3810.         return 'INSERT INTO ' . $quotedTableName . ' (' . $quotedIdentifierColumnName . ') VALUES (null)';
  3811.     }
  3813.     /**
  3814.      * Generates a Truncate Table SQL statement for a given table.
  3815.      *
  3816.      * Cascade is not supported on many platforms but would optionally cascade the truncate by
  3817.      * following the foreign keys.
  3818.      *
  3819.      * @param string $tableName
  3820.      * @param bool   $cascade
  3821.      *
  3822.      * @return string
  3823.      */
  3824.     public function getTruncateTableSQL($tableName, $cascade = false)
  3825.     {
  3826.         $tableIdentifier = new Identifier($tableName);
  3828.         return 'TRUNCATE ' . $tableIdentifier->getQuotedName($this);
  3829.     }
  3831.     /**
  3832.      * This is for test reasons, many vendors have special requirements for dummy statements.
  3833.      *
  3834.      * @return string
  3835.      */
  3836.     public function getDummySelectSQL()
  3837.     {
  3838.         $expression = func_num_args() > 0 ? func_get_arg(0) : '1';
  3840.         return sprintf('SELECT %s', $expression);
  3841.     }
  3843.     /**
  3844.      * Returns the SQL to create a new savepoint.
  3845.      *
  3846.      * @param string $savepoint
  3847.      *
  3848.      * @return string
  3849.      */
  3850.     public function createSavePoint($savepoint)
  3851.     {
  3852.         return 'SAVEPOINT ' . $savepoint;
  3853.     }
  3855.     /**
  3856.      * Returns the SQL to release a savepoint.
  3857.      *
  3858.      * @param string $savepoint
  3859.      *
  3860.      * @return string
  3861.      */
  3862.     public function releaseSavePoint($savepoint)
  3863.     {
  3864.         return 'RELEASE SAVEPOINT ' . $savepoint;
  3865.     }
  3867.     /**
  3868.      * Returns the SQL to rollback a savepoint.
  3869.      *
  3870.      * @param string $savepoint
  3871.      *
  3872.      * @return string
  3873.      */
  3874.     public function rollbackSavePoint($savepoint)
  3875.     {
  3876.         return 'ROLLBACK TO SAVEPOINT ' . $savepoint;
  3877.     }
  3879.     /**
  3880.      * Returns the keyword list instance of this platform.
  3881.      *
  3882.      * @throws Exception If no keyword list is specified.
  3883.      */
  3884.     final public function getReservedKeywordsList(): KeywordList
  3885.     {
  3886.         // Check for an existing instantiation of the keywords class.
  3887.         if ($this->_keywords === null) {
  3888.             // Store the instance so it doesn't need to be generated on every request.
  3889.             $this->_keywords = $this->createReservedKeywordsList();
  3890.         }
  3892.         return $this->_keywords;
  3893.     }
  3895.     /**
  3896.      * Creates an instance of the reserved keyword list of this platform.
  3897.      *
  3898.      * This method will become @abstract in DBAL 4.0.0.
  3899.      *
  3900.      * @throws Exception
  3901.      */
  3902.     protected function createReservedKeywordsList(): KeywordList
  3903.     {
  3904.         $class    = $this->getReservedKeywordsClass();
  3905.         $keywords = new $class();
  3906.         if (! $keywords instanceof KeywordList) {
  3907.             throw Exception::notSupported(__METHOD__);
  3908.         }
  3910.         return $keywords;
  3911.     }
  3913.     /**
  3914.      * Returns the class name of the reserved keywords list.
  3915.      *
  3916.      * @deprecated Implement {@see createReservedKeywordsList()} instead.
  3917.      *
  3918.      * @return string
  3919.      * @psalm-return class-string<KeywordList>
  3920.      *
  3921.      * @throws Exception If not supported on this platform.
  3922.      */
  3923.     protected function getReservedKeywordsClass()
  3924.     {
  3925.         Deprecation::triggerIfCalledFromOutside(
  3926.             'doctrine/dbal',
  3927.             'https://github.com/doctrine/dbal/issues/4510',
  3928.             'AbstractPlatform::getReservedKeywordsClass() is deprecated,'
  3929.                 . ' use AbstractPlatform::createReservedKeywordsList() instead.'
  3930.         );
  3932.         throw Exception::notSupported(__METHOD__);
  3933.     }
  3935.     /**
  3936.      * Quotes a literal string.
  3937.      * This method is NOT meant to fix SQL injections!
  3938.      * It is only meant to escape this platform's string literal
  3939.      * quote character inside the given literal string.
  3940.      *
  3941.      * @param string $str The literal string to be quoted.
  3942.      *
  3943.      * @return string The quoted literal string.
  3944.      */
  3945.     public function quoteStringLiteral($str)
  3946.     {
  3947.         $c = $this->getStringLiteralQuoteCharacter();
  3949.         return $c . str_replace($c, $c . $c, $str) . $c;
  3950.     }
  3952.     /**
  3953.      * Gets the character used for string literal quoting.
  3954.      *
  3955.      * @return string
  3956.      */
  3957.     public function getStringLiteralQuoteCharacter()
  3958.     {
  3959.         return "'";
  3960.     }
  3962.     /**
  3963.      * Escapes metacharacters in a string intended to be used with a LIKE
  3964.      * operator.
  3965.      *
  3966.      * @param string $inputString a literal, unquoted string
  3967.      * @param string $escapeChar  should be reused by the caller in the LIKE
  3968.      *                            expression.
  3969.      */
  3970.     final public function escapeStringForLike(string $inputString, string $escapeChar): string
  3971.     {
  3972.         return preg_replace(
  3973.             '~([' . preg_quote($this->getLikeWildcardCharacters() . $escapeChar, '~') . '])~u',
  3974.             addcslashes($escapeChar, '\\') . '$1',
  3975.             $inputString
  3976.         );
  3977.     }
  3979.     /**
  3980.      * @return array<string,mixed> An associative array with the name of the properties
  3981.      *                             of the column being declared as array indexes.
  3982.      */
  3983.     private function columnToArray(Column $column): array
  3984.     {
  3985.         $name = $column->getQuotedName($this);
  3987.         $columnData = array_merge($column->toArray(), [
  3988.             'name' => $name,
  3989.             'version' => $column->hasPlatformOption('version') ? $column->getPlatformOption('version') : false,
  3990.             'comment' => $this->getColumnComment($column),
  3991.         ]);
  3993.         if ($columnData['type'] instanceof Types\StringType && $columnData['length'] === null) {
  3994.             $columnData['length'] = $this->getVarcharDefaultLength();
  3995.         }
  3997.         return $columnData;
  3998.     }
  4000.     /**
  4001.      * @internal
  4002.      */
  4003.     public function createSQLParser(): Parser
  4004.     {
  4005.         return new Parser(false);
  4006.     }
  4008.     protected function getLikeWildcardCharacters(): string
  4009.     {
  4010.         return '%_';
  4011.     }
  4013.     /**
  4014.      * Compares the definitions of the given columns in the context of this platform.
  4015.      *
  4016.      * @throws Exception
  4017.      */
  4018.     public function columnsEqual(Column $column1, Column $column2): bool
  4019.     {
  4020.         $column1Array = $this->columnToArray($column1);
  4021.         $column2Array = $this->columnToArray($column2);
  4023.         // ignore explicit columnDefinition since it's not set on the Column generated by the SchemaManager
  4024.         unset($column1Array['columnDefinition']);
  4025.         unset($column2Array['columnDefinition']);
  4027.         if (
  4028.             $this->getColumnDeclarationSQL('', $column1Array)
  4029.             !== $this->getColumnDeclarationSQL('', $column2Array)
  4030.         ) {
  4031.             return false;
  4032.         }
  4034.         // If the platform supports inline comments, all comparison is already done above
  4035.         if ($this->supportsInlineColumnComments()) {
  4036.             return true;
  4037.         }
  4039.         if ($column1->getComment() !== $column2->getComment()) {
  4040.             return false;
  4041.         }
  4043.         return $column1->getType() === $column2->getType();
  4044.     }
  4045. }