vendor/doctrine/dbal/src/Platforms/PostgreSQLPlatform.php line 806

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Platforms;
  5. use Doctrine\DBAL\Schema\Column;
  6. use Doctrine\DBAL\Schema\ColumnDiff;
  7. use Doctrine\DBAL\Schema\ForeignKeyConstraint;
  8. use Doctrine\DBAL\Schema\Identifier;
  9. use Doctrine\DBAL\Schema\Index;
  10. use Doctrine\DBAL\Schema\Sequence;
  11. use Doctrine\DBAL\Schema\TableDiff;
  12. use Doctrine\DBAL\Types\BigIntType;
  13. use Doctrine\DBAL\Types\BinaryType;
  14. use Doctrine\DBAL\Types\BlobType;
  15. use Doctrine\DBAL\Types\IntegerType;
  16. use Doctrine\DBAL\Types\Type;
  17. use Doctrine\Deprecations\Deprecation;
  18. use UnexpectedValueException;
  20. use function array_diff;
  21. use function array_merge;
  22. use function array_unique;
  23. use function array_values;
  24. use function count;
  25. use function explode;
  26. use function implode;
  27. use function in_array;
  28. use function is_array;
  29. use function is_bool;
  30. use function is_numeric;
  31. use function is_string;
  32. use function sprintf;
  33. use function strpos;
  34. use function strtolower;
  35. use function trim;
  37. /**
  38.  * Provides the behavior, features and SQL dialect of the PostgreSQL database platform of the oldest supported version.
  39.  */
  40. class PostgreSQLPlatform extends AbstractPlatform
  41. {
  42.     /** @var bool */
  43.     private $useBooleanTrueFalseStrings = true;
  45.     /** @var string[][] PostgreSQL booleans literals */
  46.     private $booleanLiterals = [
  47.         'true' => [
  48.             't',
  49.             'true',
  50.             'y',
  51.             'yes',
  52.             'on',
  53.             '1',
  54.         ],
  55.         'false' => [
  56.             'f',
  57.             'false',
  58.             'n',
  59.             'no',
  60.             'off',
  61.             '0',
  62.         ],
  63.     ];
  65.     /**
  66.      * PostgreSQL has different behavior with some drivers
  67.      * with regard to how booleans have to be handled.
  68.      *
  69.      * Enables use of 'true'/'false' or otherwise 1 and 0 instead.
  70.      *
  71.      * @param bool $flag
  72.      *
  73.      * @return void
  74.      */
  75.     public function setUseBooleanTrueFalseStrings($flag)
  76.     {
  77.         $this->useBooleanTrueFalseStrings = (bool) $flag;
  78.     }
  80.     /**
  81.      * {@inheritDoc}
  82.      */
  83.     public function getSubstringExpression($string, $start, $length = null)
  84.     {
  85.         if ($length === null) {
  86.             return 'SUBSTRING(' . $string . ' FROM ' . $start . ')';
  87.         }
  89.         return 'SUBSTRING(' . $string . ' FROM ' . $start . ' FOR ' . $length . ')';
  90.     }
  92.     /**
  93.      * {@inheritDoc}
  94.      *
  95.      * @deprecated Generate dates within the application.
  96.      */
  97.     public function getNowExpression()
  98.     {
  99.         Deprecation::trigger(
  100.             'doctrine/dbal',
  101.             'https://github.com/doctrine/dbal/pull/4753',
  102.             'PostgreSQLPlatform::getNowExpression() is deprecated. Generate dates within the application.'
  103.         );
  105.         return 'LOCALTIMESTAMP(0)';
  106.     }
  108.     /**
  109.      * {@inheritDoc}
  110.      */
  111.     public function getRegexpExpression()
  112.     {
  113.         return 'SIMILAR TO';
  114.     }
  116.     /**
  117.      * {@inheritDoc}
  118.      */
  119.     public function getLocateExpression($str, $substr, $startPos = false)
  120.     {
  121.         if ($startPos !== false) {
  122.             $str = $this->getSubstringExpression($str, $startPos);
  124.             return 'CASE WHEN (POSITION(' . $substr . ' IN ' . $str . ') = 0) THEN 0'
  125.                 . ' ELSE (POSITION(' . $substr . ' IN ' . $str . ') + ' . $startPos . ' - 1) END';
  126.         }
  128.         return 'POSITION(' . $substr . ' IN ' . $str . ')';
  129.     }
  131.     /**
  132.      * {@inheritdoc}
  133.      */
  134.     protected function getDateArithmeticIntervalExpression($date, $operator, $interval, $unit)
  135.     {
  136.         if ($unit === DateIntervalUnit::QUARTER) {
  137.             $interval *= 3;
  138.             $unit      = DateIntervalUnit::MONTH;
  139.         }
  141.         return '(' . $date . ' ' . $operator . ' (' . $interval . " || ' " . $unit . "')::interval)";
  142.     }
  144.     /**
  145.      * {@inheritDoc}
  146.      */
  147.     public function getDateDiffExpression($date1, $date2)
  148.     {
  149.         return '(DATE(' . $date1 . ')-DATE(' . $date2 . '))';
  150.     }
  152.     public function getCurrentDatabaseExpression(): string
  153.     {
  154.         return 'CURRENT_DATABASE()';
  155.     }
  157.     /**
  158.      * {@inheritDoc}
  159.      */
  160.     public function supportsSequences()
  161.     {
  162.         return true;
  163.     }
  165.     /**
  166.      * {@inheritDoc}
  167.      */
  168.     public function supportsSchemas()
  169.     {
  170.         return true;
  171.     }
  173.     /**
  174.      * {@inheritdoc}
  175.      */
  176.     public function getDefaultSchemaName()
  177.     {
  178.         return 'public';
  179.     }
  181.     /**
  182.      * {@inheritDoc}
  183.      */
  184.     public function supportsIdentityColumns()
  185.     {
  186.         return true;
  187.     }
  189.     /**
  190.      * {@inheritdoc}
  191.      */
  192.     public function supportsPartialIndexes()
  193.     {
  194.         return true;
  195.     }
  197.     /**
  198.      * {@inheritdoc}
  199.      */
  200.     public function usesSequenceEmulatedIdentityColumns()
  201.     {
  202.         return true;
  203.     }
  205.     /**
  206.      * {@inheritdoc}
  207.      */
  208.     public function getIdentitySequenceName($tableName, $columnName)
  209.     {
  210.         return $tableName . '_' . $columnName . '_seq';
  211.     }
  213.     /**
  214.      * {@inheritDoc}
  215.      */
  216.     public function supportsCommentOnStatement()
  217.     {
  218.         return true;
  219.     }
  221.     /**
  222.      * {@inheritDoc}
  223.      */
  224.     public function hasNativeGuidType()
  225.     {
  226.         return true;
  227.     }
  229.     /**
  230.      * {@inheritDoc}
  231.      */
  232.     public function getListDatabasesSQL()
  233.     {
  234.         return 'SELECT datname FROM pg_database';
  235.     }
  237.     /**
  238.      * {@inheritDoc}
  239.      *
  240.      * @deprecated Use {@see PostgreSQLSchemaManager::listSchemaNames()} instead.
  241.      */
  242.     public function getListNamespacesSQL()
  243.     {
  244.         Deprecation::triggerIfCalledFromOutside(
  245.             'doctrine/dbal',
  246.             'https://github.com/doctrine/dbal/issues/4503',
  247.             'PostgreSQLPlatform::getListNamespacesSQL() is deprecated,'
  248.                 . ' use PostgreSQLSchemaManager::listSchemaNames() instead.'
  249.         );
  251.         return "SELECT schema_name AS nspname
  252.                 FROM   information_schema.schemata
  253.                 WHERE  schema_name NOT LIKE 'pg\_%'
  254.                 AND    schema_name != 'information_schema'";
  255.     }
  257.     /**
  258.      * {@inheritDoc}
  259.      */
  260.     public function getListSequencesSQL($database)
  261.     {
  262.         return "SELECT sequence_name AS relname,
  263.                        sequence_schema AS schemaname
  264.                 FROM   information_schema.sequences
  265.                 WHERE  sequence_schema NOT LIKE 'pg\_%'
  266.                 AND    sequence_schema != 'information_schema'";
  267.     }
  269.     /**
  270.      * {@inheritDoc}
  271.      */
  272.     public function getListTablesSQL()
  273.     {
  274.         return "SELECT quote_ident(table_name) AS table_name,
  275.                        table_schema AS schema_name
  276.                 FROM   information_schema.tables
  277.                 WHERE  table_schema NOT LIKE 'pg\_%'
  278.                 AND    table_schema != 'information_schema'
  279.                 AND    table_name != 'geometry_columns'
  280.                 AND    table_name != 'spatial_ref_sys'
  281.                 AND    table_type != 'VIEW'";
  282.     }
  284.     /**
  285.      * {@inheritDoc}
  286.      */
  287.     public function getListViewsSQL($database)
  288.     {
  289.         return 'SELECT quote_ident(table_name) AS viewname,
  290.                        table_schema AS schemaname,
  291.                        view_definition AS definition
  292.                 FROM   information_schema.views
  293.                 WHERE  view_definition IS NOT NULL';
  294.     }
  296.     /**
  297.      * @param string      $table
  298.      * @param string|null $database
  299.      *
  300.      * @return string
  301.      */
  302.     public function getListTableForeignKeysSQL($table, $database = null)
  303.     {
  304.         return 'SELECT quote_ident(r.conname) as conname, pg_catalog.pg_get_constraintdef(r.oid, true) as condef
  305.                   FROM pg_catalog.pg_constraint r
  306.                   WHERE r.conrelid =
  307.                   (
  308.                       SELECT c.oid
  309.                       FROM pg_catalog.pg_class c, pg_catalog.pg_namespace n
  310.                       WHERE ' . $this->getTableWhereClause($table) . " AND n.oid = c.relnamespace
  311.                   )
  312.                   AND r.contype = 'f'";
  313.     }
  315.     /**
  316.      * {@inheritDoc}
  317.      */
  318.     public function getListTableConstraintsSQL($table)
  319.     {
  320.         $table = new Identifier($table);
  321.         $table = $this->quoteStringLiteral($table->getName());
  323.         return sprintf(
  324.             <<<'SQL'
  325. SELECT
  326.     quote_ident(relname) as relname
  327. FROM
  328.     pg_class
  329. WHERE oid IN (
  330.     SELECT indexrelid
  331.     FROM pg_index, pg_class
  332.     WHERE pg_class.relname = %s
  333.         AND pg_class.oid = pg_index.indrelid
  334.         AND (indisunique = 't' OR indisprimary = 't')
  335.     )
  336. SQL
  337.             ,
  338.             $table
  339.         );
  340.     }
  342.     /**
  343.      * {@inheritDoc}
  344.      *
  345.      * @link http://ezcomponents.org/docs/api/trunk/DatabaseSchema/ezcDbSchemaPgsqlReader.html
  346.      */
  347.     public function getListTableIndexesSQL($table, $database = null)
  348.     {
  349.         return 'SELECT quote_ident(relname) as relname, pg_index.indisunique, pg_index.indisprimary,
  350.                        pg_index.indkey, pg_index.indrelid,
  351.                        pg_get_expr(indpred, indrelid) AS where
  352.                  FROM pg_class, pg_index
  353.                  WHERE oid IN (
  354.                     SELECT indexrelid
  355.                     FROM pg_index si, pg_class sc, pg_namespace sn
  356.                     WHERE ' . $this->getTableWhereClause($table, 'sc', 'sn') . '
  357.                     AND sc.oid=si.indrelid AND sc.relnamespace = sn.oid
  358.                  ) AND pg_index.indexrelid = oid';
  359.     }
  361.     /**
  362.      * @param string $table
  363.      * @param string $classAlias
  364.      * @param string $namespaceAlias
  365.      */
  366.     private function getTableWhereClause($table, $classAlias = 'c', $namespaceAlias = 'n'): string
  367.     {
  368.         $whereClause = $namespaceAlias . ".nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast') AND ";
  369.         if (strpos($table, '.') !== false) {
  370.             [$schema, $table] = explode('.', $table);
  371.             $schema           = $this->quoteStringLiteral($schema);
  372.         } else {
  373.             $schema = 'ANY(current_schemas(false))';
  374.         }
  376.         $table = new Identifier($table);
  377.         $table = $this->quoteStringLiteral($table->getName());
  379.         return $whereClause . sprintf(
  380.             '%s.relname = %s AND %s.nspname = %s',
  381.             $classAlias,
  382.             $table,
  383.             $namespaceAlias,
  384.             $schema
  385.         );
  386.     }
  388.     /**
  389.      * {@inheritDoc}
  390.      */
  391.     public function getListTableColumnsSQL($table, $database = null)
  392.     {
  393.         return "SELECT
  394.                     a.attnum,
  395.                     quote_ident(a.attname) AS field,
  396.                     t.typname AS type,
  397.                     format_type(a.atttypid, a.atttypmod) AS complete_type,
  398.                     (SELECT tc.collcollate FROM pg_catalog.pg_collation tc WHERE tc.oid = a.attcollation) AS collation,
  399.                     (SELECT t1.typname FROM pg_catalog.pg_type t1 WHERE t1.oid = t.typbasetype) AS domain_type,
  400.                     (SELECT format_type(t2.typbasetype, t2.typtypmod) FROM
  401.                       pg_catalog.pg_type t2 WHERE t2.typtype = 'd' AND t2.oid = a.atttypid) AS domain_complete_type,
  402.                     a.attnotnull AS isnotnull,
  403.                     (SELECT 't'
  404.                      FROM pg_index
  405.                      WHERE c.oid = pg_index.indrelid
  406.                         AND pg_index.indkey[0] = a.attnum
  407.                         AND pg_index.indisprimary = 't'
  408.                     ) AS pri,
  409.                     (SELECT pg_get_expr(adbin, adrelid)
  410.                      FROM pg_attrdef
  411.                      WHERE c.oid = pg_attrdef.adrelid
  412.                         AND pg_attrdef.adnum=a.attnum
  413.                     ) AS default,
  414.                     (SELECT pg_description.description
  415.                         FROM pg_description WHERE pg_description.objoid = c.oid AND a.attnum = pg_description.objsubid
  416.                     ) AS comment
  417.                     FROM pg_attribute a, pg_class c, pg_type t, pg_namespace n
  418.                     WHERE " . $this->getTableWhereClause($table, 'c', 'n') . '
  419.                         AND a.attnum > 0
  420.                         AND a.attrelid = c.oid
  421.                         AND a.atttypid = t.oid
  422.                         AND n.oid = c.relnamespace
  423.                     ORDER BY a.attnum';
  424.     }
  426.     /**
  427.      * {@inheritDoc}
  428.      */
  429.     public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey)
  430.     {
  431.         $query = '';
  433.         if ($foreignKey->hasOption('match')) {
  434.             $query .= ' MATCH ' . $foreignKey->getOption('match');
  435.         }
  437.         $query .= parent::getAdvancedForeignKeyOptionsSQL($foreignKey);
  439.         if ($foreignKey->hasOption('deferrable') && $foreignKey->getOption('deferrable') !== false) {
  440.             $query .= ' DEFERRABLE';
  441.         } else {
  442.             $query .= ' NOT DEFERRABLE';
  443.         }
  445.         if (
  446.             ($foreignKey->hasOption('feferred') && $foreignKey->getOption('feferred') !== false)
  447.             || ($foreignKey->hasOption('deferred') && $foreignKey->getOption('deferred') !== false)
  448.         ) {
  449.             $query .= ' INITIALLY DEFERRED';
  450.         } else {
  451.             $query .= ' INITIALLY IMMEDIATE';
  452.         }
  454.         return $query;
  455.     }
  457.     /**
  458.      * {@inheritDoc}
  459.      */
  460.     public function getAlterTableSQL(TableDiff $diff)
  461.     {
  462.         $sql         = [];
  463.         $commentsSQL = [];
  464.         $columnSql   = [];
  466.         foreach ($diff->addedColumns as $column) {
  467.             if ($this->onSchemaAlterTableAddColumn($column, $diff, $columnSql)) {
  468.                 continue;
  469.             }
  471.             $query = 'ADD ' . $this->getColumnDeclarationSQL($column->getQuotedName($this), $column->toArray());
  472.             $sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query;
  474.             $comment = $this->getColumnComment($column);
  476.             if ($comment === null || $comment === '') {
  477.                 continue;
  478.             }
  480.             $commentsSQL[] = $this->getCommentOnColumnSQL(
  481.                 $diff->getName($this)->getQuotedName($this),
  482.                 $column->getQuotedName($this),
  483.                 $comment
  484.             );
  485.         }
  487.         foreach ($diff->removedColumns as $column) {
  488.             if ($this->onSchemaAlterTableRemoveColumn($column, $diff, $columnSql)) {
  489.                 continue;
  490.             }
  492.             $query = 'DROP ' . $column->getQuotedName($this);
  493.             $sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query;
  494.         }
  496.         foreach ($diff->changedColumns as $columnDiff) {
  497.             if ($this->onSchemaAlterTableChangeColumn($columnDiff, $diff, $columnSql)) {
  498.                 continue;
  499.             }
  501.             if ($this->isUnchangedBinaryColumn($columnDiff)) {
  502.                 continue;
  503.             }
  505.             $oldColumnName = $columnDiff->getOldColumnName()->getQuotedName($this);
  506.             $column        = $columnDiff->column;
  508.             if (
  509.                 $columnDiff->hasChanged('type')
  510.                 || $columnDiff->hasChanged('precision')
  511.                 || $columnDiff->hasChanged('scale')
  512.                 || $columnDiff->hasChanged('fixed')
  513.             ) {
  514.                 $type = $column->getType();
  516.                 // SERIAL/BIGSERIAL are not "real" types and we can't alter a column to that type
  517.                 $columnDefinition                  = $column->toArray();
  518.                 $columnDefinition['autoincrement'] = false;
  520.                 // here was a server version check before, but DBAL API does not support this anymore.
  521.                 $query = 'ALTER ' . $oldColumnName . ' TYPE ' . $type->getSQLDeclaration($columnDefinition, $this);
  522.                 $sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query;
  523.             }
  525.             if ($columnDiff->hasChanged('default') || $this->typeChangeBreaksDefaultValue($columnDiff)) {
  526.                 $defaultClause = $column->getDefault() === null
  527.                     ? ' DROP DEFAULT'
  528.                     : ' SET' . $this->getDefaultValueDeclarationSQL($column->toArray());
  529.                 $query         = 'ALTER ' . $oldColumnName . $defaultClause;
  530.                 $sql[]         = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query;
  531.             }
  533.             if ($columnDiff->hasChanged('notnull')) {
  534.                 $query = 'ALTER ' . $oldColumnName . ' ' . ($column->getNotnull() ? 'SET' : 'DROP') . ' NOT NULL';
  535.                 $sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query;
  536.             }
  538.             if ($columnDiff->hasChanged('autoincrement')) {
  539.                 if ($column->getAutoincrement()) {
  540.                     // add autoincrement
  541.                     $seqName = $this->getIdentitySequenceName($diff->name, $oldColumnName);
  543.                     $sql[] = 'CREATE SEQUENCE ' . $seqName;
  544.                     $sql[] = "SELECT setval('" . $seqName . "', (SELECT MAX(" . $oldColumnName . ') FROM '
  545.                         . $diff->getName($this)->getQuotedName($this) . '))';
  546.                     $query = 'ALTER ' . $oldColumnName . " SET DEFAULT nextval('" . $seqName . "')";
  547.                     $sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query;
  548.                 } else {
  549.                     // Drop autoincrement, but do NOT drop the sequence. It might be re-used by other tables or have
  550.                     $query = 'ALTER ' . $oldColumnName . ' DROP DEFAULT';
  551.                     $sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query;
  552.                 }
  553.             }
  555.             $newComment = $this->getColumnComment($column);
  556.             $oldComment = $this->getOldColumnComment($columnDiff);
  558.             if (
  559.                 $columnDiff->hasChanged('comment')
  560.                 || ($columnDiff->fromColumn !== null && $oldComment !== $newComment)
  561.             ) {
  562.                 $commentsSQL[] = $this->getCommentOnColumnSQL(
  563.                     $diff->getName($this)->getQuotedName($this),
  564.                     $column->getQuotedName($this),
  565.                     $newComment
  566.                 );
  567.             }
  569.             if (! $columnDiff->hasChanged('length')) {
  570.                 continue;
  571.             }
  573.             $query = 'ALTER ' . $oldColumnName . ' TYPE '
  574.                 . $column->getType()->getSQLDeclaration($column->toArray(), $this);
  575.             $sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) . ' ' . $query;
  576.         }
  578.         foreach ($diff->renamedColumns as $oldColumnName => $column) {
  579.             if ($this->onSchemaAlterTableRenameColumn($oldColumnName, $column, $diff, $columnSql)) {
  580.                 continue;
  581.             }
  583.             $oldColumnName = new Identifier($oldColumnName);
  585.             $sql[] = 'ALTER TABLE ' . $diff->getName($this)->getQuotedName($this) .
  586.                 ' RENAME COLUMN ' . $oldColumnName->getQuotedName($this) . ' TO ' . $column->getQuotedName($this);
  587.         }
  589.         $tableSql = [];
  591.         if (! $this->onSchemaAlterTable($diff, $tableSql)) {
  592.             $sql = array_merge($sql, $commentsSQL);
  594.             $newName = $diff->getNewName();
  596.             if ($newName !== false) {
  597.                 $sql[] = sprintf(
  598.                     'ALTER TABLE %s RENAME TO %s',
  599.                     $diff->getName($this)->getQuotedName($this),
  600.                     $newName->getQuotedName($this)
  601.                 );
  602.             }
  604.             $sql = array_merge(
  605.                 $this->getPreAlterTableIndexForeignKeySQL($diff),
  606.                 $sql,
  607.                 $this->getPostAlterTableIndexForeignKeySQL($diff)
  608.             );
  609.         }
  611.         return array_merge($sql, $tableSql, $columnSql);
  612.     }
  614.     /**
  615.      * Checks whether a given column diff is a logically unchanged binary type column.
  616.      *
  617.      * Used to determine whether a column alteration for a binary type column can be skipped.
  618.      * Doctrine's {@see BinaryType} and {@see BlobType} are mapped to the same database column type on this platform
  619.      * as this platform does not have a native VARBINARY/BINARY column type. Therefore the comparator
  620.      * might detect differences for binary type columns which do not have to be propagated
  621.      * to database as there actually is no difference at database level.
  622.      */
  623.     private function isUnchangedBinaryColumn(ColumnDiff $columnDiff): bool
  624.     {
  625.         $columnType = $columnDiff->column->getType();
  627.         if (! $columnType instanceof BinaryType && ! $columnType instanceof BlobType) {
  628.             return false;
  629.         }
  631.         $fromColumn = $columnDiff->fromColumn instanceof Column ? $columnDiff->fromColumn : null;
  633.         if ($fromColumn !== null) {
  634.             $fromColumnType = $fromColumn->getType();
  636.             if (! $fromColumnType instanceof BinaryType && ! $fromColumnType instanceof BlobType) {
  637.                 return false;
  638.             }
  640.             return count(array_diff($columnDiff->changedProperties, ['type', 'length', 'fixed'])) === 0;
  641.         }
  643.         if ($columnDiff->hasChanged('type')) {
  644.             return false;
  645.         }
  647.         return count(array_diff($columnDiff->changedProperties, ['length', 'fixed'])) === 0;
  648.     }
  650.     /**
  651.      * {@inheritdoc}
  652.      */
  653.     protected function getRenameIndexSQL($oldIndexName, Index $index, $tableName)
  654.     {
  655.         if (strpos($tableName, '.') !== false) {
  656.             [$schema]     = explode('.', $tableName);
  657.             $oldIndexName = $schema . '.' . $oldIndexName;
  658.         }
  660.         return ['ALTER INDEX ' . $oldIndexName . ' RENAME TO ' . $index->getQuotedName($this)];
  661.     }
  663.     /**
  664.      * {@inheritdoc}
  665.      */
  666.     public function getCommentOnColumnSQL($tableName, $columnName, $comment)
  667.     {
  668.         $tableName  = new Identifier($tableName);
  669.         $columnName = new Identifier($columnName);
  670.         $comment    = $comment === null ? 'NULL' : $this->quoteStringLiteral($comment);
  672.         return sprintf(
  673.             'COMMENT ON COLUMN %s.%s IS %s',
  674.             $tableName->getQuotedName($this),
  675.             $columnName->getQuotedName($this),
  676.             $comment
  677.         );
  678.     }
  680.     /**
  681.      * {@inheritDoc}
  682.      */
  683.     public function getCreateSequenceSQL(Sequence $sequence)
  684.     {
  685.         return 'CREATE SEQUENCE ' . $sequence->getQuotedName($this) .
  686.             ' INCREMENT BY ' . $sequence->getAllocationSize() .
  687.             ' MINVALUE ' . $sequence->getInitialValue() .
  688.             ' START ' . $sequence->getInitialValue() .
  689.             $this->getSequenceCacheSQL($sequence);
  690.     }
  692.     /**
  693.      * {@inheritDoc}
  694.      */
  695.     public function getAlterSequenceSQL(Sequence $sequence)
  696.     {
  697.         return 'ALTER SEQUENCE ' . $sequence->getQuotedName($this) .
  698.             ' INCREMENT BY ' . $sequence->getAllocationSize() .
  699.             $this->getSequenceCacheSQL($sequence);
  700.     }
  702.     /**
  703.      * Cache definition for sequences
  704.      */
  705.     private function getSequenceCacheSQL(Sequence $sequence): string
  706.     {
  707.         if ($sequence->getCache() > 1) {
  708.             return ' CACHE ' . $sequence->getCache();
  709.         }
  711.         return '';
  712.     }
  714.     /**
  715.      * {@inheritDoc}
  716.      */
  717.     public function getDropSequenceSQL($sequence)
  718.     {
  719.         return parent::getDropSequenceSQL($sequence) . ' CASCADE';
  720.     }
  722.     /**
  723.      * {@inheritDoc}
  724.      */
  725.     public function getDropForeignKeySQL($foreignKey, $table)
  726.     {
  727.         return $this->getDropConstraintSQL($foreignKey, $table);
  728.     }
  730.     /**
  731.      * {@inheritDoc}
  732.      */
  733.     protected function _getCreateTableSQL($name, array $columns, array $options = [])
  734.     {
  735.         $queryFields = $this->getColumnDeclarationListSQL($columns);
  737.         if (isset($options['primary']) && ! empty($options['primary'])) {
  738.             $keyColumns   = array_unique(array_values($options['primary']));
  739.             $queryFields .= ', PRIMARY KEY(' . implode(', ', $keyColumns) . ')';
  740.         }
  742.         $query = 'CREATE TABLE ' . $name . ' (' . $queryFields . ')';
  744.         $sql = [$query];
  746.         if (isset($options['indexes']) && ! empty($options['indexes'])) {
  747.             foreach ($options['indexes'] as $index) {
  748.                 $sql[] = $this->getCreateIndexSQL($index, $name);
  749.             }
  750.         }
  752.         if (isset($options['uniqueConstraints'])) {
  753.             foreach ($options['uniqueConstraints'] as $uniqueConstraint) {
  754.                 $sql[] = $this->getCreateConstraintSQL($uniqueConstraint, $name);
  755.             }
  756.         }
  758.         if (isset($options['foreignKeys'])) {
  759.             foreach ((array) $options['foreignKeys'] as $definition) {
  760.                 $sql[] = $this->getCreateForeignKeySQL($definition, $name);
  761.             }
  762.         }
  764.         return $sql;
  765.     }
  767.     /**
  768.      * Converts a single boolean value.
  769.      *
  770.      * First converts the value to its native PHP boolean type
  771.      * and passes it to the given callback function to be reconverted
  772.      * into any custom representation.
  773.      *
  774.      * @param mixed    $value    The value to convert.
  775.      * @param callable $callback The callback function to use for converting the real boolean value.
  776.      *
  777.      * @return mixed
  778.      *
  779.      * @throws UnexpectedValueException
  780.      */
  781.     private function convertSingleBooleanValue($value, $callback)
  782.     {
  783.         if ($value === null) {
  784.             return $callback(null);
  785.         }
  787.         if (is_bool($value) || is_numeric($value)) {
  788.             return $callback((bool) $value);
  789.         }
  791.         if (! is_string($value)) {
  792.             return $callback(true);
  793.         }
  795.         /**
  796.          * Better safe than sorry: http://php.net/in_array#106319
  797.          */
  798.         if (in_array(strtolower(trim($value)), $this->booleanLiterals['false'], true)) {
  799.             return $callback(false);
  800.         }
  802.         if (in_array(strtolower(trim($value)), $this->booleanLiterals['true'], true)) {
  803.             return $callback(true);
  804.         }
  806.         throw new UnexpectedValueException("Unrecognized boolean literal '${value}'");
  807.     }
  809.     /**
  810.      * Converts one or multiple boolean values.
  811.      *
  812.      * First converts the value(s) to their native PHP boolean type
  813.      * and passes them to the given callback function to be reconverted
  814.      * into any custom representation.
  815.      *
  816.      * @param mixed    $item     The value(s) to convert.
  817.      * @param callable $callback The callback function to use for converting the real boolean value(s).
  818.      *
  819.      * @return mixed
  820.      */
  821.     private function doConvertBooleans($item, $callback)
  822.     {
  823.         if (is_array($item)) {
  824.             foreach ($item as $key => $value) {
  825.                 $item[$key] = $this->convertSingleBooleanValue($value, $callback);
  826.             }
  828.             return $item;
  829.         }
  831.         return $this->convertSingleBooleanValue($item, $callback);
  832.     }
  834.     /**
  835.      * {@inheritDoc}
  836.      *
  837.      * Postgres wants boolean values converted to the strings 'true'/'false'.
  838.      */
  839.     public function convertBooleans($item)
  840.     {
  841.         if (! $this->useBooleanTrueFalseStrings) {
  842.             return parent::convertBooleans($item);
  843.         }
  845.         return $this->doConvertBooleans(
  846.             $item,
  847.             /**
  848.              * @param mixed $value
  849.              */
  850.             static function ($value) {
  851.                 if ($value === null) {
  852.                     return 'NULL';
  853.                 }
  855.                 return $value === true ? 'true' : 'false';
  856.             }
  857.         );
  858.     }
  860.     /**
  861.      * {@inheritDoc}
  862.      */
  863.     public function convertBooleansToDatabaseValue($item)
  864.     {
  865.         if (! $this->useBooleanTrueFalseStrings) {
  866.             return parent::convertBooleansToDatabaseValue($item);
  867.         }
  869.         return $this->doConvertBooleans(
  870.             $item,
  871.             /**
  872.              * @param mixed $value
  873.              */
  874.             static function ($value): ?int {
  875.                 return $value === null ? null : (int) $value;
  876.             }
  877.         );
  878.     }
  880.     /**
  881.      * {@inheritDoc}
  882.      */
  883.     public function convertFromBoolean($item)
  884.     {
  885.         if ($item !== null && in_array(strtolower($item), $this->booleanLiterals['false'], true)) {
  886.             return false;
  887.         }
  889.         return parent::convertFromBoolean($item);
  890.     }
  892.     /**
  893.      * {@inheritDoc}
  894.      */
  895.     public function getSequenceNextValSQL($sequence)
  896.     {
  897.         return "SELECT NEXTVAL('" . $sequence . "')";
  898.     }
  900.     /**
  901.      * {@inheritDoc}
  902.      */
  903.     public function getSetTransactionIsolationSQL($level)
  904.     {
  905.         return 'SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL '
  906.             . $this->_getTransactionIsolationLevelSQL($level);
  907.     }
  909.     /**
  910.      * {@inheritDoc}
  911.      */
  912.     public function getBooleanTypeDeclarationSQL(array $column)
  913.     {
  914.         return 'BOOLEAN';
  915.     }
  917.     /**
  918.      * {@inheritDoc}
  919.      */
  920.     public function getIntegerTypeDeclarationSQL(array $column)
  921.     {
  922.         if (! empty($column['autoincrement'])) {
  923.             return 'SERIAL';
  924.         }
  926.         return 'INT';
  927.     }
  929.     /**
  930.      * {@inheritDoc}
  931.      */
  932.     public function getBigIntTypeDeclarationSQL(array $column)
  933.     {
  934.         if (! empty($column['autoincrement'])) {
  935.             return 'BIGSERIAL';
  936.         }
  938.         return 'BIGINT';
  939.     }
  941.     /**
  942.      * {@inheritDoc}
  943.      */
  944.     public function getSmallIntTypeDeclarationSQL(array $column)
  945.     {
  946.         if (! empty($column['autoincrement'])) {
  947.             return 'SMALLSERIAL';
  948.         }
  950.         return 'SMALLINT';
  951.     }
  953.     /**
  954.      * {@inheritDoc}
  955.      */
  956.     public function getGuidTypeDeclarationSQL(array $column)
  957.     {
  958.         return 'UUID';
  959.     }
  961.     /**
  962.      * {@inheritDoc}
  963.      */
  964.     public function getDateTimeTypeDeclarationSQL(array $column)
  965.     {
  966.         return 'TIMESTAMP(0) WITHOUT TIME ZONE';
  967.     }
  969.     /**
  970.      * {@inheritDoc}
  971.      */
  972.     public function getDateTimeTzTypeDeclarationSQL(array $column)
  973.     {
  974.         return 'TIMESTAMP(0) WITH TIME ZONE';
  975.     }
  977.     /**
  978.      * {@inheritDoc}
  979.      */
  980.     public function getDateTypeDeclarationSQL(array $column)
  981.     {
  982.         return 'DATE';
  983.     }
  985.     /**
  986.      * {@inheritDoc}
  987.      */
  988.     public function getTimeTypeDeclarationSQL(array $column)
  989.     {
  990.         return 'TIME(0) WITHOUT TIME ZONE';
  991.     }
  993.     /**
  994.      * {@inheritDoc}
  995.      */
  996.     protected function _getCommonIntegerTypeDeclarationSQL(array $column)
  997.     {
  998.         return '';
  999.     }
  1001.     /**
  1002.      * {@inheritDoc}
  1003.      */
  1004.     protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed)
  1005.     {
  1006.         return $fixed ? ($length > 0 ? 'CHAR(' . $length . ')' : 'CHAR(255)')
  1007.             : ($length > 0 ? 'VARCHAR(' . $length . ')' : 'VARCHAR(255)');
  1008.     }
  1010.     /**
  1011.      * {@inheritdoc}
  1012.      */
  1013.     protected function getBinaryTypeDeclarationSQLSnippet($length, $fixed)
  1014.     {
  1015.         return 'BYTEA';
  1016.     }
  1018.     /**
  1019.      * {@inheritDoc}
  1020.      */
  1021.     public function getClobTypeDeclarationSQL(array $column)
  1022.     {
  1023.         return 'TEXT';
  1024.     }
  1026.     /**
  1027.      * {@inheritDoc}
  1028.      */
  1029.     public function getName()
  1030.     {
  1031.         Deprecation::triggerIfCalledFromOutside(
  1032.             'doctrine/dbal',
  1033.             'https://github.com/doctrine/dbal/issues/4749',
  1034.             'PostgreSQLPlatform::getName() is deprecated. Identify platforms by their class.'
  1035.         );
  1037.         return 'postgresql';
  1038.     }
  1040.     /**
  1041.      * {@inheritDoc}
  1042.      */
  1043.     public function getDateTimeTzFormatString()
  1044.     {
  1045.         return 'Y-m-d H:i:sO';
  1046.     }
  1048.     /**
  1049.      * {@inheritDoc}
  1050.      */
  1051.     public function getEmptyIdentityInsertSQL($quotedTableName, $quotedIdentifierColumnName)
  1052.     {
  1053.         return 'INSERT INTO ' . $quotedTableName . ' (' . $quotedIdentifierColumnName . ') VALUES (DEFAULT)';
  1054.     }
  1056.     /**
  1057.      * {@inheritDoc}
  1058.      */
  1059.     public function getTruncateTableSQL($tableName, $cascade = false)
  1060.     {
  1061.         $tableIdentifier = new Identifier($tableName);
  1062.         $sql             = 'TRUNCATE ' . $tableIdentifier->getQuotedName($this);
  1064.         if ($cascade) {
  1065.             $sql .= ' CASCADE';
  1066.         }
  1068.         return $sql;
  1069.     }
  1071.     /**
  1072.      * {@inheritDoc}
  1073.      */
  1074.     public function getReadLockSQL()
  1075.     {
  1076.         return 'FOR SHARE';
  1077.     }
  1079.     /**
  1080.      * {@inheritDoc}
  1081.      */
  1082.     protected function initializeDoctrineTypeMappings()
  1083.     {
  1084.         $this->doctrineTypeMapping = [
  1085.             'bigint'           => 'bigint',
  1086.             'bigserial'        => 'bigint',
  1087.             'bool'             => 'boolean',
  1088.             'boolean'          => 'boolean',
  1089.             'bpchar'           => 'string',
  1090.             'bytea'            => 'blob',
  1091.             'char'             => 'string',
  1092.             'date'             => 'date',
  1093.             'datetime'         => 'datetime',
  1094.             'decimal'          => 'decimal',
  1095.             'double'           => 'float',
  1096.             'double precision' => 'float',
  1097.             'float'            => 'float',
  1098.             'float4'           => 'float',
  1099.             'float8'           => 'float',
  1100.             'inet'             => 'string',
  1101.             'int'              => 'integer',
  1102.             'int2'             => 'smallint',
  1103.             'int4'             => 'integer',
  1104.             'int8'             => 'bigint',
  1105.             'integer'          => 'integer',
  1106.             'interval'         => 'string',
  1107.             'json'             => 'json',
  1108.             'jsonb'            => 'json',
  1109.             'money'            => 'decimal',
  1110.             'numeric'          => 'decimal',
  1111.             'serial'           => 'integer',
  1112.             'serial4'          => 'integer',
  1113.             'serial8'          => 'bigint',
  1114.             'real'             => 'float',
  1115.             'smallint'         => 'smallint',
  1116.             'text'             => 'text',
  1117.             'time'             => 'time',
  1118.             'timestamp'        => 'datetime',
  1119.             'timestamptz'      => 'datetimetz',
  1120.             'timetz'           => 'time',
  1121.             'tsvector'         => 'text',
  1122.             'uuid'             => 'guid',
  1123.             'varchar'          => 'string',
  1124.             'year'             => 'date',
  1125.             '_varchar'         => 'string',
  1126.         ];
  1127.     }
  1129.     /**
  1130.      * {@inheritDoc}
  1131.      */
  1132.     public function getVarcharMaxLength()
  1133.     {
  1134.         return 65535;
  1135.     }
  1137.     /**
  1138.      * {@inheritdoc}
  1139.      */
  1140.     public function getBinaryMaxLength()
  1141.     {
  1142.         return 0;
  1143.     }
  1145.     /**
  1146.      * {@inheritdoc}
  1147.      */
  1148.     public function getBinaryDefaultLength()
  1149.     {
  1150.         return 0;
  1151.     }
  1153.     /**
  1154.      * {@inheritdoc}
  1155.      */
  1156.     public function hasNativeJsonType()
  1157.     {
  1158.         return true;
  1159.     }
  1161.     /**
  1162.      * {@inheritDoc}
  1163.      *
  1164.      * @deprecated Implement {@see createReservedKeywordsList()} instead.
  1165.      */
  1166.     protected function getReservedKeywordsClass()
  1167.     {
  1168.         Deprecation::triggerIfCalledFromOutside(
  1169.             'doctrine/dbal',
  1170.             'https://github.com/doctrine/dbal/issues/4510',
  1171.             'PostgreSQLPlatform::getReservedKeywordsClass() is deprecated,'
  1172.                 . ' use PostgreSQLPlatform::createReservedKeywordsList() instead.'
  1173.         );
  1175.         return Keywords\PostgreSQL94Keywords::class;
  1176.     }
  1178.     /**
  1179.      * {@inheritDoc}
  1180.      */
  1181.     public function getBlobTypeDeclarationSQL(array $column)
  1182.     {
  1183.         return 'BYTEA';
  1184.     }
  1186.     /**
  1187.      * {@inheritdoc}
  1188.      */
  1189.     public function getDefaultValueDeclarationSQL($column)
  1190.     {
  1191.         if ($this->isSerialColumn($column)) {
  1192.             return '';
  1193.         }
  1195.         return parent::getDefaultValueDeclarationSQL($column);
  1196.     }
  1198.     /**
  1199.      * {@inheritdoc}
  1200.      */
  1201.     public function supportsColumnCollation()
  1202.     {
  1203.         return true;
  1204.     }
  1206.     /**
  1207.      * {@inheritdoc}
  1208.      */
  1209.     public function getColumnCollationDeclarationSQL($collation)
  1210.     {
  1211.         return 'COLLATE ' . $this->quoteSingleIdentifier($collation);
  1212.     }
  1214.     /**
  1215.      * {@inheritdoc}
  1216.      */
  1217.     public function getJsonTypeDeclarationSQL(array $column)
  1218.     {
  1219.         if (! empty($column['jsonb'])) {
  1220.             return 'JSONB';
  1221.         }
  1223.         return 'JSON';
  1224.     }
  1226.     /**
  1227.      * @param mixed[] $column
  1228.      */
  1229.     private function isSerialColumn(array $column): bool
  1230.     {
  1231.         return isset($column['type'], $column['autoincrement'])
  1232.             && $column['autoincrement'] === true
  1233.             && $this->isNumericType($column['type']);
  1234.     }
  1236.     /**
  1237.      * Check whether the type of a column is changed in a way that invalidates the default value for the column
  1238.      */
  1239.     private function typeChangeBreaksDefaultValue(ColumnDiff $columnDiff): bool
  1240.     {
  1241.         if ($columnDiff->fromColumn === null) {
  1242.             return $columnDiff->hasChanged('type');
  1243.         }
  1245.         $oldTypeIsNumeric = $this->isNumericType($columnDiff->fromColumn->getType());
  1246.         $newTypeIsNumeric = $this->isNumericType($columnDiff->column->getType());
  1248.         // default should not be changed when switching between numeric types and the default comes from a sequence
  1249.         return $columnDiff->hasChanged('type')
  1250.             && ! ($oldTypeIsNumeric && $newTypeIsNumeric && $columnDiff->column->getAutoincrement());
  1251.     }
  1253.     private function isNumericType(Type $type): bool
  1254.     {
  1255.         return $type instanceof IntegerType || $type instanceof BigIntType;
  1256.     }
  1258.     private function getOldColumnComment(ColumnDiff $columnDiff): ?string
  1259.     {
  1260.         return $columnDiff->fromColumn !== null ? $this->getColumnComment($columnDiff->fromColumn) : null;
  1261.     }
  1263.     public function getListTableMetadataSQL(string $table, ?string $schema = null): string
  1264.     {
  1265.         if ($schema !== null) {
  1266.             $table = $schema . '.' . $table;
  1267.         }
  1269.         return sprintf(
  1270.             <<<'SQL'
  1271. SELECT obj_description(%s::regclass) AS table_comment;
  1272. SQL
  1273.             ,
  1274.             $this->quoteStringLiteral($table)
  1275.         );
  1276.     }
  1277. }