CREATE TABLE
CREATE TABLE — создать таблицу
Синтаксис
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] имя_таблицы ( [
{ имя_столбца тип_данных [ STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT } ] [ COMPRESSION метод_сжатия ] [ COLLATE правило_сортировки ] [ ограничение_столбца [ ... ] ]
| ограничение_таблицы
| LIKE таблица_источник [ параметр_LIKE ... ] }
[, ... ]
] )
[ INHERITS ( таблица_родитель [, ... ] ) ]
[ PARTITION BY { RANGE | LIST | HASH } ( { имя_столбца | ( выражение ) } [ COLLATE правило_сортировки ] [ класс_операторов ] [, ... ] ) ]
[ USING метод ]
[ WITH ( параметр_хранения [= значение] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE табл_пространство ]
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] имя_таблицы
OF имя_типа [ (
{ имя_столбца [ WITH OPTIONS ] [ ограничение_столбца [ ... ] ]
| ограничение_таблицы }
[, ... ]
) ]
[ PARTITION BY { RANGE | LIST | HASH } ( { имя_столбца | ( выражение ) } [ COLLATE правило_сортировки ] [ класс_операторов ] [, ... ] ) ]
[ USING метод ]
[ WITH ( параметр_хранения [= значение] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE табл_пространство ]
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] имя_таблицы
PARTITION OF таблица_родитель [ (
{ имя_столбца [ WITH OPTIONS ] [ ограничение_столбца [ ... ] ]
| ограничение_таблицы }
[, ... ]
) ] { FOR VALUES указание_границ_секции | DEFAULT }
[ PARTITION BY { RANGE | LIST | HASH } ( { имя_столбца | ( выражение ) } [ COLLATE правило_сортировки ] [ класс_операторов ] [, ... ] ) ]
[ USING метод ]
[ WITH ( параметр_хранения [= значение] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE табл_пространство ]
Здесь ограничение_столбца:
[ CONSTRAINT имя_ограничения ]
{ NOT NULL [ NO INHERIT ] |
NULL |
CHECK ( выражение ) [ NO INHERIT ] |
DEFAULT выражение_по_умолчанию |
GENERATED ALWAYS AS ( генерирующее_выражение ) [ STORED | VIRTUAL ] |
GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( параметры_последовательности ) ] |
UNIQUE [ NULLS [ NOT ] DISTINCT ] параметры_индекса |
PRIMARY KEY параметры_индекса |
REFERENCES целевая_таблица [ ( целевой_столбец ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
[ ON DELETE ссылочное_действие ] [ ON UPDATE ссылочное_действие ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] [ ENFORCED | NOT ENFORCED ]
и ограничение_таблицы:
[ CONSTRAINT имя_ограничения ]
{ CHECK ( выражение ) [ NO INHERIT ] |
NOT NULL имя_столбца [ NO INHERIT ] |
UNIQUE [ NULLS [ NOT ] DISTINCT ] ( имя_столбца [, ... ] [, имя_столбца WITHOUT OVERLAPS ] ) параметры_индекса |
PRIMARY KEY ( имя_столбца [, ... ] [, имя_столбца WITHOUT OVERLAPS ] ) параметры_индекса |
EXCLUDE [ USING индексный_метод ] ( элемент_исключения WITH оператор [, ... ] ) параметры_индекса [ WHERE ( предикат ) ] |
FOREIGN KEY ( имя_столбца [, ... ] [, PERIOD имя_столбца ] ) REFERENCES целевая_таблица [ ( целевой_столбец [, ... ] [, PERIOD целевой_столбец ] ) ]
[ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE ссылочное_действие ] [ ON UPDATE ссылочное_действие ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] [ ENFORCED | NOT ENFORCED ]
и параметр_LIKE:
{ INCLUDING | EXCLUDING } { COMMENTS | COMPRESSION | CONSTRAINTS | DEFAULTS | GENERATED | IDENTITY | INDEXES | STATISTICS | STORAGE | ALL }
и указание_границ_секции:
IN ( выражение_границ_секции [, ...] ) |
FROM ( { выражение_границ_секции | MINVALUE | MAXVALUE } [, ...] )
TO ( { выражение_границ_секции | MINVALUE | MAXVALUE } [, ...] ) |
WITH ( MODULUS числовая_константа, REMAINDER числовая_константа )
параметры_индекса в ограничениях UNIQUE, PRIMARY KEY и EXCLUDE:
[ INCLUDE ( имя_столбца [, ... ] ) ]
[ WITH ( параметр_хранения [= значение] [, ... ] ) ]
[ USING INDEX TABLESPACE табл_пространство ]
элемент_исключения в ограничении EXCLUDE:
{ имя_столбца | ( выражение ) } [ COLLATE правило_сортировки ] [ класс_операторов [ ( параметр_класса_оп = значение [, ... ] ) ] ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
ссылочное_действие в ограничении FOREIGN KEY/REFERENCES:
{ NO ACTION | RESTRICT | CASCADE | SET NULL [ ( имя_столбца [, ... ] ) ] | SET DEFAULT [ ( имя_столбца [, ... ] ) ] }Описание
CREATE TABLE создаёт новую, изначально пустую таблицу в текущей базе данных. Владельцем таблицы будет пользователь, выполнивший эту команду.
Если задано имя схемы (например, CREATE TABLE myschema.mytable ...), таблица создаётся в указанной схеме, в противном случае — в текущей. Временные таблицы существуют в специальной схеме, так что при создании таких таблиц имя схемы задать нельзя. Имя таблицы должно отличаться от имён других отношений (таблиц, последовательностей, индексов, представлений, материализованных представлений или сторонних таблиц) в этой схеме.
CREATE TABLE также автоматически создаёт составной тип данных, соответствующий одной строке таблицы. Таким образом, имя таблицы не может совпадать с именем существующего типа в этой же схеме.
Необязательные предложения ограничений задают ограничения (проверки), которым должны удовлетворять добавляемые или изменяемые строки, чтобы операция добавления или изменения была выполнена успешно. Ограничение представляет собой SQL-объект, помогающий некоторым способом определить множество допустимых значений в таблице.
Определить ограничения можно двумя способами: в виде ограничений таблицы и в виде ограничений столбца. Ограничение столбца определяется как часть определения столбца, а ограничение таблицы не привязывается к конкретному столбцу и может задействовать несколько столбцов. Любые ограничения столбцов можно также записать в виде ограничения таблицы, они введены просто для удобства записи в случаях, когда ограничение затрагивает только один столбец.
Чтобы создать таблицу, необходимо иметь право USAGE для типов всех столбцов или типа в предложении OF, соответственно.
Параметры
TEMPORARYилиTEMP#С таким указанием таблица создаётся как временная. Временные таблицы автоматически удаляются в конце сеанса или могут удаляться в конце текущей транзакции (см. описание
ON COMMITниже). В путь поиска по умолчанию первой включается временная схема, поэтому постоянная таблица с тем же именем не будет выбираться для новых планов запросов, пока существует временная (если имя задаётся без указания схемы). Все индексы, создаваемые для временной таблицы, автоматически также становятся временными.Демон автоочистки не может прочитать и, как следствие, сжимать и анализировать временные таблицы. По этой причине соответствующие операции очистки и анализа следует выполнять, вызывая SQL-команды в рамках сеанса. Например, если временную таблицу планируется использовать в сложных запросах, будет разумным выполнить для неё
ANALYZEпосле того, как она будет наполнена.По желанию можно добавить указание
GLOBALилиLOCALпередTEMPORARYилиTEMP. В настоящее время это не имеет значения для PostgreSQL и считается устаревшей возможностью; см. раздел Совместимость ниже.UNLOGGED#С этим указанием таблица создаётся как нежурналируемая. Данные, записываемые в нежурналируемые таблицы, не проходят через журнал предзаписи (см. Главу 28), в результате чего такие таблицы работают гораздо быстрее обычных. Однако они не защищены от сбоя; при сбое или аварийном отключении сервера нежурналируемая таблица автоматически усекается. Кроме того, содержимое нежурналируемой таблицы не реплицируется на ведомые серверы. Любые индексы, создаваемые для нежурналируемой таблицы, автоматически становятся нежурналируемыми.
С этим указанием все последовательности, создаваемые вместе с нежурналируемой таблицей (для столбцов идентификаторов или столбцов serial), также создаются нежурналируемыми.
Данная форма не поддерживается для секционированных таблиц.
IF NOT EXISTS#Не считать ошибкой, если отношение с таким именем уже существует. В этом случае будет выдано замечание. Заметьте, что нет никакой гарантии, что существующее отношение как-то соотносится с тем, которое могло бы быть создано.
имя_таблицы#Имя создаваемой таблицы (возможно, дополненное схемой).
OF#имя_типаСоздаёт типизированную таблицу, структура которой определяется независимым указанным составным типом (то есть созданным с помощью команды CREATE TYPE), при этом также создаётся новый составной тип. Таблица будет зависеть от типа, на который она ссылается, что означает, что каскадные операции
ALTERиDROPэтого типа будут распространяться и на таблицу.Типизированная таблица всегда имеет те же имена столбцов и типы данных, что и тип, из которого она получена, поэтому дополнительные столбцы указать нельзя. Но
CREATE TABLEможет добавить в таблицу значения по умолчанию и ограничения, а также задать параметры её хранения.имя_столбца#Имя столбца, создаваемого в новой таблице.
тип_данных#Тип данных столбца (может включать определение массива с этим типом). За дополнительными сведениями о типах данных, которые поддерживает PostgreSQL, обратитесь к Главе 8.
COLLATE#правило_сортировкиПредложение
COLLATEназначает правило сортировки для столбца (который должен иметь тип, поддерживающий сортировку). Если оно отсутствует, используется правило сортировки по умолчанию, установленное для типа данных столбца.-
STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT }# Эта форма устанавливает режим хранения столбца. Она определяет, хранятся ли данные внутри таблицы или в отдельной таблице TOAST и сжимаются ли они. Режим
PLAINдолжен применяться для значений фиксированной длины, таких какinteger; это вариант хранения внутри, без сжатия. РежимMAINприменяется для хранения внутри, но сжатых данных,EXTERNAL— для внешнего хранения несжатых данных, аEXTENDED— для внешнего хранения сжатых данных. С указаниемDEFAULTбудет использоваться режим по умолчанию для типа данных столбца.EXTENDEDиспользуется по умолчанию для большинства типов данных, поддерживающих хранилище неPLAIN. ПрименениеEXTERNALпозволяет ускорить операции с подстроками на очень больших значенияхtextиbytea, за счёт проигрыша в объёме хранилища. За дополнительными сведениями обратитесь к Разделу 66.2.COMPRESSION#метод_сжатияУказание
COMPRESSIONзадаёт метод сжатия для столбца. Сжатие поддерживается только для типов данных переменной длины и применяется только для столбцов с режимом храненияmainилиextended. (О режимах хранения столбцов рассказывается в ALTER TABLE.) Заданное для секционированной таблицы это свойство не оказывает прямого действия, так как такие таблицы сами по себе не содержат данные, но установленное значение будут наследовать её новые секции. Поддерживаются следующие методы сжатия:pglzиlz4. (lz4поддерживается, только если PostgreSQL был собран с ключом--with-lz4.) Кроме того,метод_сжатияможет принимать значениеdefault, явно выбирающее поведение по умолчанию — когда применяемый метод определяется значением default_toast_compression во время добавления данных.INHERITS (#таблица_родитель[, ... ] )Необязательное предложение
INHERITSопределяет список таблиц, от которых новая таблица будет автоматически наследовать все столбцы. Родительские таблицы могут быть обычными или сторонними таблицами.При использовании
INHERITSсоздаётся постоянная связь дочерней таблицы с родительскими. Изменения схемы в родительских таблицах обычно также отражаются в дочерних, и по умолчанию при чтении родительских таблиц в результат включаются данные дочерней таблицы.Когда в нескольких родительских таблицах оказываются столбцы с одним именем, происходит ошибка, за исключением случая, когда типы данных всех этих столбцов в таблицах совпадают. В этом случае одноимённые столбцы объединяются и формируют один столбец в новой таблице. Если имя столбца новой таблицы совпадает с именем одного из унаследованных столбцов, их типы так же должны совпадать, и в этом случае определения столбцов тоже сливаются в одну. Если в новой таблице явно указывается значение по умолчанию для нового столбца, это значение переопределяет любые значения по умолчанию, унаследованные этим столбцом. В противном случае, если значения по умолчанию определяются в разных родительских таблицах, эти определения должны совпадать, иначе произойдёт ошибка.
Ограничения
CHECKобъединяются вместе по сути так же, как и столбцы: если несколько родительских таблиц и/или определение новой таблицы содержат одноимённые ограниченияCHECK, этим ограничениям должны соответствовать одинаковые выражения проверки, в противном случае произойдёт ошибка. В случае совпадения выражения, эти ограничения с данным выражением объединяются в одно. При этом ограничения со свойствомNO INHERITв родительской таблице исключаются из рассмотрения. Заметьте, что безымянное ограничениеCHECKв новой таблице никогда не сливается с другими, так как для него всегда выбирается уникальное имя.Параметры
STORAGEдля столбца так же копируются из родительских таблиц.Если столбец в родительской таблице является столбцом идентификации, это свойство не наследуется. Если требуется, в дочерней таблице этот столбец можно объявить столбцом идентификации.
PARTITION BY { RANGE | LIST | HASH } ( {#имя_столбца| (выражение) } [класс_операторов] [, ...] )Необязательное предложение
PARTITION BYзадаёт стратегию секционирования таблицы. Таблица, созданная с этим указанием, называется секционируемой таблицей. Задаваемый в скобках список столбцов или выражений формирует ключ секционирования таблицы. Для секционирования по диапазонам или по хешу ключ секционирования может включать несколько столбцов или выражений (до 32, но этот предел можно изменить при сборке PostgreSQL), но для секционирования по спискам ключ должен состоять из одного столбца или выражения.Для секционирования по диапазонам и по спискам нужен класс операторов B-дерева, тогда как для секционирования по хешу требуется класс операторов хеширования. Если класс операторов не задан явно, будет применён класс операторов по умолчанию для соответствующего типа; в случае отсутствия такого класса выдаётся ошибка. Для секционирования по хешу применяемый класс операторов должен реализовывать опорную функцию 2 (см. Подраздел 36.16.3).
Секционируемая таблица разделяется на подтаблицы (называемые секциями), которые создаются отдельными командами
CREATE TABLE. Сама по себе секционируемая таблица не содержит данных. Строка данных, вставляемая в эту таблицу, перенаправляется в секцию в зависимости от значений столбцов или выражений в ключе секционирования. Если значениям в новой строке не соответствует ни одна из существующих секций, возникает ошибка.Узнать больше о секционировании таблиц можно в Разделе 5.12.
PARTITION OF#таблица_родитель{ FOR VALUESуказание_границ_секции| DEFAULT }Создаёт таблицу в виде секции указанной родительской таблицы. Таблицу можно создать либо как секцию для определённых значений (используя
FOR VALUES), либо как секцию по умолчанию (используяDEFAULT). Это указание неприемлемо для таблиц, секционируемых по хешу. В создаваемую секцию копируются все индексы, ограничения и пользовательские триггеры уровня строк.Здесь
указание_границ_секциидолжно соответствовать методу и ключу секционирования родительской таблицы и не должно конфликтовать с любой существующей секцией того же родителя. Вариант указания сINиспользуется для секционирования по спискам, тогда как вариант сFROMиTOдля секционирования по диапазонам, а сWITH— для секционирования по хешу.выражение_границ_секции— любое выражение без переменных (подзапросы, оконные, агрегатные и возвращающие множества функции в нём не допускаются). Его тип данных должен подходить для соответствующего столбца в ключе секционирования. Это выражение вычисляется единожды во время создания таблицы, поэтому в нём могут вызываться даже изменчивые функции, например.CURRENT_TIMESTAMPПри создании секции с секционированием по спискам возможно указать, что столбец ключа секционирования может содержать NULL, включив в список секции
NULL. Однако у отдельно взятой родительской таблицы может быть не больше одной такой секции. Для диапазонных секцийNULLзадать нельзя.При создании диапазонной секции нижняя граница, задаваемая во
FROM, включается в диапазон, а верхняя граница, задаваемая вTO— исключается. То есть, значения, задаваемые в спискеFROM, являются допустимыми значениями соответствующих столбцов ключа секционирования для этой секции, а значения в спискеTO— нет. Заметьте, что это утверждение должно восприниматься с учётом правил сравнения строк таблицы (см. Подраздел 9.25.5). Например, с секционированиемPARTITION BY RANGE (x,y), секция с границамиFROM (1, 2) TO (3, 4)приметx=1с любым значениемy>=2,x=2с любымy, отличным от NULL, иx=3с любымy<4.Специальные значения
MINVALUEиMAXVALUEмогут использоваться при создании диапазонной секции для указания, что нижняя или верхняя граница для значений столбца отсутствует. Например, секция, определённая с указаниемFROM (MINVALUE) TO (10), будет принимать любые значения меньше 10, а секция, определённая с указаниемFROM (10) TO (MAXVALUE), — любые значения, которые больше или равны 10.При создании диапазонной секции с более чем одним столбцом может также иметь смысл использовать
MAXVALUEв определении нижней границы, аMINVALUE— верхней. Например, секция, определённая с указаниемFROM (0, MAXVALUE) TO (10, MAXVALUE), будет принимать любые строки, в которых первый столбец ключа секционирования больше 0 и меньше или равен 10. Подобным образом, секция, определённая с указаниемFROM ('a', MINVALUE) TO ('b', MINVALUE), будет принимать строки, в которых первый столбец ключа секционирования начинается с «a».Заметьте, что если для одного столбца в границе секции задаётся
MINVALUEилиMAXVALUE, то же значение должно применяться и для всех последующих столбцов. Например, граница(10, MINVALUE, 0)будет некорректной; допустимая граница:(10, MINVALUE, MINVALUE).Также заметьте, что для некоторых типов элементов, таких как
timestamp, наряду с другими значениями допускается значение "infinity" (бесконечность). Оно отличается от вариантовMINVALUEиMAXVALUE, которые на самом деле не обозначают значения, которые можно сохранить, а просто говорят о том, это значение не ограничено.MAXVALUEможно воспринимать как значение, которое больше любого другого, включая "бесконечность", аMINVALUEменьше любого другого значения, включая "минус бесконечность". Таким образом, диапазонFROM ('infinity') TO (MAXVALUE)не будет пустым, а будет принимать ровно одно значение — «infinity».С указанием
DEFAULTтаблица присоединяется к родительской таблице как секция по умолчанию. Для таблиц, секционируемых по хешу, это указание не поддерживается. Ключ секционирования, не попадающий ни в одну из секций данного родителя, будет отправлен в секцию по умолчанию.Когда у таблицы есть секция по умолчанию (
DEFAULT) и к ней добавляется новая секция, требуется просканировать секцию по умолчанию и убедиться в том, что она не содержит строки, которые должны относиться к новой секции. Если она содержит большое количество строк, это сканирование может быть длительным. Сканирование не будет выполняться, если секция по умолчанию является сторонней таблицей или в ней есть ограничение, гарантирующее отсутствие в этой секции строк, подлежащих перемещению в новую секцию.При создании секции с секционированием по хешу должен задаваться модуль и остаток. Модулем должно быть положительное число, а остатком неотрицательное число, меньшее модуля. Обычно при начальной настройке таблицы с секционированием по хешу нужно выбрать модуль, равный количеству секций, и назначить каждой секции этот модуль и разные остатки (см. примеры ниже). Однако секциям можно назначить и разные модули, с условием, что модули, назначенные секциям таблицы, секционируемой по хешу, являются делителями следующих больших модулей. Это позволяет постепенно увеличивать число секций, не производя полное перемещение всех данных. Например, предположим, что у вас есть таблица, секционируемая по хешу на 8 секций, для каждой из которых назначен модуль 8, и возникла необходимость увеличить число секций до 16. Вы можете отсоединить одну из секций по модулю 8, создать две новые секции по модулю 16, покрывающих ту же часть пространства ключа (одну с остатком, равным остатку отсоединённой секции, а вторую с остатком, равным тому же остатку плюс 8), и вновь наполнить их данными. Вы можете повторять эту операцию (возможно, позже) для остальных секций по модулю 8, пока все они не будут заменены. Хотя и при таком подходе может потребоваться перемещать большие объёмы данных на каждом этапе, это всё же лучше, чем создавать абсолютно новую таблицу и перемещать все данные сразу.
В секции должны содержаться столбцы с теми же именами и типами, что и в секционированной таблице, к которой она относится. Изменение имён и типов столбцов в секционируемой таблице будет автоматически распространяться во все секции. Ограничения
CHECKбудут наследоваться автоматически всеми секциями, но для отдельных секций могут быть заданы дополнительные ограниченияCHECK; дополнительные ограничения с теми же именами и условиями, как в родительской таблице, будут объединены с родительским ограничением. Также независимо для каждой секции могут быть заданы значения по умолчанию. Но заметьте, что значение по умолчанию, заданное на уровне секции, не будет действовать при добавлении строк через секционированную таблицу.Строки, добавляемые в секционированную таблицу, будут автоматически перенаправляться в соответствующую секцию. Если подходящей секции не найдётся, произойдёт ошибка.
Такие операции, как
TRUNCATE, обычно затрагивают и саму таблицу, и каскадно распространяются на все дочерние секции, но могут также выполняться в отдельных секциях.Обратите внимание, что для создания секции с использованием
PARTITION OFтребуется применение блокировкиACCESS EXCLUSIVEдля родительской секционированной таблицы. Аналогично для удаления секции с помощьюDROP TABLEтребуется установить блокировкуACCESS EXCLUSIVEв родительской таблице. Для выполнения этих операций с менее строгой блокировкой можно использовать командуALTER TABLE ATTACH/DETACH PARTITION, тем самым снизив влияние на параллельные операции с секционированной таблицей.LIKE#таблица_источник[параметр_LIKE... ]Предложение
LIKEопределяет таблицу, из которой в новую таблицу будут автоматически скопированы все имена столбцов, их типы данных и их ограничения на NULL.В отличие от
INHERITS, новая и исходная таблица становятся полностью независимыми после завершения создания. Изменения в исходной таблице не отражаются в новой, а данные новой таблицы не включаются в результат чтения исходной.Кроме того, в отличие от
INHERITS, столбцы и ограничения, копируемые командойLIKE, не объединяются с одноимёнными столбцами и ограничениями. Если дублирующееся имя указывается явно или возникает в другом предложенииLIKE, происходит ошибка.Необязательные предложения
параметр_LIKEуказывают, какие дополнительные свойства исходной таблицы будут копироваться. УказаниеINCLUDINGкопирует заданное свойство, аEXCLUDINGисключает его. По умолчанию подразумеваетсяEXCLUDING. Если к одному типу объекта относятся несколько указаний, будет применяться последнее. Допустимые указания:INCLUDING COMMENTS#Копировать комментарии для скопированных столбцов, ограничений-проверок, ограничений NOT NULL, индексов и расширенной статистики. По умолчанию комментарии не копируются, вследствие чего соответствующие объекты в новой таблице оказываются без комментариев.
INCLUDING COMPRESSION#Копировать метод сжатия для столбцов. По умолчанию указания метода сжатия не копируются, вследствие чего для новых столбцов выбирается метод сжатия по умолчанию.
INCLUDING CONSTRAINTS#Копировать ограничения-проверки (
CHECK). В данном контексте ограничения на уровне столбцов и на уровне таблицы не различаются. Ограничения NOT NULL копируются в новую таблицу всегда.INCLUDING DEFAULTS#Копировать выражения значений по умолчанию в определениях копируемых столбцов. Без этого указания выражения по умолчанию не копируются, вследствие чего в новой таблице скопированные столбцы получают значения по умолчанию NULL. Заметьте, что при копировании подобных выражений, в которых вызываются функции, модифицирующие БД, например
nextval, может образовываться функциональная связь исходной таблицы с новой.INCLUDING GENERATED#Копировать выбор значения
STOREDилиVIRTUAL, а также выражения, генерирующие значения для копируемых столбцов. По умолчанию все новые столбцы будут обычными базовыми столбцами.INCLUDING IDENTITY#Копировать характеристики идентификации в определениях копируемых столбцов. Для каждого столбца идентификации в новой таблице создаётся новая последовательность, не зависящая от последовательностей, связанных со старой таблицей.
INCLUDING INDEXES#Создавать в новой таблице индексы, ограничения
PRIMARY KEY,UNIQUEиEXCLUDE, существующие в исходной таблице. Имена для новых индексов и ограничений выбираются согласно стандартным правилам, независимо от того, как назывались исходные. (Это позволяет избежать потенциальных конфликтов с именами новых индексов.)INCLUDING STATISTICS#Копировать в новую таблицу расширенную статистику.
INCLUDING STORAGE#Копировать параметры
STORAGEв определениях копируемых столбцов. По умолчанию параметрыSTORAGEисключаются, вследствие чего скопированные столбцы в новой таблице получают параметры по умолчанию, определённые соответствующим типом. Подробнее параметрыSTORAGEописаны в Разделе 66.2.INCLUDING ALL#Указание
INCLUDING ALLявляется сокращённым вариантом выбора всех имеющихся отдельных параметров. (ПослеINCLUDING ALLможно дополнительно добавить предложенияEXCLUDING, чтобы выбрать все параметры, за исключением некоторых.)
Предложение
LIKEможет также применяться для копирования определений столбцов из представлений, сторонних таблиц и составных типов. Неприменимые параметры (например,INCLUDING INDEXESдля представления) при этом игнорируются.CONSTRAINT#имя_ограниченияНеобязательное имя столбца или ограничения таблицы. При нарушении ограничения его имя будет выводиться в сообщении об ошибках, так что имена ограничений вида
столбец должен быть положительныммогут сообщить полезную информацию об ограничении клиентскому приложению. (Имена ограничений, включающие пробелы, необходимо заключать в двойные кавычки.) Если имя ограничения не указано, система генерирует имя автоматически.NOT NULL [ NO INHERIT ]#Данный столбец не принимает значения NULL.
Ограничение с пометкой
NO INHERITне будет наследоваться дочерними таблицами.NULL#Данный столбец может содержать значения NULL (по умолчанию).
Это предложение предназначено только для совместимости с нестандартными базами данных SQL. Использовать его в новых приложениях не рекомендуется.
CHECK (#выражение) [ NO INHERIT ]В ограничении
CHECKзадаётся выражение, возвращающее логический результат, по которому определяется, будет ли успешна операция добавления или изменения для конкретных строк. Операция выполняется успешно, если результат выражения равен TRUE или UNKNOWN. Если же для какой-нибудь строки, задействованной в операции добавления или изменения, будет получен результат FALSE, возникает ошибка, и эта операция не меняет ничего в базе данных. Ограничение-проверка, заданное как ограничение столбца, должно ссылаться только на значение самого столбца, тогда как ограничение на уровне таблицы может ссылаться и на несколько столбцов.В настоящее время выражения
CHECKне могут содержать подзапросы или ссылаться на какие-либо переменные, кроме как на столбцы текущей строки (см. Подраздел 5.5.1). Также допустима ссылка на системный столбецtableoid, но не на другие системные столбцы.Ограничение с пометкой
NO INHERITне будет наследоваться дочерними таблицами.Когда для таблицы задано несколько ограничений
CHECK, они будут проверяться для каждой строки в алфавитном порядке имён после проверки ограниченийNOT NULL. (До версии 9.5 в PostgreSQL не было установлено никакого определённого порядка обработки ограниченийCHECK.)DEFAULT#выражение_по_умолчаниюПредложение
DEFAULTзадаёт значение по умолчанию для столбца, в определении которого оно присутствует. Значение задаётся выражением без переменных (в частности, перекрёстные ссылки на другие столбцы текущей таблицы в нём не допускаются). Также не допускаются подзапросы. Тип данных выражения, задающего значение по умолчанию, должен соответствовать типу данных столбца.Это выражение будет использоваться во всех операциях добавления данных, в которых не задаётся значение данного столбца. Если значение по умолчанию не определено, таким значением будет NULL.
GENERATED ALWAYS AS (#генерирующее_выражение) [ STORED | VIRTUAL ]Это предложение создаёт столбец как генерируемый. В такой столбец нельзя записать данные, а при чтении его возвращается результат указанного выражения.
Если указано ключевое слово
VIRTUAL, столбец вычисляется при чтении и не занимает места в хранилище. Если указаноSTORED, столбец вычисляется при записи и сохраняется на диске. По умолчанию указаноVIRTUAL.Генерирующее выражение может обращаться к другим столбцам таблицы, но не к другим генерируемым столбцам. Все функции и операторы в нём должны быть постоянными. Обращаться к другим таблицам в таких выражениях нельзя.
Виртуальный генерируемый столбец не может иметь пользовательский тип, а его генерирующее выражение не должно ссылаться на пользовательские функции или типы, то есть должно использовать только встроенные функции и типы. Это ограничение действует и косвенным образом, например, для функций или типов, лежащих в основе операторов или приведений. (Это ограничение не распространяется на хранимые генерируемые столбцы.)
GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ (#параметры_последовательности) ]С этим предложением столбец создаётся как столбец идентификации. С ним будет связана неявная последовательность, из которой этот столбец будет автоматически получать значения для новых строк. Такому столбцу неявно назначается свойство
NOT NULL.Предложения
ALWAYSиBY DEFAULTопределяют, как явно заданные пользователем значения будут обрабатываться командамиINSERTиUPDATE.В команде
INSERT, в случае выбораALWAYS, пользовательское значение используется, только если в этой команде указаноOVERRIDING SYSTEM VALUE. С предложениемBY DEFAULTпользовательскому значению отдаётся предпочтение. За подробностями обратитесь к описанию INSERT. (В командеCOPYпользовательские значения используются всегда, вне зависимости от выбранного здесь варианта.)В команде
UPDATE, в случае выбораALWAYS, попытка поместить в столбец любое значение, отличное отDEFAULT, будет отвергнута. Если выбран вариантBY DEFAULT, столбец может быть изменён обычным образом. (ПредложениеOVERRIDINGдля командыUPDATEотсутствует.)Используя необязательное предложение
параметры_последовательности, можно переопределить свойства последовательности. Среди доступных параметров: параметры для CREATE SEQUENCE, а такжеSEQUENCE NAME,имяLOGGEDиUNLOGGED. Они позволяют выбрать имя и режим журналирования для последовательности. БезSEQUENCE NAMEсистема проставит последовательности ещё не использованное имя. БезLOGGEDилиUNLOGGEDу последовательности будет тот же уровень журналирования, что и у таблицы.UNIQUE [ NULLS [ NOT ] DISTINCT ](ограничение столбца)UNIQUE [ NULLS [ NOT ] DISTINCT ] ([имя_столбца[, ... ] [,имя_столбцаWITHOUT OVERLAPS ] )INCLUDE (] (ограничение таблицы) #имя_столбца[, ...])Ограничение
UNIQUEопределяет, что группа из одного или нескольких столбцов таблицы может содержать только уникальные значения. Ограничение уникальности для таблицы ведёт себя точно так же, как ограничение для столбца, но может охватывать несколько столбцов. Таким образом, ограничение уникальности гарантирует, что любые две строки таблицы различаются как минимум в этих столбцах.Если для последнего столбца указан параметр
WITHOUT OVERLAPS, то для этого столбца проверяются не равенства, а пересечения. В этом случае остальные столбцы ограничения допускают дубликаты, если дубликаты не пересекаются в столбце сWITHOUT OVERLAPS. (Такое ограничение иногда называют темпоральным ключом, если столбец представляет собой диапазон дат или меток времени, однако PostgreSQL позволяет использовать диапазоны с любыми базовыми типами.) Фактически такое ограничение устанавливается с помощью ограниченияEXCLUDE, а неUNIQUE. Например,UNIQUE (id, valid_at WITHOUT OVERLAPS)ведёт себя какEXCLUDE USING GIST (id WITH =, valid_at WITH &&). У столбца сWITHOUT OVERLAPSдолжен быть диапазонный или мультидиапазонный тип. Пустые диапазоны или мультидиапазоны не допускаются. Остальные столбцы ограничения (безWITHOUT OVERLAPS) могут иметь любой тип, поддерживающий проверку на равенство в индексе GiST. По умолчанию поддерживаются только диапазонные типы, но с помощью расширения btree_gist можно использовать и другие типы (рекомендуемый способ применения этой функции).При проверке ограничения уникальности значения NULL не считаются равными, если не указан параметр
NULLS NOT DISTINCT.В каждом ограничении уникальности должен задаваться набор столбцов, отличный от набора любого другого ограничения уникальности или первичного ключа в данной таблице. (Избыточные ограничения уникальности будут просто игнорироваться.)
При установлении ограничения уникальности в многоуровневой иерархии секционирования в определение ограничения должны включаться все столбцы ключа секционирования целевой секционированной таблицы, а также столбцы всех подчинённых секционированных таблиц.
При добавлении ограничения уникальности автоматически будет создан уникальный индекс-B-дерево по столбцу или группе столбцов, перечисленных в ограничении. Но если ограничение содержит предложение
WITHOUT OVERLAPS, будет использоваться индекс GIST. Созданный индекс наследует имя ограничения уникальности.Необязательное предложение
INCLUDEдобавляет к этому индексу один или несколько столбцов, составляющих просто «дополнительную нагрузку»: для них уникальность не будет требоваться, и искать значения в них по данному индексу нельзя. Однако их содержимое может быть получено при сканировании только индекса. Заметьте, что хотя ограничение по неключевым столбцам не контролируется, оно всё же зависит от них. Как следствие, некоторые операции с этими столбцами (например,DROP COLUMN) могут повлечь каскадное удаление индекса и ограничения.PRIMARY KEY(ограничение столбца)PRIMARY KEY ([имя_столбца[, ... ] [,имя_столбцаWITHOUT OVERLAPS ] )INCLUDE (] (ограничение таблицы) #имя_столбца[, ...])Ограничение
PRIMARY KEYопределяет, что столбец или столбцы таблицы могут содержать только уникальные (без повторений) значения, отличные от NULL. Для таблицы может быть задан только один первичный ключ, будь то ограничение столбца или ограничение таблицы.В определении первичного ключа должен задаваться набор столбцов, отличный от набора любого другого ограничения уникальности, установленного для данной таблицы. (В противном случае уникальное ограничение оказывается избыточным и будет отброшено.)
PRIMARY KEYустанавливает для данных те же ограничения, что и сочетаниеUNIQUEиNOT NULL, но созданный по набору столбцов первичный ключ также даёт метаинформацию о конструкции схемы, так как он подразумевает, что другие таблицы могут ссылаться на этот набор столбцов как на уникальный идентификатор строк.Определяемые для секционированной таблицы ограничения
PRIMARY KEYподчиняются тем же требованиям, что и ограниченияUNIQUE.При добавлении ограничения
PRIMARY KEYавтоматически будет создан уникальный индекс-B-дерево по столбцу или группе столбцов, перечисленных в ограничении, или индекс GIST, если указано значениеWITHOUT OVERLAPS.Необязательное предложение
INCLUDEдобавляет к этому индексу один или несколько столбцов, составляющих просто «дополнительную нагрузку»: для них уникальность не будет требоваться, и искать значения в них по данному индексу нельзя. Однако их содержимое может быть получено при сканировании только индекса. Заметьте, что хотя ограничение по неключевым столбцам не контролируется, оно всё же зависит от них. Как следствие, некоторые операции с этими столбцами (например,DROP COLUMN) могут повлечь каскадное удаление индекса и ограничения.EXCLUDE [ USING#индексный_метод] (элемент_исключенияWITHоператор[, ... ] )параметры_индекса[ WHERE (предикат) ]Предложение
EXCLUDEопределяет ограничение-исключение, которое гарантирует, что для любых двух строк, сравниваемых по указанным столбцам или выражениям с указанными операторами, результат не будет равенTRUEдля всех сравнений. Если все указанные операторы проверяют равенство, это ограничение равносильно ограничениюUNIQUE, хотя обычное ограничение уникальности будет работать быстрее. С другой стороны, в ограничениях-исключениях можно задавать более общие условия, чем простое условие на равенство. Например, можно задать ограничение, требующее, чтобы никакие две строки в таблице не содержали пересекающихся кругов (см. Раздел 8.8), применив оператор&&. Кроме того, операторы должны быть коммутативными.Ограничения-исключения реализуются с помощью одноимённых индексов, так что каждый указанный в них оператор должен быть связан с соответствующим классом операторов (см. Раздел 11.10) для
индексного_метода. В каждомэлементе_исключенияуказывается столбец индекса, чтобы можно было дополнительно указать правило сортировки, класс оператора, параметры класса оператора и/или параметры сортировки, подробно описанные в CREATE INDEX.Индексный метод доступа должен поддерживать
amgettuple(см. Главу 63); в настоящее время это означает, что индексы GIN для этого не подходят. Хотя в ограничении-исключении можно использовать B-деревья и хеш-индексы, в этом мало смысла, так как такой подход ничем не лучше обычного ограничения уникальности. Так что на практике методом доступа всегда будет GiST или SP-GiST.Параметр
предикатпозволяет указать ограничение-исключение для подмножества таблицы; внутри при этом создаётся частичный индекс. Заметьте, что предикат необходимо заключить в скобки.При установлении ограничения исключения в многоуровневой иерархии секционирования в определение ограничения должны включаться все столбцы ключа секционирования целевой секционированной таблицы, а также столбцы всех подчинённых секционированных таблиц. Кроме того, эти столбцы должны сравниваться через оператор равенства. Данные ограничения обеспечивают существование в одной секции потенциально конфликтующих строк. Ограничение может также относиться к другим столбцам, не являющихся частью ключа секционирования, которые можно сравнить с помощью любого подходящего оператора.
REFERENCES(ограничение столбца)внешняя_таблица[ (внешний_столбец) ] [ MATCHтип_совпадения] [ ON DELETEссылочное_действие] [ ON UPDATEссылочное_действие]FOREIGN KEY ((ограничение таблицы) #имя_столбца[, ... ] [, PERIODимя_столбца] ) REFERENCESвнешняя_таблица[ (внешний_столбец[, ... ] [, PERIODвнешний_столбец] ) ] [ MATCHтип_совпадения] [ ON DELETEссылочное_действие] [ ON UPDATEссылочное_действие]Эти предложения определяют ограничение внешнего ключа, требующее, чтобы группа из одного или нескольких столбцов новой таблицы содержала только такие значения, которым соответствуют значения в заданных столбцах некоторой строки во внешней таблице. Если список
целевых_столбцовопущен, в качестве него используется первичный ключцелевой_таблицы. Если же он задан, в качестве целевых столбцов должны указываться столбцы неоткладываемого уникального ограничения или первичного ключа во внешней таблице, либо столбцы нечастичного уникального индекса.Если у последнего столбца есть пометка
PERIOD, он обрабатывается особым образом. В то время как столбцы без такой пометки сравниваются на равенство (при этом должен быть хотя бы один такой столбец), столбец сPERIODне сравнивается. Вместо этого ограничение считается выполненным, если в целевой таблице есть совпадающие записи (основанные на столбцах ключа безPERIOD), чьи объединённые значенияPERIODполностью покрывают значениеPERIODссылающейся записи. Другими словами, у ссылки должен быть объект, на который она ссылается, на протяжении всего временного интервала. У этого столбца должен быть диапазонный или мультидиапазонный тип. Кроме того, в целевой таблице должно быть объявлено ограничение первичного ключа или ограничение уникальности с указаниемWITHOUT OVERLAPS. Наконец, если у внешнего ключа указаноPERIODимя_столбца, соответствующийцелевой_столбец, если он присутствует, также должен быть помечен какPERIOD. Если предложениецелевой_столбецопущено, и поэтому выбирается ограничение первичного ключа целевой таблицы, то у последнего столбца первичного ключа должна быть пометкаWITHOUT OVERLAPS.Если у пары ссылающегося и целевого столбцов сортируемый тип данных, правила сортировки должны быть либо детерминированными, либо одинаковыми для обоих столбцов. Это гарантирует, что у обоих столбцов согласованное определение равенства.
Пользователь должен иметь право
REFERENCESво внешней таблице (либо для всей таблицы, либо только для целевых столбцов). Для добавления ограничения внешнего ключа требуется блокировкаSHARE ROW EXCLUSIVEв целевой таблице. Обратите внимание, что нельзя определить ограничения внешнего ключа, связывающие временные и постоянные таблицы.Значения, вставляемые в ссылающиеся столбцы, сверяются со значениями во внешних столбцах внешней таблицы с учётом заданного типа совпадения. Возможны три типа совпадения:
MATCH FULL(полное совпадение),MATCH PARTIAL(частичное совпадение) и тип по умолчанию,MATCH SIMPLE(простое совпадение). СMATCH FULLни один из столбцов составного внешнего ключа не может содержать NULL, кроме случая, когда все внешние столбцы NULL; в этом случае строка может не иметь соответствия во внешней таблице. СMATCH SIMPLEлюбой из столбцов внешнего ключа может содержать NULL; при этом строка с NULL в одном из таких столбцов может не иметь соответствия во внешней таблице. ТипMATCH PARTIALещё не реализован. (Разумеется, чтобы вопросы со сравнением NULL не возникали, к столбцам, ссылающимся на внешние, можно применить ограниченияNOT NULL.)Кроме того, при изменении значений во внешних столбцах с данными в столбцах этой таблицы могут производиться определённые действия. Предложение
ON DELETEзадаёт действие, производимое при удалении некоторой строки во внешней таблице. ПредложениеON UPDATEподобным образом задаёт действие, производимое при изменении значения в целевых столбцах внешней таблицы. Если строка изменена, но это изменение не затронуло целевые столбцы, никакое действие не производится. Ссылочные действия выполняются в рамках команды изменения данных даже при отложенном ограничении. Для каждого предложения возможные следующие варианты действий:NO ACTION#Выдать ошибку, если при удалении или изменении записи произойдёт нарушение ограничения внешнего ключа. Для отложенных ограничений ошибка произойдёт в момент проверки ограничения, если строки, ссылающиеся на эту запись, по-прежнему будут существовать. Этот вариант действия подразумевается по умолчанию.
RESTRICT#Выдать ошибку, если удаляемая или изменяемая строка совпадает со строкой в ссылающейся таблице. Это предотвращает выполнение операции, даже если состояние после выполнения не нарушало бы ограничение внешнего ключа. В частности, предотвращается изменение целевых строк до значений, которые различны, но сравниваются как равные. Однако это не предотвращает бесполезные изменения, когда столбцу задаётся то же самое значение.
Этот параметр не поддерживается для темпоральных внешних ключей.
CASCADE#Удалить все строки, ссылающиеся на удаляемую запись, либо поменять значения в ссылающихся столбцах на новые значения во внешних столбцах, в соответствии с операцией.
Этот параметр не поддерживается для темпоральных внешних ключей.
SET NULL [ (#имя_столбца[, ... ] ) ]Установить во всех ссылающихся столбцах или в указанном подмножестве ссылающихся столбцов значения null. Подмножество столбцов можно указать только для действий
ON DELETE.Этот параметр не поддерживается для темпоральных внешних ключей.
SET DEFAULT [ (#имя_столбца[, ... ] ) ]Установить во всех ссылающихся столбцах или в указанном подмножестве ссылающихся столбцов значения по умолчанию. Подмножество столбцов можно указать только для действий
ON DELETE. (Если значения по умолчанию отличны от NULL, во внешней таблице должна быть строка, соответствующая набору этих значений; в противном случае операция завершится ошибкой.)Этот параметр не поддерживается для темпоральных внешних ключей.
Если внешние столбцы меняются часто, будет разумным добавить индекс для ссылающихся столбцов, чтобы действия по обеспечению ссылочной целостности, связанные с ограничением внешнего ключа, выполнялись более эффективно.
DEFERRABLENOT DEFERRABLE#Это предложение определяет, может ли ограничение быть отложенным. Неоткладываемое ограничение будет проверяться немедленно после каждой команды. Проверка откладываемых ограничений может быть отложена до завершения транзакции (обычно с помощью команды
SET CONSTRAINTS). По умолчанию подразумевается вариантNOT DEFERRABLE. В настоящее время это предложение принимают только ограниченияUNIQUE,PRIMARY KEY,EXCLUDEиREFERENCES(внешний ключ). ОграниченияNOT NULLиCHECKне могут быть отложенными. Заметьте, что откладываемые ограничения не могут применяться в качестве решающих при конфликте в оператореINSERTс предложениемON CONFLICT.INITIALLY IMMEDIATEINITIALLY DEFERRED#Для откладываемых ограничений это предложение определяет, когда ограничение должно проверяться по умолчанию. Ограничение с характеристикой
INITIALLY IMMEDIATE(подразумеваемой по умолчанию) проверяется после каждого оператора. ОграничениеINITIALLY DEFERRED, напротив, проверяется только в конце транзакции. Время проверки ограничения можно изменить явно с помощью командыSET CONSTRAINTS.ENFORCEDNOT ENFORCED#Если для ограничения задана характеристика
ENFORCED, СУБД обеспечивает его выполнение, проверяя ограничение в соответствующий момент (после каждого оператора или в конце транзакции в зависимости от ситуации). Это значение по умолчанию. Ограничение с характеристикойNOT ENFORCEDСУБД не проверяет. В этом случае соблюдение ограничения возлагается на код приложения. При этом СУБД может по-прежнему предполагать, что данные фактически удовлетворяют ограничению для целей оптимизации в тех случаях, когда это не влияет на корректность результата.Ограничения
NOT ENFORCEDмогут быть полезны в качестве документации, если фактическая проверка ограничения во время выполнения слишком затратна.В настоящее время это поддерживается только для ограничений внешнего ключа и ограничений
CHECK.USING#методЭто дополнительное предложение задаёт табличный метод доступа, который будет использоваться для сохранения содержимого новой таблицы; типом этого метода доступа должен быть
TABLE. Подробнее об этом рассказывается в Главе 62. В случае отсутствия этого указания для новой таблицы выбирается метод доступа по умолчанию. За подробностями обратитесь к default_table_access_method.При создании секции табличный метод доступа наследуется от секционированной таблицы, если он был задан.
WITH (#параметр_хранения[=значение] [, ... ] )Это предложение определяет дополнительные параметры хранения для таблицы или индекса; за подробностями обратитесь к разделу Параметры хранения ниже. В целях обратной совместимости предложение
WITHдля таблицы также может содержать указаниеOIDS=FALSE, отмечающее, что строки новой таблицы не должны содержать OID (идентификатор объекта); указаниеOIDS=TRUEболее не поддерживаетсяWITHOUT OIDS#Обеспечивающий обратную совместимость синтаксис создания таблицы с характеристикой
WITHOUT OIDS; создание таблицы с указаниемWITH OIDSболее не поддерживается.ON COMMIT#Поведением временных таблиц в конце блока транзакции позволяет управлять предложение
ON COMMIT, которое принимает три параметра:PRESERVE ROWS#Никакое специальное действие в конце транзакции не выполняется. Это поведение по умолчанию.
DELETE ROWS#Все строки в этой временной таблице будут удаляться в конце каждого блока транзакции. По сути, при каждой фиксации транзакции будет автоматически выполняться
TRUNCATE. В случае секционированной таблицы это действие не распространяется на её секции.DROP#Временная таблица будет удалена в конце текущего блока транзакции. Если это секционированная таблица, будут удалены и все её секции. Если у таблицы есть потомки в иерархии наследования, они также будут удалены.
TABLESPACE#табл_пространствоЗдесь
табл_пространство— имя табличного пространства, в котором будет создаваться новая таблица. Если оно не указано, выбирается default_tablespace для обычных или temp_tablespaces для временных таблиц. Если же этот параметр задаётся для секционируемой таблицы, то ввиду того, что ей самой табличное пространство не требуется, заданное имя переопределяет значениеdefault_tablespace(табличное пространство по умолчанию), которое применяется для всех создаваемых секций в случае отсутствия явного указания.USING INDEX TABLESPACE#табл_пространствоЭто предложение позволяет выбрать табличное пространство, в котором будут создаваться индексы, связанные с ограничениями
UNIQUE,PRIMARY KEYилиEXCLUDE. Если оно не указано, выбирается default_tablespace или temp_tablespaces, если таблица временная.
Параметры хранения
Предложение WITH позволяет установить параметры хранения для таблиц и индексов, связанных с ограничениями UNIQUE, PRIMARY KEY и EXCLUDE. Параметры хранения для индексов документированы в CREATE INDEX. Поддерживаемые в настоящее время параметры хранения для таблиц перечислены ниже. Как показано, для многих параметров существует дополнительный параметр с тем же именем и префиксом toast., который управляет поведением вторичной таблицы TOAST, если она есть (за дополнительными сведениями о TOAST обратитесь к Разделу 66.2). Если значение некоторого параметра задано для таблицы, а значение равнозначного параметра toast. не определено, для таблицы TOAST будет применяться значение параметра основной таблицы. Возможность задания этих параметров для секционированных таблиц не поддерживается, но вы можете задать их для отдельных конечных секций.
fillfactor(integer) #Фактор заполнения для таблицы, задаваемый в процентах, от 10 до 100. Значение по умолчанию — 100 (плотное заполнение). При меньшем факторе заполнения операции
INSERTупаковывают данные в страницы только до заданного процента; оставшееся место резервируется для изменения строк на этой странице. В результатеUPDATEполучает шанс поместить изменённую копию строки в ту же страницу, что и исходную, что гораздо эффективнее, чем размещать её на другой странице, и увеличивает возможности для внесения изменений по схеме кортежи только в куче. Для таблиц, записи в которых никогда не меняются, лучшим выбором будет плотное заполнение, но для активно изменяемых таблиц лучше выбрать меньший фактор заполнения. Этот параметр нельзя задать для таблиц TOAST.toast_tuple_target(integer) #Параметр toast_tuple_target задаёт минимальную длину кортежа, после превышения которой мы будем пытаться сжимать и/или переносить значения больших столбцов в таблицы TOAST и до которой мы будем пытаться сократить размер кортежа после перехода к TOAST. Это затрагивает столбцы с пометкой External (внешние, которые могут переноситься), Main (основные, которые могут сжиматься) или Extended (расширенные, которые могут и сжиматься, и просто переноситься) и касается только новых кортежей. На существующие кортежи это не влияет. По умолчанию этот параметр имеет значение, позволяющее разместить минимум 4 кортежа в блоке, что при стандартном размере блока составляет 2040 байт. Допустимые значения лежат в интервале от 128 байт до (размер_блока - заголовок), по умолчанию 8160 байт. Изменение этого значения может не отражаться на очень коротких и очень длинных кортежах. Заметьте, что выбранное по умолчанию значение часто близко к оптимальному, и весьма вероятно, что изменение этого параметра в некоторых случаях будет иметь отрицательный эффект. Для таблиц TOAST этот параметр задать нельзя.
parallel_workers(integer) #Данный параметр задаёт число рабочих процессов, которые должны задействоваться при параллельном сканировании таблицы. Если это значение не задано, система будет определять его, исходя из размера отношения. Фактическое число рабочих процессов, выбранное планировщиком или служебными операторами, выполняющими параллельное сканирование, может быть меньше, например, вследствие ограничения max_worker_processes.
autovacuum_enabled,toast.autovacuum_enabled(boolean) #Включает или отключает демон автоочистки для определённой таблицы. Со значением true демон автоочистки будет автоматически выполнять операции
VACUUMи/илиANALYZEв этой таблице, согласно правилам, описанным в Подразделе 24.1.6. Со значением false эта таблица не будет подвергаться автоочистке, если только это не потребуется для предотвращения зацикливания идентификаторов транзакций. Более подробно предотвращение зацикливания описывается в Подразделе 24.1.5. Заметьте, что демон автоочистки не будет запускаться вовсе (если только это не потребуется для предотвращения зацикливания), если параметр autovacuum имеет значение false; это нельзя переопределить, установив параметры хранения для отдельных таблиц. Таким образом, явно устанавливать для этого параметра значениеtrueпрактически не имеет смысла — полезно только значениеfalse.vacuum_index_cleanup,toast.vacuum_index_cleanup(enum) #Включает или отключает очистку индекса при выполнении в этой таблице операции
VACUUM. Значение по умолчанию —AUTO. ЗначениеOFFотключаёт очистку индекса,ON— включает, а со значениемAUTOрешение об очистке принимается динамически при каждом выполненииVACUUM. Динамический выбор позволяет избежать во времяVACUUMненужного сканирования индексов, в результате которого удаляются лишь несколько мёртвых кортежей. Принудительное безусловное отключение очистки индексов может очень существенно ускоритьVACUUM, но также может привести к значительному раздуванию индексов при частых изменениях данных в таблице. Если для командыVACUUMзадаётся параметрINDEX_CLEANUP, он переопределяет значениеvacuum_index_cleanup.vacuum_truncate,toast.vacuum_truncate(boolean) #Значение параметра vacuum_truncate для таблицы. Явно заданный параметр
TRUNCATEкомандыVACUUMпереопределяет значение этого параметра.autovacuum_vacuum_threshold,toast.autovacuum_vacuum_threshold(integer) #Значение параметра autovacuum_vacuum_threshold для таблицы.
autovacuum_vacuum_max_threshold,toast.autovacuum_vacuum_max_threshold(integer) #Значение параметра autovacuum_vacuum_max_threshold для таблицы.
autovacuum_vacuum_scale_factor,toast.autovacuum_vacuum_scale_factor(floating point) #Значение параметра autovacuum_vacuum_scale_factor для таблицы.
autovacuum_vacuum_insert_threshold,toast.autovacuum_vacuum_insert_threshold(integer) #Значение параметра autovacuum_vacuum_insert_threshold для таблицы. Особое значение -1 отключает очистку, вызываемую добавлением данных.
autovacuum_vacuum_insert_scale_factor,toast.autovacuum_vacuum_insert_scale_factor(floating point) #Значение параметра autovacuum_vacuum_insert_scale_factor для таблицы.
autovacuum_analyze_threshold(integer) #Значение параметра autovacuum_analyze_threshold для таблицы.
autovacuum_analyze_scale_factor(floating point) #Значение параметра autovacuum_analyze_scale_factor для таблицы.
autovacuum_vacuum_cost_delay,toast.autovacuum_vacuum_cost_delay(floating point) #Значение параметра autovacuum_vacuum_cost_delay для таблицы.
autovacuum_vacuum_cost_limit,toast.autovacuum_vacuum_cost_limit(integer) #Значение параметра autovacuum_vacuum_cost_limit для таблицы.
autovacuum_freeze_min_age,toast.autovacuum_freeze_min_age(integer) #Значение параметра vacuum_freeze_min_age для таблицы. Учтите, что система будет игнорировать установленные для таблиц значения
autovacuum_freeze_min_age, превышающие половину системного autovacuum_freeze_max_age.autovacuum_freeze_max_age,toast.autovacuum_freeze_max_age(integer) #Значение параметра autovacuum_freeze_max_age для таблицы. Учтите, что система будет игнорировать установленные для таблиц значения
autovacuum_freeze_max_age, превышающие значение системного параметра (они могут быть только меньше).autovacuum_freeze_table_age,toast.autovacuum_freeze_table_age(integer) #Значение параметра vacuum_freeze_table_age для таблицы.
autovacuum_multixact_freeze_min_age,toast.autovacuum_multixact_freeze_min_age(integer) #Значение параметра vacuum_multixact_freeze_min_age для таблицы. Учтите, что демон автоочистки будет игнорировать установленные для таблиц значения
autovacuum_multixact_freeze_min_age, превышающие половину значения системного параметра autovacuum_multixact_freeze_max_age.autovacuum_multixact_freeze_max_age,toast.autovacuum_multixact_freeze_max_age(integer) #Значение параметра autovacuum_multixact_freeze_max_age для таблицы. Учтите, что система автоочистки будет игнорировать установленные для таблиц параметры
autovacuum_multixact_freeze_max_age, превышающие системный параметр (они могут быть только меньше).autovacuum_multixact_freeze_table_age,toast.autovacuum_multixact_freeze_table_age(integer) #Значения параметра vacuum_multixact_freeze_table_age для таблицы.
log_autovacuum_min_duration,toast.log_autovacuum_min_duration(integer) #Значения параметра log_autovacuum_min_duration для таблицы.
vacuum_max_eager_freeze_failure_rate,toast.vacuum_max_eager_freeze_failure_rate(floating point) #Значение параметра vacuum_max_eager_freeze_failure_rate для таблицы.
user_catalog_table(boolean) #Объявляет таблицу как дополнительную таблицу каталога, например для целей логической репликации. За подробностями обратитесь к Подразделу 47.6.2. Для таблиц TOAST этот параметр задать нельзя.
Примечания
PostgreSQL автоматически создаёт индекс, гарантирующий уникальность, для каждого ограничения уникальности и ограничения первичного ключа. Поэтому явно создавать индекс для столбцов первичного ключа не требуется. (За дополнительными сведениями обратитесь к CREATE INDEX.)
Ограничения уникальности и первичные ключи в текущей реализации не наследуются. Вследствие этого ограничения уникальности довольно плохо сочетаются с наследованием.
В таблице не может быть больше 1600 столбцов. (На практике фактический предел обычно ниже из-за ограничения на длину записи.)
Примеры
Создание таблицы films и таблицы distributors:
CREATE TABLE films (
code char(5) CONSTRAINT firstkey PRIMARY KEY,
title varchar(40) NOT NULL,
did integer NOT NULL,
date_prod date,
kind varchar(10),
len interval hour to minute
);
CREATE TABLE distributors (
did integer PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
name varchar(40) NOT NULL CHECK (name <> '')
);Создание таблицы с двумерным массивом:
CREATE TABLE array_int (
vector int[][]
);Определение ограничения уникальности для таблицы films. Ограничения уникальности могут быть определены для одного или нескольких столбцов таблицы:
CREATE TABLE films (
code char(5),
title varchar(40),
did integer,
date_prod date,
kind varchar(10),
len interval hour to minute,
CONSTRAINT production UNIQUE(date_prod)
);Определение ограничения-проверки для столбца:
CREATE TABLE distributors (
did integer CHECK (did > 100),
name varchar(40)
);Определение ограничения-проверки для таблицы:
CREATE TABLE distributors (
did integer,
name varchar(40),
CONSTRAINT con1 CHECK (did > 100 AND name <> '')
);Определение ограничения первичного ключа для таблицы films:
CREATE TABLE films (
code char(5),
title varchar(40),
did integer,
date_prod date,
kind varchar(10),
len interval hour to minute,
CONSTRAINT code_title PRIMARY KEY(code,title)
);Определение ограничения первичного ключа для таблицы distributors. Следующие два примера равнозначны, но в первом используется синтаксис ограничений для таблицы, а во втором — для столбца:
CREATE TABLE distributors (
did integer,
name varchar(40),
PRIMARY KEY(did)
);
CREATE TABLE distributors (
did integer PRIMARY KEY,
name varchar(40)
);Определение значений по умолчанию: для столбца name значением по умолчанию будет строка, для столбца did — следующее значение объекта последовательности, а для modtime — время, когда была вставлена запись:
CREATE TABLE distributors (
name varchar(40) DEFAULT 'Luso Films',
did integer DEFAULT nextval('distributors_serial'),
modtime timestamp DEFAULT current_timestamp
);Определение двух ограничений NOT NULL для столбцов таблицы distributors, при этом одному ограничению даётся явное имя:
CREATE TABLE distributors (
did integer CONSTRAINT no_null NOT NULL,
name varchar(40) NOT NULL
);Определение ограничения уникальности для столбца name:
CREATE TABLE distributors (
did integer,
name varchar(40) UNIQUE
);То же самое условие, но в виде ограничения таблицы:
CREATE TABLE distributors (
did integer,
name varchar(40),
UNIQUE(name)
);Создание такой же таблицы с фактором заполнения 70% для таблицы и её уникального индекса:
CREATE TABLE distributors (
did integer,
name varchar(40),
UNIQUE(name) WITH (fillfactor=70)
)
WITH (fillfactor=70);Создание таблицы circles с ограничением-исключением, не допускающим пересечения двух кругов:
CREATE TABLE circles (
c circle,
EXCLUDE USING gist (c WITH &&)
);Создание таблицы cinemas в табличном пространстве diskvol1:
CREATE TABLE cinemas (
id serial,
name text,
location text
) TABLESPACE diskvol1;Создание составного типа и типизированной таблицы:
CREATE TYPE employee_type AS (name text, salary numeric);
CREATE TABLE employees OF employee_type (
PRIMARY KEY (name),
salary WITH OPTIONS DEFAULT 1000
);Создание таблицы, секционируемой по диапазонам:
CREATE TABLE measurement (
logdate date not null,
peaktemp int,
unitsales int
) PARTITION BY RANGE (logdate);Создание таблицы, секционируемой по диапазонам, с ключом секционирования, включающим несколько столбцов:
CREATE TABLE measurement_year_month (
logdate date not null,
peaktemp int,
unitsales int
) PARTITION BY RANGE (EXTRACT(YEAR FROM logdate), EXTRACT(MONTH FROM logdate));Создание таблицы, секционируемой по спискам:
CREATE TABLE cities (
city_id bigserial not null,
name text not null,
population bigint
) PARTITION BY LIST (left(lower(name), 1));Создание таблицы, секционируемой по хешу:
CREATE TABLE orders (
order_id bigint not null,
cust_id bigint not null,
status text
) PARTITION BY HASH (order_id);Создание секции таблицы, секционируемой по диапазонам:
CREATE TABLE measurement_y2016m07
PARTITION OF measurement (
unitsales DEFAULT 0
) FOR VALUES FROM ('2016-07-01') TO ('2016-08-01');Создание нескольких секций для таблицы, секционируемой по диапазонам, с ключом секционирования, включающим несколько столбцов:
CREATE TABLE measurement_ym_older
PARTITION OF measurement_year_month
FOR VALUES FROM (MINVALUE, MINVALUE) TO (2016, 11);
CREATE TABLE measurement_ym_y2016m11
PARTITION OF measurement_year_month
FOR VALUES FROM (2016, 11) TO (2016, 12);
CREATE TABLE measurement_ym_y2016m12
PARTITION OF measurement_year_month
FOR VALUES FROM (2016, 12) TO (2017, 01);
CREATE TABLE measurement_ym_y2017m01
PARTITION OF measurement_year_month
FOR VALUES FROM (2017, 01) TO (2017, 02);Создание секции таблицы, секционируемой по спискам:
CREATE TABLE cities_ab
PARTITION OF cities (
CONSTRAINT city_id_nonzero CHECK (city_id != 0)
) FOR VALUES IN ('a', 'b');Создание секции таблицы, секционируемой по спискам (при этом сама секция также создаётся секционируемой), и добавление секции в неё:
CREATE TABLE cities_ab
PARTITION OF cities (
CONSTRAINT city_id_nonzero CHECK (city_id != 0)
) FOR VALUES IN ('a', 'b') PARTITION BY RANGE (population);
CREATE TABLE cities_ab_10000_to_100000
PARTITION OF cities_ab FOR VALUES FROM (10000) TO (100000);Создание секций таблицы, секционируемой по хешу:
CREATE TABLE orders_p1 PARTITION OF orders
FOR VALUES WITH (MODULUS 4, REMAINDER 0);
CREATE TABLE orders_p2 PARTITION OF orders
FOR VALUES WITH (MODULUS 4, REMAINDER 1);
CREATE TABLE orders_p3 PARTITION OF orders
FOR VALUES WITH (MODULUS 4, REMAINDER 2);
CREATE TABLE orders_p4 PARTITION OF orders
FOR VALUES WITH (MODULUS 4, REMAINDER 3);Создание секции по умолчанию:
CREATE TABLE cities_partdef
PARTITION OF cities DEFAULT;Совместимость
Команда CREATE TABLE соответствует стандарту SQL, с описанными ниже исключениями.
Временные таблицы
Хотя синтаксис CREATE TEMPORARY TABLE подобен аналогичному в стандарте SQL, результат получается другим. В стандарте временные таблицы определяются только один раз и существуют (изначально пустые) в каждом сеансе, в котором они используются. PostgreSQL вместо этого требует, чтобы каждый сеанс выполнял собственную команду CREATE TEMPORARY TABLE для каждой временной таблицы, которая будет использоваться. Это позволяет использовать в разных сеансах таблицы с одинаковыми именами для разных целей, тогда как при подходе, регламентированном стандартом, все экземпляры временной таблицы с одним именем должны иметь одинаковую табличную структуру.
Поведение временных таблиц, описанное в стандарте, в большинстве своём игнорируют и другие СУБД, так что в этом отношении PostgreSQL ведёт себя так же, как и ряд других СУБД.
В стандарте SQL также разделяются глобальные и локальные временные таблицы — в локальной временной таблице содержится отдельный набор данных для каждого модуля SQL в отдельном сеансе, хотя её определение так же разделяется между ними. Так как в PostgreSQL модули SQL не поддерживаются, это различие в PostgreSQL не существует.
Совместимости ради, PostgreSQL принимает ключевые слова GLOBAL и LOCAL в объявлении временной таблицы, но в настоящее время они никак не действуют. Использовать их не рекомендуется, так как в будущих версиях PostgreSQL может быть принята их интерпретация, более близкая к стандарту.
Предложение ON COMMIT для временных таблиц тоже подобно описанному в стандарте SQL, но есть некоторые отличия. Если предложение ON COMMIT опущено, в SQL подразумевается поведение ON COMMIT DELETE ROWS. Однако в PostgreSQL по умолчанию действует ON COMMIT PRESERVE ROWS. Параметр ON COMMIT DROP в стандарте SQL отсутствует.
Неотложенные ограничения уникальности
Когда ограничение UNIQUE или PRIMARY KEY не является отложенным, PostgreSQL проверяет уникальность непосредственно в момент добавления или изменения строки. Стандарт SQL говорит, что уникальность должна обеспечиваться только в конце оператора; это различие проявляется, например когда одна команда изменяет множество ключевых значений. Чтобы получить поведение, оговоренное стандартом, объявите ограничение как откладываемое (DEFERRABLE), но не отложенное (т. е., INITIALLY IMMEDIATE). Учтите, что этот вариант может быть значительно медленнее, чем немедленная проверка ограничений.
Ограничения-проверки для столбцов
Стандарт SQL говорит, что ограничение CHECK, определяемое для столбца, может ссылаться только на столбец, с которым оно связано; только ограничения CHECK для таблиц могут ссылаться на несколько столбцов. В PostgreSQL этого ограничения нет; он воспринимает ограничения-проверки для столбцов и таблиц одинаково.
Ограничение EXCLUDE
Ограничения EXCLUDE являются расширением PostgreSQL.
Ограничения внешнего ключа
Возможность указывать списки столбцов в действиях внешнего ключа SET DEFAULT и SET NULL является расширением PostgreSQL.
Возможность ограничения внешнего ключа ссылаться на столбцы уникального индекса вместо столбцов первичного ключа или ограничения уникальности является расширением PostgreSQL.
NULL «Ограничение»
«Ограничение» NULL (на самом деле это не ограничение) является расширением PostgreSQL стандарта SQL, которое реализовано для совместимости с некоторыми другими СУБД (и для симметрии с ограничением NOT NULL). Так как это поведение по умолчанию для любого столбца, его присутствие не несёт смысловой нагрузки.
Имена ограничений
В стандарте SQL говорится, что имена ограничений таблицы и ограничений домена должны быть уникальными в схеме, содержащей эту таблицу или домен. Однако PostgreSQL менее строг: он требует только, чтобы имена были уникальны среди ограничений, присоединённых к данной конкретной таблице или домену. Но такого послабления нет для ограничений, построенных на индексах (ограничений UNIQUE, PRIMARY KEY и EXCLUDE), так как ограничение и связанный с ним индекс имеют одно имя, а имена индексов должны быть уникальны среди всех отношений в их схеме.
Наследование
Множественное наследование посредством INHERITS является языковым расширением PostgreSQL. SQL:1999 и более поздние стандарты определяют единичное наследование с другим синтаксисом и смыслом. Наследование в стиле SQL:1999 пока ещё не поддерживается в PostgreSQL.
Таблицы с нулём столбцов
PostgreSQL позволяет создать таблицу без столбцов (например, CREATE TABLE foo();). Это расширение стандарта SQL, который не допускает таблицы с нулём столбцов. Таблицы с нулём столбцов сами по себе не очень полезны, но если их запретить, возникают странные особые ситуации с командой ALTER TABLE DROP COLUMN, так что лучшим вариантом кажется игнорировать это требование стандарта.
Множество столбцов идентификации
PostgreSQL позволяет иметь в таблице более одного столбца идентификации. В стандарте же говорится, что в таблице может быть максимум один столбец идентификации. Это ограничение ослаблено в основном для большей гибкости при выполнении изменений в схеме или миграции. Заметьте, что команда INSERT поддерживает только одно предложение переопределения значения, применяемое ко всему оператору, так что с несколькими столбцами идентификации различное поведение не поддерживается должным образом.
Генерируемые столбцы
Указания STORED и VIRTUAL отсутствуют в стандарте, но используются и в других реализациях SQL. Стандарт SQL не предусматривает хранение генерируемых столбцов.
Предложение LIKE
Хотя предложение LIKE описано в стандарте SQL, многие варианты его использования, допустимые в PostgreSQL, в стандарте не описаны, а некоторые предусмотренные в стандарте возможности не реализованы в PostgreSQL.
Предложение WITH
Предложение WITH является расширением PostgreSQL; в стандарте параметры хранения не оговариваются.
Табличные пространства
Концепция табличных пространств в PostgreSQL отсутствует в стандарте. Как следствие, предложения TABLESPACE и USING INDEX TABLESPACE являются расширениями.
Типизированные таблицы
Типизированные таблицы реализуют подмножество стандарта SQL. Согласно стандарту, типизированная таблица содержит столбцы, соответствующие нижележащему составному типу, и ещё один столбец, ссылающийся на себя. PostgreSQL не поддерживает ссылающиеся на себя столбцы явно.
Предложение PARTITION BY
Предложение PARTITION BY является расширением PostgreSQL.
Предложение PARTITION OF
Предложение PARTITION OF является расширением PostgreSQL.
См. также
ALTER TABLE, DROP TABLE, CREATE TABLE AS, CREATE TABLESPACE, CREATE TYPECREATE TABLE
CREATE TABLE — define a new table
Synopsis
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name ( [
{ column_name data_type [ STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT } ] [ COMPRESSION compression_method ] [ COLLATE collation ] [ column_constraint [ ... ] ]
| table_constraint
| LIKE source_table [ like_option ... ] }
[, ... ]
] )
[ INHERITS ( parent_table [, ... ] ) ]
[ PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass ] [, ... ] ) ]
[ USING method ]
[ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE tablespace_name ]
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name
OF type_name [ (
{ column_name [ WITH OPTIONS ] [ column_constraint [ ... ] ]
| table_constraint }
[, ... ]
) ]
[ PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass ] [, ... ] ) ]
[ USING method ]
[ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE tablespace_name ]
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name
PARTITION OF parent_table [ (
{ column_name [ WITH OPTIONS ] [ column_constraint [ ... ] ]
| table_constraint }
[, ... ]
) ] { FOR VALUES partition_bound_spec | DEFAULT }
[ PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass ] [, ... ] ) ]
[ USING method ]
[ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE tablespace_name ]
where column_constraint is:
[ CONSTRAINT constraint_name ]
{ NOT NULL [ NO INHERIT ] |
NULL |
CHECK ( expression ) [ NO INHERIT ] |
DEFAULT default_expr |
GENERATED ALWAYS AS ( generation_expr ) [ STORED | VIRTUAL ] |
GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( sequence_options ) ] |
UNIQUE [ NULLS [ NOT ] DISTINCT ] index_parameters |
PRIMARY KEY index_parameters |
REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
[ ON DELETE referential_action ] [ ON UPDATE referential_action ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] [ ENFORCED | NOT ENFORCED ]
and table_constraint is:
[ CONSTRAINT constraint_name ]
{ CHECK ( expression ) [ NO INHERIT ] |
NOT NULL column_name [ NO INHERIT ] |
UNIQUE [ NULLS [ NOT ] DISTINCT ] ( column_name [, ... ] [, column_name WITHOUT OVERLAPS ] ) index_parameters |
PRIMARY KEY ( column_name [, ... ] [, column_name WITHOUT OVERLAPS ] ) index_parameters |
EXCLUDE [ USING index_method ] ( exclude_element WITH operator [, ... ] ) index_parameters [ WHERE ( predicate ) ] |
FOREIGN KEY ( column_name [, ... ] [, PERIOD column_name ] ) REFERENCES reftable [ ( refcolumn [, ... ] [, PERIOD refcolumn ] ) ]
[ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE referential_action ] [ ON UPDATE referential_action ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] [ ENFORCED | NOT ENFORCED ]
and like_option is:
{ INCLUDING | EXCLUDING } { COMMENTS | COMPRESSION | CONSTRAINTS | DEFAULTS | GENERATED | IDENTITY | INDEXES | STATISTICS | STORAGE | ALL }
and partition_bound_spec is:
IN ( partition_bound_expr [, ...] ) |
FROM ( { partition_bound_expr | MINVALUE | MAXVALUE } [, ...] )
TO ( { partition_bound_expr | MINVALUE | MAXVALUE } [, ...] ) |
WITH ( MODULUS numeric_literal, REMAINDER numeric_literal )
index_parameters in UNIQUE, PRIMARY KEY, and EXCLUDE constraints are:
[ INCLUDE ( column_name [, ... ] ) ]
[ WITH ( storage_parameter [= value] [, ... ] ) ]
[ USING INDEX TABLESPACE tablespace_name ]
exclude_element in an EXCLUDE constraint is:
{ column_name | ( expression ) } [ COLLATE collation ] [ opclass [ ( opclass_parameter = value [, ... ] ) ] ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
referential_action in a FOREIGN KEY/REFERENCES constraint is:
{ NO ACTION | RESTRICT | CASCADE | SET NULL [ ( column_name [, ... ] ) ] | SET DEFAULT [ ( column_name [, ... ] ) ] }
Description
CREATE TABLE will create a new, initially empty table in the current database. The table will be owned by the user issuing the command.
If a schema name is given (for example, CREATE TABLE myschema.mytable ...) then the table is created in the specified schema. Otherwise it is created in the current schema. Temporary tables exist in a special schema, so a schema name cannot be given when creating a temporary table. The name of the table must be distinct from the name of any other relation (table, sequence, index, view, materialized view, or foreign table) in the same schema.
CREATE TABLE also automatically creates a data type that represents the composite type corresponding to one row of the table. Therefore, tables cannot have the same name as any existing data type in the same schema.
The optional constraint clauses specify constraints (tests) that new or updated rows must satisfy for an insert or update operation to succeed. A constraint is an SQL object that helps define the set of valid values in the table in various ways.
There are two ways to define constraints: table constraints and column constraints. A column constraint is defined as part of a column definition. A table constraint definition is not tied to a particular column, and it can encompass more than one column. Every column constraint can also be written as a table constraint; a column constraint is only a notational convenience for use when the constraint only affects one column.
To be able to create a table, you must have USAGE privilege on all column types or the type in the OF clause, respectively.
Parameters
TEMPORARYorTEMP#If specified, the table is created as a temporary table. Temporary tables are automatically dropped at the end of a session, or optionally at the end of the current transaction (see
ON COMMITbelow). The default search_path includes the temporary schema first and so identically named existing permanent tables are not chosen for new plans while the temporary table exists, unless they are referenced with schema-qualified names. Any indexes created on a temporary table are automatically temporary as well.The autovacuum daemon cannot access and therefore cannot vacuum or analyze temporary tables. For this reason, appropriate vacuum and analyze operations should be performed via session SQL commands. For example, if a temporary table is going to be used in complex queries, it is wise to run
ANALYZEon the temporary table after it is populated.Optionally,
GLOBALorLOCALcan be written beforeTEMPORARYorTEMP. This presently makes no difference in PostgreSQL and is deprecated; see Compatibility below.UNLOGGED#If specified, the table is created as an unlogged table. Data written to unlogged tables is not written to the write-ahead log (see Chapter 28), which makes them considerably faster than ordinary tables. However, they are not crash-safe: an unlogged table is automatically truncated after a crash or unclean shutdown. The contents of an unlogged table are also not replicated to standby servers. Any indexes created on an unlogged table are automatically unlogged as well.
If this is specified, any sequences created together with the unlogged table (for identity or serial columns) are also created as unlogged.
This form is not supported for partitioned tables.
IF NOT EXISTS#Do not throw an error if a relation with the same name already exists. A notice is issued in this case. Note that there is no guarantee that the existing relation is anything like the one that would have been created.
table_name#The name (optionally schema-qualified) of the table to be created.
OF#type_nameCreates a typed table, which takes its structure from the specified stand-alone composite type (that is, one created using CREATE TYPE) though it still produces a new composite type as well. The table will have a dependency on the referenced type, meaning that cascaded alter and drop actions on that type will propagate to the table.
A typed table always has the same column names and data types as the type it is derived from, so you cannot specify additional columns. But the
CREATE TABLEcommand can add defaults and constraints to the table, as well as specify storage parameters.column_name#The name of a column to be created in the new table.
data_type#The data type of the column. This can include array specifiers. For more information on the data types supported by PostgreSQL, refer to Chapter 8.
COLLATE#collationThe
COLLATEclause assigns a collation to the column (which must be of a collatable data type). If not specified, the column data type's default collation is used.-
STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT }# This form sets the storage mode for the column. This controls whether this column is held inline or in a secondary TOAST table, and whether the data should be compressed or not.
PLAINmust be used for fixed-length values such asintegerand is inline, uncompressed.MAINis for inline, compressible data.EXTERNALis for external, uncompressed data, andEXTENDEDis for external, compressed data. WritingDEFAULTsets the storage mode to the default mode for the column's data type.EXTENDEDis the default for most data types that support non-PLAINstorage. Use ofEXTERNALwill make substring operations on very largetextandbyteavalues run faster, at the penalty of increased storage space. See Section 66.2 for more information.COMPRESSION#compression_methodThe
COMPRESSIONclause sets the compression method for the column. Compression is supported only for variable-width data types, and is used only when the column's storage mode ismainorextended. (See ALTER TABLE for information on column storage modes.) Setting this property for a partitioned table has no direct effect, because such tables have no storage of their own, but the configured value will be inherited by newly-created partitions. The supported compression methods arepglzandlz4. (lz4is available only if--with-lz4was used when building PostgreSQL.) In addition,compression_methodcan bedefaultto explicitly specify the default behavior, which is to consult the default_toast_compression setting at the time of data insertion to determine the method to use.INHERITS (#parent_table[, ... ] )The optional
INHERITSclause specifies a list of tables from which the new table automatically inherits all columns. Parent tables can be plain tables or foreign tables.Use of
INHERITScreates a persistent relationship between the new child table and its parent table(s). Schema modifications to the parent(s) normally propagate to children as well, and by default the data of the child table is included in scans of the parent(s).If the same column name exists in more than one parent table, an error is reported unless the data types of the columns match in each of the parent tables. If there is no conflict, then the duplicate columns are merged to form a single column in the new table. If the column name list of the new table contains a column name that is also inherited, the data type must likewise match the inherited column(s), and the column definitions are merged into one. If the new table explicitly specifies a default value for the column, this default overrides any defaults from inherited declarations of the column. Otherwise, any parents that specify default values for the column must all specify the same default, or an error will be reported.
CHECKconstraints are merged in essentially the same way as columns: if multiple parent tables and/or the new table definition contain identically-namedCHECKconstraints, these constraints must all have the same check expression, or an error will be reported. Constraints having the same name and expression will be merged into one copy. A constraint markedNO INHERITin a parent will not be considered. Notice that an unnamedCHECKconstraint in the new table will never be merged, since a unique name will always be chosen for it.Column
STORAGEsettings are also copied from parent tables.If a column in the parent table is an identity column, that property is not inherited. A column in the child table can be declared identity column if desired.
PARTITION BY { RANGE | LIST | HASH } ( {#column_name| (expression) } [opclass] [, ...] )The optional
PARTITION BYclause specifies a strategy of partitioning the table. The table thus created is called a partitioned table. The parenthesized list of columns or expressions forms the partition key for the table. When using range or hash partitioning, the partition key can include multiple columns or expressions (up to 32, but this limit can be altered when building PostgreSQL), but for list partitioning, the partition key must consist of a single column or expression.Range and list partitioning require a btree operator class, while hash partitioning requires a hash operator class. If no operator class is specified explicitly, the default operator class of the appropriate type will be used; if no default operator class exists, an error will be raised. When hash partitioning is used, the operator class used must implement support function 2 (see Section 36.16.3 for details).
A partitioned table is divided into sub-tables (called partitions), which are created using separate
CREATE TABLEcommands. The partitioned table is itself empty. A data row inserted into the table is routed to a partition based on the value of columns or expressions in the partition key. If no existing partition matches the values in the new row, an error will be reported.See Section 5.12 for more discussion on table partitioning.
PARTITION OF#parent_table{ FOR VALUESpartition_bound_spec| DEFAULT }Creates the table as a partition of the specified parent table. The table can be created either as a partition for specific values using
FOR VALUESor as a default partition usingDEFAULT. Any indexes, constraints and user-defined row-level triggers that exist in the parent table are cloned on the new partition.The
partition_bound_specmust correspond to the partitioning method and partition key of the parent table, and must not overlap with any existing partition of that parent. The form withINis used for list partitioning, the form withFROMandTOis used for range partitioning, and the form withWITHis used for hash partitioning.partition_bound_expris any variable-free expression (subqueries, window functions, aggregate functions, and set-returning functions are not allowed). Its data type must match the data type of the corresponding partition key column. The expression is evaluated once at table creation time, so it can even contain volatile expressions such as.CURRENT_TIMESTAMPWhen creating a list partition,
NULLcan be specified to signify that the partition allows the partition key column to be null. However, there cannot be more than one such list partition for a given parent table.NULLcannot be specified for range partitions.When creating a range partition, the lower bound specified with
FROMis an inclusive bound, whereas the upper bound specified withTOis an exclusive bound. That is, the values specified in theFROMlist are valid values of the corresponding partition key columns for this partition, whereas those in theTOlist are not. Note that this statement must be understood according to the rules of row-wise comparison (Section 9.25.5). For example, givenPARTITION BY RANGE (x,y), a partition boundFROM (1, 2) TO (3, 4)allowsx=1with anyy>=2,x=2with any non-nully, andx=3with anyy<4.The special values
MINVALUEandMAXVALUEmay be used when creating a range partition to indicate that there is no lower or upper bound on the column's value. For example, a partition defined usingFROM (MINVALUE) TO (10)allows any values less than 10, and a partition defined usingFROM (10) TO (MAXVALUE)allows any values greater than or equal to 10.When creating a range partition involving more than one column, it can also make sense to use
MAXVALUEas part of the lower bound, andMINVALUEas part of the upper bound. For example, a partition defined usingFROM (0, MAXVALUE) TO (10, MAXVALUE)allows any rows where the first partition key column is greater than 0 and less than or equal to 10. Similarly, a partition defined usingFROM ('a', MINVALUE) TO ('b', MINVALUE)allows any rows where the first partition key column starts with "a".Note that if
MINVALUEorMAXVALUEis used for one column of a partitioning bound, the same value must be used for all subsequent columns. For example,(10, MINVALUE, 0)is not a valid bound; you should write(10, MINVALUE, MINVALUE).Also note that some element types, such as
timestamp, have a notion of "infinity", which is just another value that can be stored. This is different fromMINVALUEandMAXVALUE, which are not real values that can be stored, but rather they are ways of saying that the value is unbounded.MAXVALUEcan be thought of as being greater than any other value, including "infinity" andMINVALUEas being less than any other value, including "minus infinity". Thus the rangeFROM ('infinity') TO (MAXVALUE)is not an empty range; it allows precisely one value to be stored — "infinity".If
DEFAULTis specified, the table will be created as the default partition of the parent table. This option is not available for hash-partitioned tables. A partition key value not fitting into any other partition of the given parent will be routed to the default partition.When a table has an existing
DEFAULTpartition and a new partition is added to it, the default partition must be scanned to verify that it does not contain any rows which properly belong in the new partition. If the default partition contains a large number of rows, this may be slow. The scan will be skipped if the default partition is a foreign table or if it has a constraint which proves that it cannot contain rows which should be placed in the new partition.When creating a hash partition, a modulus and remainder must be specified. The modulus must be a positive integer, and the remainder must be a non-negative integer less than the modulus. Typically, when initially setting up a hash-partitioned table, you should choose a modulus equal to the number of partitions and assign every table the same modulus and a different remainder (see examples, below). However, it is not required that every partition have the same modulus, only that every modulus which occurs among the partitions of a hash-partitioned table is a factor of the next larger modulus. This allows the number of partitions to be increased incrementally without needing to move all the data at once. For example, suppose you have a hash-partitioned table with 8 partitions, each of which has modulus 8, but find it necessary to increase the number of partitions to 16. You can detach one of the modulus-8 partitions, create two new modulus-16 partitions covering the same portion of the key space (one with a remainder equal to the remainder of the detached partition, and the other with a remainder equal to that value plus 8), and repopulate them with data. You can then repeat this -- perhaps at a later time -- for each modulus-8 partition until none remain. While this may still involve a large amount of data movement at each step, it is still better than having to create a whole new table and move all the data at once.
A partition must have the same column names and types as the partitioned table to which it belongs. Modifications to the column names or types of a partitioned table will automatically propagate to all partitions.
CHECKconstraints will be inherited automatically by every partition, but an individual partition may specify additionalCHECKconstraints; additional constraints with the same name and condition as in the parent will be merged with the parent constraint. Defaults may be specified separately for each partition. But note that a partition's default value is not applied when inserting a tuple through a partitioned table.Rows inserted into a partitioned table will be automatically routed to the correct partition. If no suitable partition exists, an error will occur.
Operations such as
TRUNCATEwhich normally affect a table and all of its inheritance children will cascade to all partitions, but may also be performed on an individual partition.Note that creating a partition using
PARTITION OFrequires taking anACCESS EXCLUSIVElock on the parent partitioned table. Likewise, dropping a partition withDROP TABLErequires taking anACCESS EXCLUSIVElock on the parent table. It is possible to useALTER TABLE ATTACH/DETACH PARTITIONto perform these operations with a weaker lock, thus reducing interference with concurrent operations on the partitioned table.LIKE#source_table[like_option... ]The
LIKEclause specifies a table from which the new table automatically copies all column names, their data types, and their not-null constraints.Unlike
INHERITS, the new table and original table are completely decoupled after creation is complete. Changes to the original table will not be applied to the new table, and it is not possible to include data of the new table in scans of the original table.Also unlike
INHERITS, columns and constraints copied byLIKEare not merged with similarly named columns and constraints. If the same name is specified explicitly or in anotherLIKEclause, an error is signaled.The optional
like_optionclauses specify which additional properties of the original table to copy. SpecifyingINCLUDINGcopies the property, specifyingEXCLUDINGomits the property.EXCLUDINGis the default. If multiple specifications are made for the same kind of object, the last one is used. The available options are:INCLUDING COMMENTS#Comments for the copied columns, check constraints, not-null constraints, indexes, and extended statistics will be copied. The default behavior is to exclude comments, resulting in the corresponding objects in the new table having no comments.
INCLUDING COMPRESSION#Compression method of the columns will be copied. The default behavior is to exclude compression methods, resulting in columns having the default compression method.
INCLUDING CONSTRAINTS#CHECKconstraints will be copied. No distinction is made between column constraints and table constraints. Not-null constraints are always copied to the new table.INCLUDING DEFAULTS#Default expressions for the copied column definitions will be copied. Otherwise, default expressions are not copied, resulting in the copied columns in the new table having null defaults. Note that copying defaults that call database-modification functions, such as
nextval, may create a functional linkage between the original and new tables.INCLUDING GENERATED#Any generation expressions as well as the stored/virtual choice of copied column definitions will be copied. By default, new columns will be regular base columns.
INCLUDING IDENTITY#Any identity specifications of copied column definitions will be copied. A new sequence is created for each identity column of the new table, separate from the sequences associated with the old table.
INCLUDING INDEXES#Indexes,
PRIMARY KEY,UNIQUE, andEXCLUDEconstraints on the original table will be created on the new table. Names for the new indexes and constraints are chosen according to the default rules, regardless of how the originals were named. (This behavior avoids possible duplicate-name failures for the new indexes.)INCLUDING STATISTICS#Extended statistics are copied to the new table.
INCLUDING STORAGE#STORAGEsettings for the copied column definitions will be copied. The default behavior is to excludeSTORAGEsettings, resulting in the copied columns in the new table having type-specific default settings. For more onSTORAGEsettings, see Section 66.2.INCLUDING ALL#INCLUDING ALLis an abbreviated form selecting all the available individual options. (It could be useful to write individualEXCLUDINGclauses afterINCLUDING ALLto select all but some specific options.)
The
LIKEclause can also be used to copy column definitions from views, foreign tables, or composite types. Inapplicable options (e.g.,INCLUDING INDEXESfrom a view) are ignored.CONSTRAINT#constraint_nameAn optional name for a column or table constraint. If the constraint is violated, the constraint name is present in error messages, so constraint names like
col must be positivecan be used to communicate helpful constraint information to client applications. (Double-quotes are needed to specify constraint names that contain spaces.) If a constraint name is not specified, the system generates a name.NOT NULL [ NO INHERIT ]#The column is not allowed to contain null values.
A constraint marked with
NO INHERITwill not propagate to child tables.NULL#The column is allowed to contain null values. This is the default.
This clause is only provided for compatibility with non-standard SQL databases. Its use is discouraged in new applications.
CHECK (#expression) [ NO INHERIT ]The
CHECKclause specifies an expression producing a Boolean result which new or updated rows must satisfy for an insert or update operation to succeed. Expressions evaluating to TRUE or UNKNOWN succeed. Should any row of an insert or update operation produce a FALSE result, an error exception is raised and the insert or update does not alter the database. A check constraint specified as a column constraint should reference that column's value only, while an expression appearing in a table constraint can reference multiple columns.Currently,
CHECKexpressions cannot contain subqueries nor refer to variables other than columns of the current row (see Section 5.5.1). The system columntableoidmay be referenced, but not any other system column.A constraint marked with
NO INHERITwill not propagate to child tables.When a table has multiple
CHECKconstraints, they will be tested for each row in alphabetical order by name, after checkingNOT NULLconstraints. (PostgreSQL versions before 9.5 did not honor any particular firing order forCHECKconstraints.)DEFAULT#default_exprThe
DEFAULTclause assigns a default data value for the column whose column definition it appears within. The value is any variable-free expression (in particular, cross-references to other columns in the current table are not allowed). Subqueries are not allowed either. The data type of the default expression must match the data type of the column.The default expression will be used in any insert operation that does not specify a value for the column. If there is no default for a column, then the default is null.
GENERATED ALWAYS AS (#generation_expr) [ STORED | VIRTUAL ]This clause creates the column as a generated column. The column cannot be written to, and when read the result of the specified expression will be returned.
When
VIRTUALis specified, the column will be computed when it is read, and it will not occupy any storage. WhenSTOREDis specified, the column will be computed on write and will be stored on disk.VIRTUALis the default.The generation expression can refer to other columns in the table, but not other generated columns. Any functions and operators used must be immutable. References to other tables are not allowed.
A virtual generated column cannot have a user-defined type, and the generation expression of a virtual generated column must not reference user-defined functions or types, that is, it can only use built-in functions or types. This applies also indirectly, such as for functions or types that underlie operators or casts. (This restriction does not exist for stored generated columns.)
GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ (#sequence_options) ]This clause creates the column as an identity column. It will have an implicit sequence attached to it and in newly-inserted rows the column will automatically have values from the sequence assigned to it. Such a column is implicitly
NOT NULL.The clauses
ALWAYSandBY DEFAULTdetermine how explicitly user-specified values are handled inINSERTandUPDATEcommands.In an
INSERTcommand, ifALWAYSis selected, a user-specified value is only accepted if theINSERTstatement specifiesOVERRIDING SYSTEM VALUE. IfBY DEFAULTis selected, then the user-specified value takes precedence. See INSERT for details. (In theCOPYcommand, user-specified values are always used regardless of this setting.)In an
UPDATEcommand, ifALWAYSis selected, any update of the column to any value other thanDEFAULTwill be rejected. IfBY DEFAULTis selected, the column can be updated normally. (There is noOVERRIDINGclause for theUPDATEcommand.)The optional
sequence_optionsclause can be used to override the parameters of the sequence. The available options include those shown for CREATE SEQUENCE, plusSEQUENCE NAME,nameLOGGED, andUNLOGGED, which allow selection of the name and persistence level of the sequence. WithoutSEQUENCE NAME, the system chooses an unused name for the sequence. WithoutLOGGEDorUNLOGGED, the sequence will have the same persistence level as the table.UNIQUE [ NULLS [ NOT ] DISTINCT ](column constraint)UNIQUE [ NULLS [ NOT ] DISTINCT ] ([column_name[, ... ] [,column_nameWITHOUT OVERLAPS ] )INCLUDE (] (table constraint) #column_name[, ...])The
UNIQUEconstraint specifies that a group of one or more columns of a table can contain only unique values. The behavior of a unique table constraint is the same as that of a unique column constraint, with the additional capability to span multiple columns. The constraint therefore enforces that any two rows must differ in at least one of these columns.If the
WITHOUT OVERLAPSoption is specified for the last column, then that column is checked for overlaps instead of equality. In that case, the other columns of the constraint will allow duplicates so long as the duplicates don't overlap in theWITHOUT OVERLAPScolumn. (This is sometimes called a temporal key, if the column is a range of dates or timestamps, but PostgreSQL allows ranges over any base type.) In effect, such a constraint is enforced with anEXCLUDEconstraint rather than aUNIQUEconstraint. So for exampleUNIQUE (id, valid_at WITHOUT OVERLAPS)behaves likeEXCLUDE USING GIST (id WITH =, valid_at WITH &&). TheWITHOUT OVERLAPScolumn must have a range or multirange type. Empty ranges/multiranges are not permitted. The non-WITHOUT OVERLAPScolumns of the constraint can be any type that can be compared for equality in a GiST index. By default, only range types are supported, but you can use other types by adding the btree_gist extension (which is the expected way to use this feature).For the purpose of a unique constraint, null values are not considered equal, unless
NULLS NOT DISTINCTis specified.Each unique constraint should name a set of columns that is different from the set of columns named by any other unique or primary key constraint defined for the table. (Otherwise, redundant unique constraints will be discarded.)
When establishing a unique constraint for a multi-level partition hierarchy, all the columns in the partition key of the target partitioned table, as well as those of all its descendant partitioned tables, must be included in the constraint definition.
Adding a unique constraint will automatically create a unique btree index on the column or group of columns used in the constraint. But if the constraint includes a
WITHOUT OVERLAPSclause, it will use a GiST index. The created index has the same name as the unique constraint.The optional
INCLUDEclause adds to that index one or more columns that are simply “payload”: uniqueness is not enforced on them, and the index cannot be searched on the basis of those columns. However they can be retrieved by an index-only scan. Note that although the constraint is not enforced on included columns, it still depends on them. Consequently, some operations on such columns (e.g.,DROP COLUMN) can cause cascaded constraint and index deletion.PRIMARY KEY(column constraint)PRIMARY KEY ([column_name[, ... ] [,column_nameWITHOUT OVERLAPS ] )INCLUDE (] (table constraint) #column_name[, ...])The
PRIMARY KEYconstraint specifies that a column or columns of a table can contain only unique (non-duplicate), nonnull values. Only one primary key can be specified for a table, whether as a column constraint or a table constraint.The primary key constraint should name a set of columns that is different from the set of columns named by any unique constraint defined for the same table. (Otherwise, the unique constraint is redundant and will be discarded.)
PRIMARY KEYenforces the same data constraints as a combination ofUNIQUEandNOT NULL. However, identifying a set of columns as the primary key also provides metadata about the design of the schema, since a primary key implies that other tables can rely on this set of columns as a unique identifier for rows.When placed on a partitioned table,
PRIMARY KEYconstraints share the restrictions previously described forUNIQUEconstraints.Adding a
PRIMARY KEYconstraint will automatically create a unique btree index on the column or group of columns used in the constraint, or GiST ifWITHOUT OVERLAPSwas specified.The optional
INCLUDEclause adds to that index one or more columns that are simply “payload”: uniqueness is not enforced on them, and the index cannot be searched on the basis of those columns. However they can be retrieved by an index-only scan. Note that although the constraint is not enforced on included columns, it still depends on them. Consequently, some operations on such columns (e.g.,DROP COLUMN) can cause cascaded constraint and index deletion.EXCLUDE [ USING#index_method] (exclude_elementWITHoperator[, ... ] )index_parameters[ WHERE (predicate) ]The
EXCLUDEclause defines an exclusion constraint, which guarantees that if any two rows are compared on the specified column(s) or expression(s) using the specified operator(s), not all of these comparisons will returnTRUE. If all of the specified operators test for equality, this is equivalent to aUNIQUEconstraint, although an ordinary unique constraint will be faster. However, exclusion constraints can specify constraints that are more general than simple equality. For example, you can specify a constraint that no two rows in the table contain overlapping circles (see Section 8.8) by using the&&operator. The operator(s) are required to be commutative.Exclusion constraints are implemented using an index that has the same name as the constraint, so each specified operator must be associated with an appropriate operator class (see Section 11.10) for the index access method
index_method. Eachexclude_elementdefines a column of the index, so it can optionally specify a collation, an operator class, operator class parameters, and/or ordering options; these are described fully under CREATE INDEX.The access method must support
amgettuple(see Chapter 63); at present this means GIN cannot be used. Although it's allowed, there is little point in using B-tree or hash indexes with an exclusion constraint, because this does nothing that an ordinary unique constraint doesn't do better. So in practice the access method will always be GiST or SP-GiST.The
predicateallows you to specify an exclusion constraint on a subset of the table; internally this creates a partial index. Note that parentheses are required around the predicate.When establishing an exclusion constraint for a multi-level partition hierarchy, all the columns in the partition key of the target partitioned table, as well as those of all its descendant partitioned tables, must be included in the constraint definition. Additionally, those columns must be compared using the equality operator. These restrictions ensure that potentially-conflicting rows will exist in the same partition. The constraint may also refer to other columns which are not a part of any partition key, which can be compared using any appropriate operator.
REFERENCES(column constraint)reftable[ (refcolumn) ] [ MATCHmatchtype] [ ON DELETEreferential_action] [ ON UPDATEreferential_action]FOREIGN KEY ((table constraint) #column_name[, ... ] [, PERIODcolumn_name] ) REFERENCESreftable[ (refcolumn[, ... ] [, PERIODrefcolumn] ) ] [ MATCHmatchtype] [ ON DELETEreferential_action] [ ON UPDATEreferential_action]These clauses specify a foreign key constraint, which requires that a group of one or more columns of the new table must only contain values that match values in the referenced column(s) of some row of the referenced table. If the
refcolumnlist is omitted, the primary key of thereftableis used. Otherwise, therefcolumnlist must refer to the columns of a non-deferrable unique or primary key constraint or be the columns of a non-partial unique index.If the last column is marked with
PERIOD, it is treated in a special way. While the non-PERIODcolumns are compared for equality (and there must be at least one of them), thePERIODcolumn is not. Instead, the constraint is considered satisfied if the referenced table has matching records (based on the non-PERIODparts of the key) whose combinedPERIODvalues completely cover the referencing record's. In other words, the reference must have a referent for its entire duration. This column must be a range or multirange type. In addition, the referenced table must have a primary key or unique constraint declared withWITHOUT OVERLAPS. Finally, if the foreign key has a PERIODcolumn_namespecification the correspondingrefcolumn, if present, must also be markedPERIOD. If therefcolumnclause is omitted, and thus the reftable's primary key constraint chosen, the primary key must have its final column markedWITHOUT OVERLAPS.For each pair of referencing and referenced column, if they are of a collatable data type, then the collations must either be both deterministic or else both the same. This ensures that both columns have a consistent notion of equality.
The user must have
REFERENCESpermission on the referenced table (either the whole table, or the specific referenced columns). The addition of a foreign key constraint requires aSHARE ROW EXCLUSIVElock on the referenced table. Note that foreign key constraints cannot be defined between temporary tables and permanent tables.A value inserted into the referencing column(s) is matched against the values of the referenced table and referenced columns using the given match type. There are three match types:
MATCH FULL,MATCH PARTIAL, andMATCH SIMPLE(which is the default).MATCH FULLwill not allow one column of a multicolumn foreign key to be null unless all foreign key columns are null; if they are all null, the row is not required to have a match in the referenced table.MATCH SIMPLEallows any of the foreign key columns to be null; if any of them are null, the row is not required to have a match in the referenced table.MATCH PARTIALis not yet implemented. (Of course,NOT NULLconstraints can be applied to the referencing column(s) to prevent these cases from arising.)In addition, when the data in the referenced columns is changed, certain actions are performed on the data in this table's columns. The
ON DELETEclause specifies the action to perform when a referenced row in the referenced table is being deleted. Likewise, theON UPDATEclause specifies the action to perform when a referenced column in the referenced table is being updated to a new value. If the row is updated, but the referenced column is not actually changed, no action is done. Referential actions are executed as part of the data changing command, even if the constraint is deferred. There are the following possible actions for each clause:NO ACTION#Produce an error if the deletion or update would create a foreign key constraint violation. If the constraint is deferred, this error will be produced at constraint check time if there still exist any referencing rows. This is the default action.
RESTRICT#Produce an error if a row to be deleted or updated matches a row in the referencing table. This prevents the action even if the state after the action would not violate the foreign key constraint. In particular, it prevents updates of referenced rows to values that are distinct but compare as equal. (But it does not prevent “no-op” updates that update a column to the same value.)
In a temporal foreign key, this option is not supported.
CASCADE#Delete any rows referencing the deleted row, or update the values of the referencing column(s) to the new values of the referenced columns, respectively.
In a temporal foreign key, this option is not supported.
SET NULL [ (#column_name[, ... ] ) ]Set all of the referencing columns, or a specified subset of the referencing columns, to null. A subset of columns can only be specified for
ON DELETEactions.In a temporal foreign key, this option is not supported.
SET DEFAULT [ (#column_name[, ... ] ) ]Set all of the referencing columns, or a specified subset of the referencing columns, to their default values. A subset of columns can only be specified for
ON DELETEactions. (There must be a row in the referenced table matching the default values, if they are not null, or the operation will fail.)In a temporal foreign key, this option is not supported.
If the referenced column(s) are changed frequently, it might be wise to add an index to the referencing column(s) so that referential actions associated with the foreign key constraint can be performed more efficiently.
DEFERRABLENOT DEFERRABLE#This controls whether the constraint can be deferred. A constraint that is not deferrable will be checked immediately after every command. Checking of constraints that are deferrable can be postponed until the end of the transaction (using the
SET CONSTRAINTScommand).NOT DEFERRABLEis the default. Currently, onlyUNIQUE,PRIMARY KEY,EXCLUDE, andREFERENCES(foreign key) constraints accept this clause.NOT NULLandCHECKconstraints are not deferrable. Note that deferrable constraints cannot be used as conflict arbiters in anINSERTstatement that includes anON CONFLICTclause.INITIALLY IMMEDIATEINITIALLY DEFERRED#If a constraint is deferrable, this clause specifies the default time to check the constraint. If the constraint is
INITIALLY IMMEDIATE, it is checked after each statement. This is the default. If the constraint isINITIALLY DEFERRED, it is checked only at the end of the transaction. The constraint check time can be altered with theSET CONSTRAINTScommand.ENFORCEDNOT ENFORCED#When the constraint is
ENFORCED, then the database system will ensure that the constraint is satisfied, by checking the constraint at appropriate times (after each statement or at the end of the transaction, as appropriate). That is the default. If the constraint isNOT ENFORCED, the database system will not check the constraint. It is then up to the application code to ensure that the constraints are satisfied. The database system might still assume that the data actually satisfies the constraint for optimization decisions where this does not affect the correctness of the result.NOT ENFORCEDconstraints can be useful as documentation if the actual checking of the constraint at run time is too expensive.This is currently only supported for foreign key and
CHECKconstraints.USING#methodThis optional clause specifies the table access method to use to store the contents for the new table; the method needs be an access method of type
TABLE. See Chapter 62 for more information. If this option is not specified, the default table access method is chosen for the new table. See default_table_access_method for more information.When creating a partition, the table access method is the access method of its partitioned table, if set.
WITH (#storage_parameter[=value] [, ... ] )This clause specifies optional storage parameters for a table or index; see Storage Parameters below for more information. For backward-compatibility the
WITHclause for a table can also includeOIDS=FALSEto specify that rows of the new table should not contain OIDs (object identifiers),OIDS=TRUEis not supported anymore.WITHOUT OIDS#This is backward-compatible syntax for declaring a table
WITHOUT OIDS, creating a tableWITH OIDSis not supported anymore.ON COMMIT#The behavior of temporary tables at the end of a transaction block can be controlled using
ON COMMIT. The three options are:PRESERVE ROWS#No special action is taken at the ends of transactions. This is the default behavior.
DELETE ROWS#All rows in the temporary table will be deleted at the end of each transaction block. Essentially, an automatic
TRUNCATEis done at each commit. When used on a partitioned table, this is not cascaded to its partitions.DROP#The temporary table will be dropped at the end of the current transaction block. When used on a partitioned table, this action drops its partitions and when used on tables with inheritance children, it drops the dependent children.
TABLESPACE#tablespace_nameThe
tablespace_nameis the name of the tablespace in which the new table is to be created. If not specified, default_tablespace is consulted, or temp_tablespaces if the table is temporary. For partitioned tables, since no storage is required for the table itself, the tablespace specified overridesdefault_tablespaceas the default tablespace to use for any newly created partitions when no other tablespace is explicitly specified.USING INDEX TABLESPACE#tablespace_nameThis clause allows selection of the tablespace in which the index associated with a
UNIQUE,PRIMARY KEY, orEXCLUDEconstraint will be created. If not specified, default_tablespace is consulted, or temp_tablespaces if the table is temporary.
Storage Parameters
The WITH clause can specify storage parameters for tables, and for indexes associated with a UNIQUE, PRIMARY KEY, or EXCLUDE constraint. Storage parameters for indexes are documented in CREATE INDEX. The storage parameters currently available for tables are listed below. For many of these parameters, as shown, there is an additional parameter with the same name prefixed with toast., which controls the behavior of the table's secondary TOAST table, if any (see Section 66.2 for more information about TOAST). If a table parameter value is set and the equivalent toast. parameter is not, the TOAST table will use the table's parameter value. Specifying these parameters for partitioned tables is not supported, but you may specify them for individual leaf partitions.
fillfactor(integer) #The fillfactor for a table is a percentage between 10 and 100. 100 (complete packing) is the default. When a smaller fillfactor is specified,
INSERToperations pack table pages only to the indicated percentage; the remaining space on each page is reserved for updating rows on that page. This givesUPDATEa chance to place the updated copy of a row on the same page as the original, which is more efficient than placing it on a different page, and makes heap-only tuple updates more likely. For a table whose entries are never updated, complete packing is the best choice, but in heavily updated tables smaller fillfactors are appropriate. This parameter cannot be set for TOAST tables.toast_tuple_target(integer) #The toast_tuple_target specifies the minimum tuple length required before we try to compress and/or move long column values into TOAST tables, and is also the target length we try to reduce the length below once toasting begins. This affects columns marked as External (for move), Main (for compression), or Extended (for both) and applies only to new tuples. There is no effect on existing rows. By default this parameter is set to allow at least 4 tuples per block, which with the default block size will be 2040 bytes. Valid values are between 128 bytes and the (block size - header), by default 8160 bytes. Changing this value may not be useful for very short or very long rows. Note that the default setting is often close to optimal, and it is possible that setting this parameter could have negative effects in some cases. This parameter cannot be set for TOAST tables.
parallel_workers(integer) #This sets the number of workers that should be used to assist a parallel scan of this table. If not set, the system will determine a value based on the relation size. The actual number of workers chosen by the planner or by utility statements that use parallel scans may be less, for example due to the setting of max_worker_processes.
autovacuum_enabled,toast.autovacuum_enabled(boolean) #Enables or disables the autovacuum daemon for a particular table. If true, the autovacuum daemon will perform automatic
VACUUMand/orANALYZEoperations on this table following the rules discussed in Section 24.1.6. If false, this table will not be autovacuumed, except to prevent transaction ID wraparound. See Section 24.1.5 for more about wraparound prevention. Note that the autovacuum daemon does not run at all (except to prevent transaction ID wraparound) if the autovacuum parameter is false; setting individual tables' storage parameters does not override that. Therefore there is seldom much point in explicitly setting this storage parameter totrue, only tofalse.vacuum_index_cleanup,toast.vacuum_index_cleanup(enum) #Forces or disables index cleanup when
VACUUMis run on this table. The default value isAUTO. WithOFF, index cleanup is disabled, withONit is enabled, and withAUTOa decision is made dynamically, each timeVACUUMruns. The dynamic behavior allowsVACUUMto avoid needlessly scanning indexes to remove very few dead tuples. Forcibly disabling all index cleanup can speed upVACUUMvery significantly, but may also lead to severely bloated indexes if table modifications are frequent. TheINDEX_CLEANUPparameter ofVACUUM, if specified, overrides the value of this option.vacuum_truncate,toast.vacuum_truncate(boolean) #Per-table value for vacuum_truncate parameter. The
TRUNCATEparameter ofVACUUM, if specified, overrides the value of this option.autovacuum_vacuum_threshold,toast.autovacuum_vacuum_threshold(integer) #Per-table value for autovacuum_vacuum_threshold parameter.
autovacuum_vacuum_max_threshold,toast.autovacuum_vacuum_max_threshold(integer) #Per-table value for autovacuum_vacuum_max_threshold parameter.
autovacuum_vacuum_scale_factor,toast.autovacuum_vacuum_scale_factor(floating point) #Per-table value for autovacuum_vacuum_scale_factor parameter.
autovacuum_vacuum_insert_threshold,toast.autovacuum_vacuum_insert_threshold(integer) #Per-table value for autovacuum_vacuum_insert_threshold parameter. The special value of -1 may be used to disable insert vacuums on the table.
autovacuum_vacuum_insert_scale_factor,toast.autovacuum_vacuum_insert_scale_factor(floating point) #Per-table value for autovacuum_vacuum_insert_scale_factor parameter.
autovacuum_analyze_threshold(integer) #Per-table value for autovacuum_analyze_threshold parameter.
autovacuum_analyze_scale_factor(floating point) #Per-table value for autovacuum_analyze_scale_factor parameter.
autovacuum_vacuum_cost_delay,toast.autovacuum_vacuum_cost_delay(floating point) #Per-table value for autovacuum_vacuum_cost_delay parameter.
autovacuum_vacuum_cost_limit,toast.autovacuum_vacuum_cost_limit(integer) #Per-table value for autovacuum_vacuum_cost_limit parameter.
autovacuum_freeze_min_age,toast.autovacuum_freeze_min_age(integer) #Per-table value for vacuum_freeze_min_age parameter. Note that autovacuum will ignore per-table
autovacuum_freeze_min_ageparameters that are larger than half the system-wide autovacuum_freeze_max_age setting.autovacuum_freeze_max_age,toast.autovacuum_freeze_max_age(integer) #Per-table value for autovacuum_freeze_max_age parameter. Note that autovacuum will ignore per-table
autovacuum_freeze_max_ageparameters that are larger than the system-wide setting (it can only be set smaller).autovacuum_freeze_table_age,toast.autovacuum_freeze_table_age(integer) #Per-table value for vacuum_freeze_table_age parameter.
autovacuum_multixact_freeze_min_age,toast.autovacuum_multixact_freeze_min_age(integer) #Per-table value for vacuum_multixact_freeze_min_age parameter. Note that autovacuum will ignore per-table
autovacuum_multixact_freeze_min_ageparameters that are larger than half the system-wide autovacuum_multixact_freeze_max_age setting.autovacuum_multixact_freeze_max_age,toast.autovacuum_multixact_freeze_max_age(integer) #Per-table value for autovacuum_multixact_freeze_max_age parameter. Note that autovacuum will ignore per-table
autovacuum_multixact_freeze_max_ageparameters that are larger than the system-wide setting (it can only be set smaller).autovacuum_multixact_freeze_table_age,toast.autovacuum_multixact_freeze_table_age(integer) #Per-table value for vacuum_multixact_freeze_table_age parameter.
log_autovacuum_min_duration,toast.log_autovacuum_min_duration(integer) #Per-table value for log_autovacuum_min_duration parameter.
vacuum_max_eager_freeze_failure_rate,toast.vacuum_max_eager_freeze_failure_rate(floating point) #Per-table value for vacuum_max_eager_freeze_failure_rate parameter.
user_catalog_table(boolean) #Declare the table as an additional catalog table for purposes of logical replication. See Section 47.6.2 for details. This parameter cannot be set for TOAST tables.
Notes
PostgreSQL automatically creates an index for each unique constraint and primary key constraint to enforce uniqueness. Thus, it is not necessary to create an index explicitly for primary key columns. (See CREATE INDEX for more information.)
Unique constraints and primary keys are not inherited in the current implementation. This makes the combination of inheritance and unique constraints rather dysfunctional.
A table cannot have more than 1600 columns. (In practice, the effective limit is usually lower because of tuple-length constraints.)
Examples
Create table films and table distributors:
CREATE TABLE films (
code char(5) CONSTRAINT firstkey PRIMARY KEY,
title varchar(40) NOT NULL,
did integer NOT NULL,
date_prod date,
kind varchar(10),
len interval hour to minute
);
CREATE TABLE distributors (
did integer PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
name varchar(40) NOT NULL CHECK (name <> '')
);
Create a table with a 2-dimensional array:
CREATE TABLE array_int (
vector int[][]
);
Define a unique table constraint for the table films. Unique table constraints can be defined on one or more columns of the table:
CREATE TABLE films (
code char(5),
title varchar(40),
did integer,
date_prod date,
kind varchar(10),
len interval hour to minute,
CONSTRAINT production UNIQUE(date_prod)
);
Define a check column constraint:
CREATE TABLE distributors (
did integer CHECK (did > 100),
name varchar(40)
);
Define a check table constraint:
CREATE TABLE distributors (
did integer,
name varchar(40),
CONSTRAINT con1 CHECK (did > 100 AND name <> '')
);
Define a primary key table constraint for the table films:
CREATE TABLE films (
code char(5),
title varchar(40),
did integer,
date_prod date,
kind varchar(10),
len interval hour to minute,
CONSTRAINT code_title PRIMARY KEY(code,title)
);
Define a primary key constraint for table distributors. The following two examples are equivalent, the first using the table constraint syntax, the second the column constraint syntax:
CREATE TABLE distributors (
did integer,
name varchar(40),
PRIMARY KEY(did)
);
CREATE TABLE distributors (
did integer PRIMARY KEY,
name varchar(40)
);
Assign a literal constant default value for the column name, arrange for the default value of column did to be generated by selecting the next value of a sequence object, and make the default value of modtime be the time at which the row is inserted:
CREATE TABLE distributors (
name varchar(40) DEFAULT 'Luso Films',
did integer DEFAULT nextval('distributors_serial'),
modtime timestamp DEFAULT current_timestamp
);
Define two NOT NULL column constraints on the table distributors, one of which is explicitly given a name:
CREATE TABLE distributors (
did integer CONSTRAINT no_null NOT NULL,
name varchar(40) NOT NULL
);
Define a unique constraint for the name column:
CREATE TABLE distributors (
did integer,
name varchar(40) UNIQUE
);
The same, specified as a table constraint:
CREATE TABLE distributors (
did integer,
name varchar(40),
UNIQUE(name)
);
Create the same table, specifying 70% fill factor for both the table and its unique index:
CREATE TABLE distributors (
did integer,
name varchar(40),
UNIQUE(name) WITH (fillfactor=70)
)
WITH (fillfactor=70);
Create table circles with an exclusion constraint that prevents any two circles from overlapping:
CREATE TABLE circles (
c circle,
EXCLUDE USING gist (c WITH &&)
);
Create table cinemas in tablespace diskvol1:
CREATE TABLE cinemas (
id serial,
name text,
location text
) TABLESPACE diskvol1;
Create a composite type and a typed table:
CREATE TYPE employee_type AS (name text, salary numeric);
CREATE TABLE employees OF employee_type (
PRIMARY KEY (name),
salary WITH OPTIONS DEFAULT 1000
);
Create a range partitioned table:
CREATE TABLE measurement (
logdate date not null,
peaktemp int,
unitsales int
) PARTITION BY RANGE (logdate);
Create a range partitioned table with multiple columns in the partition key:
CREATE TABLE measurement_year_month (
logdate date not null,
peaktemp int,
unitsales int
) PARTITION BY RANGE (EXTRACT(YEAR FROM logdate), EXTRACT(MONTH FROM logdate));
Create a list partitioned table:
CREATE TABLE cities (
city_id bigserial not null,
name text not null,
population bigint
) PARTITION BY LIST (left(lower(name), 1));
Create a hash partitioned table:
CREATE TABLE orders (
order_id bigint not null,
cust_id bigint not null,
status text
) PARTITION BY HASH (order_id);
Create partition of a range partitioned table:
CREATE TABLE measurement_y2016m07
PARTITION OF measurement (
unitsales DEFAULT 0
) FOR VALUES FROM ('2016-07-01') TO ('2016-08-01');
Create a few partitions of a range partitioned table with multiple columns in the partition key:
CREATE TABLE measurement_ym_older
PARTITION OF measurement_year_month
FOR VALUES FROM (MINVALUE, MINVALUE) TO (2016, 11);
CREATE TABLE measurement_ym_y2016m11
PARTITION OF measurement_year_month
FOR VALUES FROM (2016, 11) TO (2016, 12);
CREATE TABLE measurement_ym_y2016m12
PARTITION OF measurement_year_month
FOR VALUES FROM (2016, 12) TO (2017, 01);
CREATE TABLE measurement_ym_y2017m01
PARTITION OF measurement_year_month
FOR VALUES FROM (2017, 01) TO (2017, 02);
Create partition of a list partitioned table:
CREATE TABLE cities_ab
PARTITION OF cities (
CONSTRAINT city_id_nonzero CHECK (city_id != 0)
) FOR VALUES IN ('a', 'b');
Create partition of a list partitioned table that is itself further partitioned and then add a partition to it:
CREATE TABLE cities_ab
PARTITION OF cities (
CONSTRAINT city_id_nonzero CHECK (city_id != 0)
) FOR VALUES IN ('a', 'b') PARTITION BY RANGE (population);
CREATE TABLE cities_ab_10000_to_100000
PARTITION OF cities_ab FOR VALUES FROM (10000) TO (100000);
Create partitions of a hash partitioned table:
CREATE TABLE orders_p1 PARTITION OF orders
FOR VALUES WITH (MODULUS 4, REMAINDER 0);
CREATE TABLE orders_p2 PARTITION OF orders
FOR VALUES WITH (MODULUS 4, REMAINDER 1);
CREATE TABLE orders_p3 PARTITION OF orders
FOR VALUES WITH (MODULUS 4, REMAINDER 2);
CREATE TABLE orders_p4 PARTITION OF orders
FOR VALUES WITH (MODULUS 4, REMAINDER 3);
Create a default partition:
CREATE TABLE cities_partdef
PARTITION OF cities DEFAULT;
Compatibility
The CREATE TABLE command conforms to the SQL standard, with exceptions listed below.
Temporary Tables
Although the syntax of CREATE TEMPORARY TABLE resembles that of the SQL standard, the effect is not the same. In the standard, temporary tables are defined just once and automatically exist (starting with empty contents) in every session that needs them. PostgreSQL instead requires each session to issue its own CREATE TEMPORARY TABLE command for each temporary table to be used. This allows different sessions to use the same temporary table name for different purposes, whereas the standard's approach constrains all instances of a given temporary table name to have the same table structure.
The standard's definition of the behavior of temporary tables is widely ignored. PostgreSQL's behavior on this point is similar to that of several other SQL databases.
The SQL standard also distinguishes between global and local temporary tables, where a local temporary table has a separate set of contents for each SQL module within each session, though its definition is still shared across sessions. Since PostgreSQL does not support SQL modules, this distinction is not relevant in PostgreSQL.
For compatibility's sake, PostgreSQL will accept the GLOBAL and LOCAL keywords in a temporary table declaration, but they currently have no effect. Use of these keywords is discouraged, since future versions of PostgreSQL might adopt a more standard-compliant interpretation of their meaning.
The ON COMMIT clause for temporary tables also resembles the SQL standard, but has some differences. If the ON COMMIT clause is omitted, SQL specifies that the default behavior is ON COMMIT DELETE ROWS. However, the default behavior in PostgreSQL is ON COMMIT PRESERVE ROWS. The ON COMMIT DROP option does not exist in SQL.
Non-Deferred Uniqueness Constraints
When a UNIQUE or PRIMARY KEY constraint is not deferrable, PostgreSQL checks for uniqueness immediately whenever a row is inserted or modified. The SQL standard says that uniqueness should be enforced only at the end of the statement; this makes a difference when, for example, a single command updates multiple key values. To obtain standard-compliant behavior, declare the constraint as DEFERRABLE but not deferred (i.e., INITIALLY IMMEDIATE). Be aware that this can be significantly slower than immediate uniqueness checking.
Column Check Constraints
The SQL standard says that CHECK column constraints can only refer to the column they apply to; only CHECK table constraints can refer to multiple columns. PostgreSQL does not enforce this restriction; it treats column and table check constraints alike.
EXCLUDE Constraint
The EXCLUDE constraint type is a PostgreSQL extension.
Foreign Key Constraints
The ability to specify column lists in the foreign key actions SET DEFAULT and SET NULL is a PostgreSQL extension.
It is a PostgreSQL extension that a foreign key constraint may reference columns of a unique index instead of columns of a primary key or unique constraint.
NULL “Constraint”
The NULL “constraint” (actually a non-constraint) is a PostgreSQL extension to the SQL standard that is included for compatibility with some other database systems (and for symmetry with the NOT NULL constraint). Since it is the default for any column, its presence is simply noise.
Constraint Naming
The SQL standard says that table and domain constraints must have names that are unique across the schema containing the table or domain. PostgreSQL is laxer: it only requires constraint names to be unique across the constraints attached to a particular table or domain. However, this extra freedom does not exist for index-based constraints (UNIQUE, PRIMARY KEY, and EXCLUDE constraints), because the associated index is named the same as the constraint, and index names must be unique across all relations within the same schema.
Inheritance
Multiple inheritance via the INHERITS clause is a PostgreSQL language extension. SQL:1999 and later define single inheritance using a different syntax and different semantics. SQL:1999-style inheritance is not yet supported by PostgreSQL.
Zero-Column Tables
PostgreSQL allows a table of no columns to be created (for example, CREATE TABLE foo();). This is an extension from the SQL standard, which does not allow zero-column tables. Zero-column tables are not in themselves very useful, but disallowing them creates odd special cases for ALTER TABLE DROP COLUMN, so it seems cleaner to ignore this spec restriction.
Multiple Identity Columns
PostgreSQL allows a table to have more than one identity column. The standard specifies that a table can have at most one identity column. This is relaxed mainly to give more flexibility for doing schema changes or migrations. Note that the INSERT command supports only one override clause that applies to the entire statement, so having multiple identity columns with different behaviors is not well supported.
Generated Columns
The options STORED and VIRTUAL are not standard but are also used by other SQL implementations. The SQL standard does not specify the storage of generated columns.
LIKE Clause
While a LIKE clause exists in the SQL standard, many of the options that PostgreSQL accepts for it are not in the standard, and some of the standard's options are not implemented by PostgreSQL.
WITH Clause
The WITH clause is a PostgreSQL extension; storage parameters are not in the standard.
Tablespaces
The PostgreSQL concept of tablespaces is not part of the standard. Hence, the clauses TABLESPACE and USING INDEX TABLESPACE are extensions.
Typed Tables
Typed tables implement a subset of the SQL standard. According to the standard, a typed table has columns corresponding to the underlying composite type as well as one other column that is the “self-referencing column”. PostgreSQL does not support self-referencing columns explicitly.
PARTITION BY Clause
The PARTITION BY clause is a PostgreSQL extension.
PARTITION OF Clause
The PARTITION OF clause is a PostgreSQL extension.