CREATE TABLE — 定義新表
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 [, ... ] ) ] }
CREATE TABLE 將在當前資料庫中建立一個新的、初始為空的表。該表將屬於發出命令的使用者。
如果給出了模式名稱（例如，CREATE TABLE myschema.mytable ...），則表將在指定的模式中建立。否則，它將在當前模式中建立。臨時表存在於一個特殊的模式中，因此在建立臨時表時不能給出模式名稱。表名必須與同一模式中的任何其他關係（表、序列、索引、檢視、物化檢視或外部表）的名稱不同。
CREATE TABLE 還會自動建立一個表示表一行對應的複合型別的型別。因此，表不能與同一模式中的任何現有資料型別具有相同的名稱。
可選的約束子句指定了約束（測試），新行或更新後的行必須滿足這些約束，才能使插入或更新操作成功。約束是 SQL 物件，它以各種方式幫助定義表中有效值的集合。
定義約束有兩種方式：表約束和列約束。列約束是作為列定義的一部分定義的。表約束定義不與特定列繫結，它可以包含多列。每個列約束也可以寫成表約束；列約束只是一個用於當約束僅影響一列時的符號方便。
要能夠建立表，您必須對所有列型別或 OF 子句中的型別分別具有 USAGE 許可權。
TEMPORARY 或 TEMP #如果指定，表將作為臨時表建立。臨時表將在會話結束時自動刪除，或者根據選擇在當前事務結束時刪除（參見下面的 ON COMMIT）。預設的 search_path 首先包含臨時模式，因此當臨時表存在時，除非使用帶模式限定的名稱引用，否則新計劃不會選擇同名現有永久表。在臨時表上建立的任何索引也會自動是臨時的。
自動清理守護程序無法訪問臨時表，因此也無法清理或分析臨時表。因此，應透過會話 SQL 命令執行適當的清理和分析操作。例如，如果一個臨時表將用於複雜查詢，那麼在填充臨時表之後執行 ANALYZE 是明智的。
可選地，可以在 TEMPORARY 或 TEMP 之前寫入 GLOBAL 或 LOCAL。這在 PostgreSQL 中目前沒有區別，並且已棄用；請參閱下面的 相容性。
UNLOGGED #如果指定，表將作為未記錄表建立。寫入未記錄表的資料不會寫入預寫日誌（請參閱 第 28 章），這使得它們比普通錶快得多。但是，它們不是崩潰安全的：在崩潰或非正常關機後，未記錄表會自動截斷。未記錄表的內容也不會複製到備用伺服器。在未記錄表上建立的任何索引也會自動是未記錄的。
如果指定了此項，與未記錄表一起建立的任何序列（用於標識或序列列）也將建立為未記錄。
此形式不支援分割槽表。
IF NOT EXISTS #如果具有相同名稱的關係已存在，則不丟擲錯誤。在這種情況下會發出通知。請注意，不能保證現有關係與將要建立的關係有任何相似之處。
table_name #要建立的表的名稱（可以選擇性地指定模式）。
OF type_name #建立一個型別化表，它從指定的獨立複合型別（即使用 CREATE TYPE 建立的型別）繼承結構，儘管它仍然會生成一個新的複合型別。該表將對引用的型別具有依賴性，這意味著該型別的級聯的 alter 和 drop 操作將傳播到該表。
型別化表始終具有與它派生的型別相同的列名和資料型別，因此您不能指定其他列。但是 CREATE TABLE 命令可以為表新增預設值和約束，以及指定儲存引數。
column_name #新表中要建立的列名。
data_type #列的資料型別。這可以包括陣列說明符。有關 PostgreSQL 支援的資料型別的更多資訊，請參閱 第 8 章。
COLLATE collation #COLLATE 子句為列分配排序規則（該列必須是可排序的資料型別）。如果未指定，則使用列資料型別的預設排序規則。
STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT } #此形式設定列的儲存模式。這控制該列是儲存在行內還是在輔助TOAST表中，以及資料是否應被壓縮。 PLAIN 必須用於固定長度的值，例如 integer，它是行內、未壓縮的。 MAIN 用於行內、可壓縮的資料。 EXTERNAL 用於外部、未壓縮的資料，而 EXTENDED 用於外部、壓縮的資料。寫入 DEFAULT 將儲存模式設定為列資料型別的預設模式。 EXTENDED 是大多數支援非 PLAIN 儲存的資料型別的預設值。使用 EXTERNAL 可以更快地處理非常大的 text 和 bytea 值的子字串操作，但會增加儲存空間。有關更多資訊，請參閱 第 66.2 節。
COMPRESSION compression_method #COMPRESSION 子句設定列的壓縮方法。壓縮僅支援可變寬度資料型別，並且僅在列的儲存模式為 main 或 extended 時使用。（有關列儲存模式的資訊，請參閱 ALTER TABLE。）對分割槽表設定此屬性沒有直接影響，因為這樣的表沒有自己的儲存，但配置的值將由新建立的分割槽繼承。支援的壓縮方法是 pglz 和 lz4。（只有在構建 PostgreSQL 時使用了 --with-lz4 選項時，lz4 才可用。）此外，compression_method 可以是 default 來明確指定預設行為，即在插入資料時查閱 default_toast_compression 設定來確定要使用的方法。
INHERITS ( parent_table [, ...] ) #可選的 INHERITS 子句指定了一個或多個表的列表，新表將自動從這些表中繼承所有列。父表可以是普通表或外部表。
使用 INHERITS 會在新的子表與其父表之間建立持久關係。父表的模式修改通常也會傳播到子表，並且預設情況下，子表的資料包含在父表的掃描中。
如果同一列名在多個父表中存在，除非各父表中的列資料型別匹配，否則會報告錯誤。如果沒有衝突，則重複的列將被合併成新表中的一個列。如果新表的列名列表包含一個與繼承的列同名的列，則資料型別也必須與繼承的列匹配，並且列定義將被合併成一個。如果新表顯式為該列指定了預設值，則此預設值將覆蓋繼承宣告中該列的任何預設值。否則，指定了該列預設值的任何父表都必須指定相同的預設值，否則將報告錯誤。
CHECK 約束的合併方式與列基本相同：如果多個父表和/或新表定義包含同名的 CHECK 約束，則所有這些約束必須具有相同的檢查表示式，否則將報告錯誤。具有相同名稱和表示式的約束將被合併成一個副本。在父表中標記為 NO INHERIT 的約束將不被考慮。請注意，新表中的無名 CHECK 約束永遠不會合並，因為總是會為其選擇一個唯一的名稱。
列 STORAGE 設定也從父表複製。
如果父表中的列是標識列，則該屬性不會被繼承。如果需要，子表中的列可以宣告為標識列。
PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [ opclass ] [, ...] ) #可選的 PARTITION BY 子句指定了表分割槽策略。因此建立的表稱為分割槽表。括號中的列或表示式列表構成了表分割槽鍵。在使用範圍或雜湊分割槽時，分割槽鍵可以包含多個列或表示式（最多 32 個，但此限制在構建 PostgreSQL 時可以更改），但對於列表分割槽，分割槽鍵必須由單個列或表示式組成。
範圍和列表分割槽需要 btree 運算子類，而雜湊分割槽需要雜湊運算子類。如果未顯式指定運算子類，將使用相應型別的預設運算子類；如果不存在預設運算子類，將引發錯誤。在使用雜湊分割槽時，使用的運算子類必須實現支援函式 2（有關詳細資訊，請參閱 第 36.16.3 節）。
分割槽表被劃分為子表（稱為分割槽），這些子表使用單獨的 CREATE TABLE 命令建立。分割槽表本身是空的。插入表中的資料行將根據分割槽鍵中的列或表示式的值路由到某個分割槽。如果沒有現有分割槽匹配新行中的值，將報告錯誤。
有關表分割槽的更多討論，請參閱 第 5.12 節。
PARTITION OF parent_table { FOR VALUES partition_bound_spec | DEFAULT } #將表建立為指定父表的分割槽。可以使用 FOR VALUES 為特定值建立表作為分割槽，或使用 DEFAULT 建立為預設分割槽。父表中存在的任何索引、約束和使用者定義的行級觸發器都會克隆到新分割槽。
partition_bound_spec 必須對應於父表的分割槽方法和分割槽鍵，並且不得與該父表的任何現有分割槽重疊。帶 IN 的形式用於列表分割槽，帶 FROM 和 TO 的形式用於範圍分割槽，帶 WITH 的形式用於雜湊分割槽。
partition_bound_expr 是任何無變數的表示式（不允許子查詢、視窗函式、聚合函式和集合返回函式）。其資料型別必須與相應分割槽鍵列的資料型別匹配。該表示式在表建立時求值一次，因此它甚至可以包含 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，以及 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）具有“無窮大”的概念，這只是另一個可以儲存的值。這與 MINVALUE 和 MAXVALUE 不同，它們不是可以儲存的實際值，而是表示值無界的說法。MAXVALUE 可以被認為是大於任何其他值（包括“無窮大”），而 MINVALUE 可以被認為是小於任何其他值（包括“負無窮大”）。因此，範圍 FROM ('infinity') TO (MAXVALUE) 不是空範圍；它允許精確儲存一個值——“無窮大”。
如果指定了 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 source_table [ like_option ... ] #LIKE 子句指定一個表，新表將自動從該表中複製所有列名、資料型別和非空約束。
與 INHERITS 不同，新表和原始表在建立完成後是完全解耦的。對原始表的更改不會應用於新表，並且不可能在原始表的掃描中包含新表的資料。
與 INHERITS 不同，透過 LIKE 複製的列和約束不會與同名的列和約束合併。如果顯式指定了相同的名稱或在另一個 LIKE 子句中指定，將發出錯誤。
可選的 like_option 子句指定要從原始表中複製哪些附加屬性。指定 INCLUDING 會複製屬性，指定 EXCLUDING 會忽略屬性。EXCLUDING 是預設的。如果對同一種物件進行了多個指定，則使用最後一個指定。可用的選項是
INCLUDING COMMENTS #複製的列、約束和索引的註釋將被複制。預設行為是排除註釋，導致新表中複製的列和約束沒有註釋。
INCLUDING COMPRESSION #列的壓縮方法將被複制。預設行為是排除壓縮方法，導致列具有預設的壓縮方法。
INCLUDING CONSTRAINTS #CHECK 約束將被複制。列約束和表約束之間不做區分。非空約束始終被複制到新表中。
INCLUDING DEFAULTS #複製的列定義的預設表示式將被複制。否則，預設表示式不被複制，導致新表中複製的列具有 null 預設值。請注意，複製呼叫資料庫修改函式的預設值（如 nextval）可能會在原始表和新表之間建立函式連結。
INCLUDING GENERATED #任何生成表示式以及複製的列定義的儲存/虛擬選擇都將被複制。預設情況下，新列將是常規的基數列。
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 constraint_name #列或表約束的可選名稱。如果違反約束，錯誤訊息中將包含約束名稱，因此可以使用 col must be positive 這樣的約束名稱向客戶端應用程式傳達有用的約束資訊。（需要雙引號才能指定包含空格的約束名稱。）如果未指定約束名稱，系統將生成一個名稱。
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 約束後，按名稱的字母順序對每一行進行測試。（PostgreSQL 9.5 之前的版本不遵循任何特定的 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，則只有當 INSERT 語句指定了 OVERRIDING SYSTEM VALUE 時，才接受使用者指定的值。如果選擇了 BY DEFAULT，則使用者指定的值優先。有關詳細資訊，請參見 INSERT。（在 COPY 命令中，無論此設定如何，始終使用使用者指定的值。）
在 UPDATE 命令中，如果選擇了 ALWAYS，則任何將該列更新為除 DEFAULT 以外的值都將被拒絕。如果選擇了 BY DEFAULT，則可以正常更新該列。（UPDATE 命令沒有 OVERRIDING 子句。）
可選的 序列選項 子句可用於覆蓋序列的引數。可用選項包括 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 擴充套件來使用其他型別（這是使用此功能的預期方式）。
就唯一約束而言，空值不被視為相等，除非指定了 NULLS NOT DISTINCT。
每個唯一約束應命名一組列，該組列應不同於為該表定義的任何其他唯一約束或主鍵約束所命名的列集。（否則，重複的唯一約束將被丟棄。）
在為多級分割槽層次結構建立唯一約束時，目標分割槽表及其所有後代分割槽表的分割槽鍵中的所有列都必須包含在約束定義中。
新增唯一約束將自動在該約束使用的列或列組上建立一個唯一的 btree 索引。但如果約束包含 WITHOUT OVERLAPS 子句，它將使用 GiST 索引。建立的索引與唯一約束具有相同的名稱。
可選的 INCLUDE 子句將一個或多個列新增到該索引中，這些列僅是“有效負載”：不強制對它們執行唯一性，並且無法基於這些列來搜尋索引。但是，它們可以透過僅索引掃描進行檢索。請注意，儘管不強制對包含的列執行約束，但它仍然依賴於它們。因此，對這些列的某些操作（例如 DROP COLUMN）可能會導致級聯約束和索引刪除。
PRIMARY KEY（列約束）PRIMARY KEY ( 列名 [, ... ] [, 列名 WITHOUT OVERLAPS ] ) [ INCLUDE ( 列名 [, ...]) ]（表約束） #PRIMARY KEY 約束指定表的一列或多列只能包含唯一（非重複）的非空值。對於一個表，無論是以列約束還是表約束的形式，都只能指定一個主鍵。
主鍵約束應命名一組列，該組列應不同於為同一表定義的任何唯一約束所命名的列集。（否則，唯一約束將是冗餘的並將被丟棄。）
PRIMARY KEY 強制執行與 UNIQUE 和 NOT NULL 的組合相同的 資料約束。但是，將一組列標識為主鍵還可以提供有關架構設計的元資料，因為主鍵意味著其他表可以依賴於這組列作為行的唯一識別符號。
當應用於分割槽表時，PRIMARY KEY 約束共享之前為 UNIQUE 約束描述的限制。
新增 PRIMARY KEY 約束將自動在該約束使用的列或列組上建立一個唯一的 btree 索引，如果指定了 WITHOUT OVERLAPS，則使用 GiST 索引。
可選的 INCLUDE 子句將一個或多個列新增到該索引中，這些列僅是“有效負載”：不強制對它們執行唯一性，並且無法基於這些列來搜尋索引。但是，它們可以透過僅索引掃描進行檢索。請注意，儘管不強制對包含的列執行約束，但它仍然依賴於它們。因此，對這些列的某些操作（例如 DROP COLUMN）可能會導致級聯約束和索引刪除。
EXCLUDE [ USING 索引方法 ] ( 排除元素 WITH 運算子 [, ... ] ) 索引引數 [ WHERE ( 謂詞 ) ] #EXCLUDE 子句定義了一個排斥約束，它保證如果在使用指定的運算子將任何兩行與指定的列（或表示式）進行比較時，並非所有這些比較都返回 TRUE。如果所有指定的運算子都測試相等性，那麼這等同於 UNIQUE 約束，儘管普通唯一約束會更快。但是，排斥約束可以指定比簡單相等性更通用的約束。例如，您可以使用 && 運算子指定一個約束，即表中沒有兩行包含重疊的圓（參見 第 8.8 節）。指定的運算子必須是可交換的。
排斥約束是透過與約束同名的索引實現的，因此每個指定的運算子都必須與索引訪問方法 索引方法 的適當運算元類（參見 第 11.10 節）相關聯。每個 排除元素 定義了一個索引列，因此它可以選擇性地指定排序規則、運算元類、運算元類引數和/或排序選項；這些在 CREATE INDEX 中有完整描述。
訪問方法必須支援 amgettuple（參見 第 63 章）；目前這意味著GIN不能使用。雖然允許使用 B-tree 或 hash 索引進行排斥約束，但這並不能做普通唯一約束做不到的任何事情。因此，實際上訪問方法將始終是GiST或SP-GiST.
謂詞 允許您為表的子集指定排斥約束；在內部，這會建立一個部分索引。請注意，謂詞周圍必須有括號。
為多級分割槽層次結構建立排斥約束時，目標分割槽表及其所有後代分割槽表的分割槽鍵中的所有列都必須包含在約束定義中。此外，這些列必須使用相等運算子進行比較。這些限制確保可能衝突的行將存在於同一分割槽中。該約束還可以引用不是任何分割槽鍵一部分的其他列，這些列可以使用任何適當的運算子進行比較。
REFERENCES 引用表 [ ( 引用列 ) ] [ MATCH 匹配型別 ] [ ON DELETE 引用操作 ] [ ON UPDATE 引用操作 ]（列約束）FOREIGN KEY ( 列名 [, ... ] [, PERIOD 列名 ] ) REFERENCES 引用表 [ ( 引用列 [, ... ] [, PERIOD 引用列 ] ) ] [ MATCH 匹配型別 ] [ ON DELETE 引用操作 ] [ ON UPDATE 引用操作 ]（表約束） #這些子句指定了外部索引鍵約束，該約束要求新表的一列或多列中的值必須匹配引用表中某行的引用列（或列）中的值。如果省略 引用列 列表，則使用 引用表 的主鍵。否則，引用列 列表必須引用非延遲唯一約束或主鍵約束的列，或者是一些非部分唯一索引的列。
如果最後一列標記為 PERIOD，則它被特殊處理。雖然非 PERIOD 列是按相等性比較的（並且至少必須有一個），但 PERIOD 列不是。相反，如果引用表具有匹配的記錄（基於鍵的非 PERIOD 部分），並且這些記錄的 PERIOD 值完全覆蓋了引用記錄的 PERIOD 值，則認為約束滿足。換句話說，引用必須在其整個持續時間內都有一個被引用項。此列必須是範圍或多範圍型別。此外，引用表必須具有使用 WITHOUT OVERLAPS 宣告的主鍵或唯一約束。最後，如果外部索引鍵具有 PERIOD 列名 規範，則相應的 引用列（如果存在）也必須標記為 PERIOD。如果省略 引用列 子句，從而選擇了引用表的PRIMARY KEY 約束，則 PRIMARY KEY 的最後一列必須標記為 WITHOUT OVERLAPS。
對於每一對引用列和被引用列，如果它們是可排序的資料型別，則它們的排序規則必須都是確定性的，或者兩者都相同。這確保了這兩列具有一致的相等性概念。
使用者必須對引用表具有 REFERENCES 許可權（可以是整個表，也可以是特定的引用列）。新增外部索引鍵約束需要對引用表進行 SHARE ROW EXCLUSIVE 鎖。請注意，外部索引鍵約束不能在臨時表和永久表之間定義。
插入到引用列（或列）中的值將使用指定的匹配型別與引用表和引用列的值進行匹配。有三種匹配型別：MATCH FULL、MATCH PARTIAL 和 MATCH SIMPLE（這是預設值）。MATCH FULL 不允許多列外部索引鍵的其中一列為 null，除非所有外部索引鍵列都為 null；如果它們都為 null，則不要求該行在引用表中具有匹配項。MATCH SIMPLE 允許外部索引鍵中的任何一列為 null；如果其中任何一列為 null，則不要求該行在引用表中具有匹配項。MATCH PARTIAL 尚未實現。（當然，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 約束不可延遲。請注意，在包含 ON CONFLICT DO UPDATE 子句的 INSERT 語句中，可延遲約束不能用作衝突仲裁者。
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 控制臨時表在事務塊結束時的行為。三個選項是：
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 表）的行為（有關 TOAST 的更多資訊，請參見 第 66.2 節）。如果設定了表引數值，而未設定等效的 toast. 引數，則 TOAST 表將使用表引數值。不支援為分割槽表指定這些引數，但您可以為單個葉子分割槽指定它們。
fillfactor（integer） #表的 fillfactor 是一個介於 10 和 100 之間的百分比。預設值為 100（完全打包）。當指定較小的 fillfactor 時，INSERT 操作僅將表頁填充到指示的百分比；每個頁上剩餘的空間用於更新該頁上的行。這使得 UPDATE 有機會將行的更新副本放置在與原始副本相同的頁面上，這比將其放置在不同頁面上更有效，並且使堆僅元組更新更有可能發生。對於從未更新的條目，完全打包是最佳選擇，但在大量更新的表中，較小的 fillfactor 是合適的。無法為 TOAST 表設定此引數。
toast_tuple_target（integer） #toast_tuple_target 指定在嘗試壓縮和/或將長列值移至 TOAST 表所需的最小元組長度，並且也是一旦開始分 toast 的目標長度。這會影響標記為 External（用於移動）、Main（用於壓縮）或 Extended（用於兩者）的列，並且僅適用於新元組。對現有行沒有影響。預設情況下，此引數設定為允許每個塊至少有 4 個元組，這將是 2040 位元組（預設塊大小）。有效值介於 128 位元組和（塊大小 - 頭部）之間，預設為 8160 位元組。更改此值對於非常短或非常長的行可能沒有用。請注意，預設設定通常接近最優，並且在這種情況下，設定此引數可能會產生負面影響。無法為 TOAST 表設定此引數。
parallel_workers（integer） #這設定了用於輔助並行掃描此表的 worker 數量。如果未設定，系統將根據關係大小確定一個值。計劃程式或使用並行掃描的實用程式語句實際選擇的 worker 數量可能會少一些，例如由於 max_worker_processes 的設定。
autovacuum_enabled, toast.autovacuum_enabled（boolean） #啟用或停用特定表的 autovacuum 守護程序。如果為 true，autovacuum 守護程序將按照 第 24.1.6 節 中討論的規則，對該表執行自動 VACUUM 和/或 ANALYZE 操作。如果為 false，此表將不會被 autovacuum，除非是為了防止事務 ID 溢位。有關溢位預防的更多資訊，請參見 第 24.1.5 節。請注意，如果 autovacuum 引數為 false，則 autovacuum 守護程序根本不會執行（除非是為了防止事務 ID 溢位）；設定單個表的儲存引數不會覆蓋該設定。因此，顯式將此儲存引數設定為 true 通常沒有多大意義，只應設定為 false。
vacuum_index_cleanup, toast.vacuum_index_cleanup（enum） #當在該表上執行 VACUUM 時，強制或停用索引清理。預設值為 AUTO。設定為 OFF 時，停用索引清理；設定為 ON 時，啟用索引清理；設定為 AUTO 時，每次執行 VACUUM 時都會動態決定。動態行為允許 VACUUM 避免不必要地掃描索引以刪除非常少的死元組。強制停用所有索引清理可以非常顯著地加快 VACUUM 的速度，但如果表修改頻繁，也可能導致索引嚴重膨脹。VACUUM 的 INDEX_CLEANUP 引數（如果指定）將覆蓋此選項的值。
vacuum_truncate, toast.vacuum_truncate (boolean) #每個表 vacuum_truncate 引數的值。如果指定了 VACUUM 的 TRUNCATE 引數，它將覆蓋此選項的值。
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) #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) #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) #Per-table value for vacuum_freeze_min_age parameter. Note that autovacuum will ignore per-table autovacuum_freeze_min_age parameters 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_age parameters that are larger than the system-wide setting (it can only be set smaller).
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) #Per-table value for vacuum_multixact_freeze_min_age parameter. Note that autovacuum will ignore per-table autovacuum_multixact_freeze_min_age parameters 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_age parameters 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) #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) #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.
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.)
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;
The CREATE TABLE command conforms to theSQLstandard, with exceptions listed below.
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.
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.
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 ConstraintThe EXCLUDE constraint type is a PostgreSQL extension.
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.
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.
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.
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.
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.
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 ClauseWhile 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 ClauseThe WITH clause is a PostgreSQL extension; storage parameters are not in the standard.
The PostgreSQL concept of tablespaces is not part of the standard. Hence, the clauses TABLESPACE and USING INDEX TABLESPACE are extensions.
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 ClauseThe PARTITION BY clause is a PostgreSQL extension.
PARTITION OF ClauseThe PARTITION OF clause is a PostgreSQL extension.
If you see anything in the documentation that is not correct, does not match your experience with the particular feature or requires further clarification, please use this form to report a documentation issue.