From fced921285371d5783d3a2fd8b9fa45f553115b7 Mon Sep 17 00:00:00 2001 From: amit Date: Mon, 22 Feb 2016 14:06:33 +0900 Subject: [PATCH 1/6] Add syntax to specify partition key. This adds the following clause to CREATE TABLE: PARTITION BY method (col [USING opclass] [, ...]) where 'method' is either RANGE or LIST. 'col' could be either a simple column reference or a parenthesized expression. 'opclass' is name of btree operator class to use with the column. If method is LIST, only one column is allowed, whereas, for RANGE method up to 32 columns can be specified. If this clause is specified, the following constraints viz. PARTITION KEY, UNIQUE, FOREIGN KEY, EXCLUSION are not allowed because they cannot be supported on partitioned tables. This adds 2 new parser nodes viz. PartitionElem and PartitionBy. The former is similar to IndexElem and the latter consists of details of partition key such as the method and list of PartitionElems. The new member partby of CreateStmt is a pointer to the PartitionBy struct created when PARTITION BY clause is present. --- doc/src/sgml/ref/create_table.sgml | 35 +++++ src/backend/commands/indexcmds.c | 4 +- src/backend/commands/tablecmds.c | 215 ++++++++++++++++++++++++++++ src/backend/nodes/copyfuncs.c | 33 +++++ src/backend/nodes/equalfuncs.c | 28 ++++ src/backend/nodes/outfuncs.c | 27 ++++ src/backend/parser/gram.y | 110 ++++++++++++--- src/backend/parser/parse_agg.c | 11 ++ src/backend/parser/parse_expr.c | 5 + src/backend/parser/parse_utilcmd.c | 63 ++++++++ src/include/commands/defrem.h | 2 + src/include/nodes/nodes.h | 2 + src/include/nodes/parsenodes.h | 35 +++++ src/include/parser/kwlist.h | 1 + src/include/parser/parse_node.h | 3 +- src/include/pg_config_manual.h | 5 + src/test/regress/expected/create_table.out | 79 ++++++++++ src/test/regress/sql/create_table.sql | 68 +++++++++ 18 files changed, 704 insertions(+), 22 deletions(-) diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml index d1807ed..70a7579 100644 --- a/doc/src/sgml/ref/create_table.sgml +++ b/doc/src/sgml/ref/create_table.sgml @@ -28,6 +28,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI [, ... ] ] ) [ INHERITS ( parent_table [, ... ] ) ] +[ PARTITION BY {RANGE | LIST} ( { column_name | ( expression ) } [ opclass ] [, ...] ) [ WITH ( storage_parameter [= value] [, ... ] ) | WITH OIDS | WITHOUT OIDS ] [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ] [ TABLESPACE tablespace_name ] @@ -38,6 +39,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI | table_constraint } [, ... ] ) ] +[ PARTITION BY {RANGE | LIST} ( { column_name | ( expression ) } [ opclass ] [, ...] ) [ WITH ( storage_parameter [= value] [, ... ] ) | WITH OIDS | WITHOUT OIDS ] [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ] [ TABLESPACE tablespace_name ] @@ -314,6 +316,39 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI + PARTITION BY {RANGE | LIST} ( { column_name | ( expression ) } [ opclass ] [, ...] ) + + + The optional PARTITION BY clause specifies a method of + partitioning the table and the corresponding partition key. Table + thus created is called partitioned table. Key + consists of an ordered list of column names and/or expressions when + using the RANGE method, whereas only a single column or + expression can be specified when using the LIST method. + The type of a key column or an expresion must have an associated + btree operator class or one must be specified along with the column + or the expression. + + + + A partitioned table is divided into sub-tables (called partitions), which + in turn, are created using separate CREATE TABLE commands. + The table itself is empty. A data row inserted into the table is mapped + to and stored in one of the partitions (if one exists) based on the + values of columns and/or expressions in the partition key and partition + rules associated with the partitions. + + + + Currently, there are following limitations on definition of partitioned + tables: one cannot specify any UNIQUE, PRIMARY KEY, EXCLUDE and/or + FOREIGN KEY constraints. + + + + + + LIKE source_table [ like_option ... ] diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c index d14d540..4ef6b80 100644 --- a/src/backend/commands/indexcmds.c +++ b/src/backend/commands/indexcmds.c @@ -69,8 +69,6 @@ static void ComputeIndexAttrs(IndexInfo *indexInfo, char *accessMethodName, Oid accessMethodId, bool amcanorder, bool isconstraint); -static Oid GetIndexOpClass(List *opclass, Oid attrType, - char *accessMethodName, Oid accessMethodId); static char *ChooseIndexName(const char *tabname, Oid namespaceId, List *colnames, List *exclusionOpNames, bool primary, bool isconstraint); @@ -1256,7 +1254,7 @@ ComputeIndexAttrs(IndexInfo *indexInfo, /* * Resolve possibly-defaulted operator class specification */ -static Oid +Oid GetIndexOpClass(List *opclass, Oid attrType, char *accessMethodName, Oid accessMethodId) { diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 86e9814..d03147d 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -433,6 +433,11 @@ static void RangeVarCallbackForDropRelation(const RangeVar *rel, Oid relOid, Oid oldRelOid, void *arg); static void RangeVarCallbackForAlterRelation(const RangeVar *rv, Oid relid, Oid oldrelid, void *arg); +static PartitionBy *transformPartitionBy(Relation rel, PartitionBy *partitionby); +static void ComputePartitionAttrs(Oid relid, List *partParams, + AttrNumber *partattrs, + List **partexprs, + Oid *partoplass); /* ---------------------------------------------------------------- @@ -710,6 +715,21 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, AddRelationNewConstraints(rel, rawDefaults, stmt->constraints, true, true, false); + /* Process partition key, if any */ + if (stmt->partby) + { + PartitionBy *partby; + int16 partnatts; + AttrNumber partattrs[PARTITION_MAX_KEYS]; + Oid partopclass[PARTITION_MAX_KEYS]; + List *partexprs = NIL; + + partnatts = list_length(stmt->partby->partParams); + partby = transformPartitionBy(rel, stmt->partby); + ComputePartitionAttrs(relationId, stmt->partby->partParams, + partattrs, &partexprs, partopclass); + } + ObjectAddressSet(address, RelationRelationId, relationId); /* @@ -12059,3 +12079,198 @@ RangeVarCallbackForAlterRelation(const RangeVar *rv, Oid relid, Oid oldrelid, ReleaseSysCache(tuple); } + +/* + * transformPartitionBy + * Transform any expressions present in the partition key + */ +static PartitionBy * +transformPartitionBy(Relation rel, PartitionBy *partitionby) +{ + PartitionBy *partby; + ParseState *pstate; + RangeTblEntry *rte; + ListCell *l; + + partby = (PartitionBy *) makeNode(PartitionBy); + + partby->strategy = partitionby->strategy; + partby->location = partitionby->location; + partby->partParams = NIL; + + /* + * Create a dummy ParseState and insert the target relation as its sole + * rangetable entry. We need a ParseState for transformExpr. + */ + pstate = make_parsestate(NULL); + rte = addRangeTableEntryForRelation(pstate, rel, NULL, false, true); + addRTEtoQuery(pstate, rte, true, true, true); + + /* take care of any partition expressions */ + foreach(l, partitionby->partParams) + { + ListCell *column; + PartitionElem *pelem = (PartitionElem *) lfirst(l); + + /* Check for PARTITION BY ... ON (foo, foo) */ + foreach(column, partby->partParams) + { + PartitionElem *pparam = (PartitionElem *) lfirst(column); + + if (pelem->name && pparam->name && + !strcmp(pelem->name, pparam->name)) + ereport(ERROR, + (errcode(ERRCODE_DUPLICATE_COLUMN), + errmsg("column \"%s\" appears twice in partition key", pelem->name), + parser_errposition(pstate, pelem->location))); + } + + if (pelem->expr) + { + /* Now do parse transformation of the expression */ + pelem->expr = transformExpr(pstate, pelem->expr, + EXPR_KIND_PARTITION_KEY); + + /* we have to fix its collations too */ + assign_expr_collations(pstate, pelem->expr); + + /* + * transformExpr() should have already rejected subqueries, + * aggregates, and window functions, based on the EXPR_KIND_ for + * a partition key expression. + * + * Also reject expressions returning sets; this is for consistency + * DefineRelation() will make more checks. + */ + if (expression_returns_set(pelem->expr)) + ereport(ERROR, + (errcode(ERRCODE_DATATYPE_MISMATCH), + errmsg("partition key expression cannot return a set"), + parser_errposition(pstate, pelem->location))); + } + + partby->partParams = lappend(partby->partParams, pelem); + } + + return partby; +} + +/* + * ComputePartitionAttrs + * Compute per-partition-column information from partParams + */ +static void +ComputePartitionAttrs(Oid relid, List *partParams, AttrNumber *partattrs, + List **partexprs, Oid *partopclass) +{ + int attn; + ListCell *lc; + + attn = 0; + foreach(lc, partParams) + { + PartitionElem *pelem = (PartitionElem *) lfirst(lc); + Oid atttype; + Oid opclassOid; + + if (pelem->name != NULL) + { + HeapTuple atttuple; + Form_pg_attribute attform; + + atttuple = SearchSysCacheAttName(relid, pelem->name); + if (!HeapTupleIsValid(atttuple)) + { + /* difference in error message spellings is historical */ + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_COLUMN), + errmsg("column \"%s\" named in partition key does not exist", + pelem->name))); + } + attform = (Form_pg_attribute) GETSTRUCT(atttuple); + + if (attform->attnum <= 0) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_COLUMN), + errmsg("cannot use system column \"%s\" in partition key", + pelem->name))); + + partattrs[attn] = attform->attnum; + atttype = attform->atttypid; + ReleaseSysCache(atttuple); + } + else + { + /* Partition key expression */ + Node *expr = pelem->expr; + + Assert(expr != NULL); + atttype = exprType(expr); + + if (IsA(expr, CollateExpr)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), + errmsg("cannot use COLLATE in partition key expression"))); + + if (IsA(expr, Var) && + ((Var *) expr)->varattno != InvalidAttrNumber) + { + /* + * User wrote "(column)" or "(column COLLATE something)". + * Treat it like simple attribute anyway. + */ + partattrs[attn] = ((Var *) expr)->varattno; + } + else + { + partattrs[attn] = 0; /* marks expression */ + *partexprs = lappend(*partexprs, expr); + + /* + * transformExpr() should have already rejected subqueries, + * aggregates, and window functions, based on the EXPR_KIND_ + * for a partition key expression. + */ + + /* + * An expression using mutable functions is probably wrong even + * even to use in a partition key + */ + expr = (Node *) expression_planner((Expr *) expr); + + if (IsA(expr, Const)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), + errmsg("cannot use a constant expression as partition key"))); + + if (contain_mutable_functions(expr)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), + errmsg("functions in partition key expression must be marked IMMUTABLE"))); + } + } + + /* + * Identify the opclass to use. At the moment, we use "btree" operators + * that seems enough for list and range partitioning. + */ + if (!pelem->opclass) + { + opclassOid = GetDefaultOpClass(atttype, BTREE_AM_OID); + + if (!OidIsValid(opclassOid)) + ereport(ERROR, + (errcode(ERRCODE_UNDEFINED_OBJECT), + errmsg("data type %s has no default btree operator class", + format_type_be(atttype)), + errhint("You must specify an existing btree operator class or define one for the type."))); + } + else + opclassOid = GetIndexOpClass(pelem->opclass, + atttype, + "btree", + BTREE_AM_OID); + + partopclass[attn++] = opclassOid; + } +} diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index 20e38f0..968a3f4 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -3001,6 +3001,7 @@ CopyCreateStmtFields(const CreateStmt *from, CreateStmt *newnode) COPY_NODE_FIELD(relation); COPY_NODE_FIELD(tableElts); COPY_NODE_FIELD(inhRelations); + COPY_NODE_FIELD(partby); COPY_NODE_FIELD(ofTypename); COPY_NODE_FIELD(constraints); COPY_NODE_FIELD(options); @@ -4156,6 +4157,32 @@ _copyAlterPolicyStmt(const AlterPolicyStmt *from) return newnode; } +static PartitionBy * +_copyPartitionBy(const PartitionBy *from) +{ + + PartitionBy *newnode = makeNode(PartitionBy); + + COPY_SCALAR_FIELD(strategy); + COPY_NODE_FIELD(partParams); + COPY_LOCATION_FIELD(location); + + return newnode; +} + +static PartitionElem * +_copyPartitionElem(const PartitionElem *from) +{ + PartitionElem *newnode = makeNode(PartitionElem); + + COPY_STRING_FIELD(name); + COPY_NODE_FIELD(expr); + COPY_NODE_FIELD(opclass); + COPY_LOCATION_FIELD(location); + + return newnode; +} + /* **************************************************************** * pg_list.h copy functions * **************************************************************** @@ -5049,6 +5076,12 @@ copyObject(const void *from) case T_RoleSpec: retval = _copyRoleSpec(from); break; + case T_PartitionBy: + retval = _copyPartitionBy(from); + break; + case T_PartitionElem: + retval = _copyPartitionElem(from); + break; default: elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from)); diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c index c5ccc42..56325fe 100644 --- a/src/backend/nodes/equalfuncs.c +++ b/src/backend/nodes/equalfuncs.c @@ -1156,6 +1156,7 @@ _equalCreateStmt(const CreateStmt *a, const CreateStmt *b) COMPARE_NODE_FIELD(relation); COMPARE_NODE_FIELD(tableElts); COMPARE_NODE_FIELD(inhRelations); + COMPARE_NODE_FIELD(partby); COMPARE_NODE_FIELD(ofTypename); COMPARE_NODE_FIELD(constraints); COMPARE_NODE_FIELD(options); @@ -2619,6 +2620,27 @@ _equalRoleSpec(const RoleSpec *a, const RoleSpec *b) return true; } +static bool +_equalPartitionBy(const PartitionBy *a, const PartitionBy *b) +{ + COMPARE_SCALAR_FIELD(strategy); + COMPARE_NODE_FIELD(partParams); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalPartitionElem(const PartitionElem *a, const PartitionElem *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_NODE_FIELD(expr); + COMPARE_NODE_FIELD(opclass); + COMPARE_LOCATION_FIELD(location); + + return true; +} + /* * Stuff from pg_list.h */ @@ -3369,6 +3391,12 @@ equal(const void *a, const void *b) case T_RoleSpec: retval = _equalRoleSpec(a, b); break; + case T_PartitionBy: + retval = _equalPartitionBy(a, b); + break; + case T_PartitionElem: + retval = _equalPartitionElem(a, b); + break; default: elog(ERROR, "unrecognized node type: %d", diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index c2f0e0f..5623471 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -2369,6 +2369,7 @@ _outCreateStmtInfo(StringInfo str, const CreateStmt *node) WRITE_NODE_FIELD(relation); WRITE_NODE_FIELD(tableElts); WRITE_NODE_FIELD(inhRelations); + WRITE_NODE_FIELD(partby); WRITE_NODE_FIELD(ofTypename); WRITE_NODE_FIELD(constraints); WRITE_NODE_FIELD(options); @@ -3217,6 +3218,26 @@ _outConstraint(StringInfo str, const Constraint *node) } } +static void +_outPartitionBy(StringInfo str, const PartitionBy *node) +{ + WRITE_NODE_TYPE("PARTITIONBY"); + + WRITE_CHAR_FIELD(strategy); + WRITE_NODE_FIELD(partParams); + WRITE_LOCATION_FIELD(location); +} + +static void +_outPartitionElem(StringInfo str, const PartitionElem *node) +{ + WRITE_NODE_TYPE("PARTITIONELEM"); + + WRITE_STRING_FIELD(name); + WRITE_NODE_FIELD(expr); + WRITE_NODE_FIELD(opclass); + WRITE_LOCATION_FIELD(location); +} /* * outNode - @@ -3796,6 +3817,12 @@ outNode(StringInfo str, const void *obj) case T_XmlSerialize: _outXmlSerialize(str, obj); break; + case T_PartitionBy: + _outPartitionBy(str, obj); + break; + case T_PartitionElem: + _outPartitionElem(str, obj); + break; default: diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index 18ec5f0..0607439 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -227,6 +227,8 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query); struct ImportQual *importqual; InsertStmt *istmt; VariableSetStmt *vsetstmt; + PartitionElem *partelem; + PartitionBy *partby; } %type stmt schema_stmt @@ -539,6 +541,9 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query); opt_frame_clause frame_extent frame_bound %type opt_existing_window_name %type opt_if_not_exists +%type PartitionBy OptPartitionBy +%type part_elem +%type part_params /* * Non-keyword token types. These are hard-wired into the "flex" lexer. @@ -603,7 +608,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query); KEY LABEL LANGUAGE LARGE_P LAST_P LATERAL_P - LEADING LEAKPROOF LEAST LEFT LEVEL LIKE LIMIT LISTEN LOAD LOCAL + LEADING LEAKPROOF LEAST LEFT LEVEL LIKE LIMIT LIST LISTEN LOAD LOCAL LOCALTIME LOCALTIMESTAMP LOCATION LOCK_P LOCKED LOGGED MAPPING MATCH MATERIALIZED MAXVALUE METHOD MINUTE_P MINVALUE MODE MONTH_P MOVE @@ -2808,69 +2813,75 @@ copy_generic_opt_arg_list_item: *****************************************************************************/ CreateStmt: CREATE OptTemp TABLE qualified_name '(' OptTableElementList ')' - OptInherit OptWith OnCommitOption OptTableSpace + OptInherit OptPartitionBy OptWith OnCommitOption OptTableSpace { CreateStmt *n = makeNode(CreateStmt); $4->relpersistence = $2; n->relation = $4; n->tableElts = $6; n->inhRelations = $8; + n->partby = $9; n->ofTypename = NULL; n->constraints = NIL; - n->options = $9; - n->oncommit = $10; - n->tablespacename = $11; + n->options = $10; + n->oncommit = $11; + n->tablespacename = $12; n->if_not_exists = false; $$ = (Node *)n; } | CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name '(' - OptTableElementList ')' OptInherit OptWith OnCommitOption - OptTableSpace + OptTableElementList ')' OptInherit OptPartitionBy OptWith + OnCommitOption OptTableSpace { CreateStmt *n = makeNode(CreateStmt); $7->relpersistence = $2; n->relation = $7; n->tableElts = $9; n->inhRelations = $11; + n->partby = $12; n->ofTypename = NULL; n->constraints = NIL; - n->options = $12; - n->oncommit = $13; - n->tablespacename = $14; + n->options = $13; + n->oncommit = $14; + n->tablespacename = $15; n->if_not_exists = true; $$ = (Node *)n; } | CREATE OptTemp TABLE qualified_name OF any_name - OptTypedTableElementList OptWith OnCommitOption OptTableSpace + OptTypedTableElementList OptPartitionBy OptWith OnCommitOption + OptTableSpace { CreateStmt *n = makeNode(CreateStmt); $4->relpersistence = $2; n->relation = $4; n->tableElts = $7; n->inhRelations = NIL; + n->partby = $8; n->ofTypename = makeTypeNameFromNameList($6); n->ofTypename->location = @6; n->constraints = NIL; - n->options = $8; - n->oncommit = $9; - n->tablespacename = $10; + n->options = $9; + n->oncommit = $10; + n->tablespacename = $11; n->if_not_exists = false; $$ = (Node *)n; } | CREATE OptTemp TABLE IF_P NOT EXISTS qualified_name OF any_name - OptTypedTableElementList OptWith OnCommitOption OptTableSpace + OptTypedTableElementList OptPartitionBy OptWith OnCommitOption + OptTableSpace { CreateStmt *n = makeNode(CreateStmt); $7->relpersistence = $2; n->relation = $7; n->tableElts = $10; n->inhRelations = NIL; + n->partby = $11; n->ofTypename = makeTypeNameFromNameList($9); n->ofTypename->location = @9; n->constraints = NIL; - n->options = $11; - n->oncommit = $12; - n->tablespacename = $13; + n->options = $12; + n->oncommit = $13; + n->tablespacename = $14; n->if_not_exists = true; $$ = (Node *)n; } @@ -3415,6 +3426,68 @@ OptInherit: INHERITS '(' qualified_name_list ')' { $$ = $3; } | /*EMPTY*/ { $$ = NIL; } ; +/* Optional partition key definition */ +OptPartitionBy: PartitionBy { $$ = $1; } + | /*EMPTY*/ { $$ = NULL; } + ; + +PartitionBy: PARTITION BY RANGE '(' part_params ')' + { + PartitionBy *n = makeNode(PartitionBy); + + n->strategy = PARTITION_STRAT_RANGE; + n->partParams = $5; + n->location = @1; + + $$ = n; + } + | PARTITION BY LIST '(' part_params ')' + { + PartitionBy *n = makeNode(PartitionBy); + + n->strategy = PARTITION_STRAT_LIST; + n->partParams = $5; + n->location = @1; + + $$ = n; + } + ; + +part_params: part_elem { $$ = list_make1($1); } + | part_params ',' part_elem { $$ = lappend($1, $3); } + ; + +part_elem: ColId opt_class + { + PartitionElem *n = makeNode(PartitionElem); + + n->name = $1; + n->expr = NULL; + n->opclass = $2; + n->location = @1; + $$ = n; + } + | func_expr_windowless opt_class + { + PartitionElem *n = makeNode(PartitionElem); + + n->name = NULL; + n->expr = $1; + n->opclass = $2; + n->location = @1; + $$ = n; + } + | '(' a_expr ')' opt_class + { + PartitionElem *n = makeNode(PartitionElem); + + n->name = NULL; + n->expr = $2; + n->opclass = $4; + n->location = @1; + $$ = n; + } + ; /* WITH (options) is preferred, WITH OIDS and WITHOUT OIDS are legacy forms */ OptWith: WITH reloptions { $$ = $2; } @@ -13839,6 +13912,7 @@ unreserved_keyword: | LAST_P | LEAKPROOF | LEVEL + | LIST | LISTEN | LOAD | LOCAL diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c index 91bfe66..b56fd4f 100644 --- a/src/backend/parser/parse_agg.c +++ b/src/backend/parser/parse_agg.c @@ -486,6 +486,14 @@ check_agglevels_and_constraints(ParseState *pstate, Node *expr) err = _("grouping operations are not allowed in trigger WHEN conditions"); break; + case EXPR_KIND_PARTITION_KEY: + if (isAgg) + err = _("aggregate functions are not allowed in partition key expressions"); + else + err = _("grouping operations are not allowed in partition key expressions"); + + break; + /* * There is intentionally no default: case here, so that the @@ -843,6 +851,9 @@ transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc, case EXPR_KIND_TRIGGER_WHEN: err = _("window functions are not allowed in trigger WHEN conditions"); break; + case EXPR_KIND_PARTITION_KEY: + err = _("window functions are not allowed in partition key expressions"); + break; /* * There is intentionally no default: case here, so that the diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c index 8b28516..b53b7f1 100644 --- a/src/backend/parser/parse_expr.c +++ b/src/backend/parser/parse_expr.c @@ -1723,6 +1723,9 @@ transformSubLink(ParseState *pstate, SubLink *sublink) case EXPR_KIND_TRIGGER_WHEN: err = _("cannot use subquery in trigger WHEN condition"); break; + case EXPR_KIND_PARTITION_KEY: + err = _("cannot use subquery in partition key expressions"); + break; /* * There is intentionally no default: case here, so that the @@ -3249,6 +3252,8 @@ ParseExprKindName(ParseExprKind exprKind) return "EXECUTE"; case EXPR_KIND_TRIGGER_WHEN: return "WHEN"; + case EXPR_KIND_PARTITION_KEY: + return "partition key expression"; /* * There is intentionally no default: case here, so that the diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c index 6528494..e267f74 100644 --- a/src/backend/parser/parse_utilcmd.c +++ b/src/backend/parser/parse_utilcmd.c @@ -87,6 +87,7 @@ typedef struct List *alist; /* "after list" of things to do after creating * the table */ IndexStmt *pkey; /* PRIMARY KEY index, if any */ + bool ispartitioned; /* true if table is partitioned */ } CreateStmtContext; /* State shared by transformCreateSchemaStmt and its subroutines */ @@ -229,6 +230,7 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString) cxt.blist = NIL; cxt.alist = NIL; cxt.pkey = NULL; + cxt.ispartitioned = stmt->partby != NULL; /* * Notice that we allow OIDs here only for plain tables, even though @@ -247,6 +249,24 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString) if (stmt->ofTypename) transformOfType(&cxt, stmt->ofTypename); + if (stmt->partby) + { + int partnatts = list_length(stmt->partby->partParams); + + if (partnatts > PARTITION_MAX_KEYS) + ereport(ERROR, + (errcode(ERRCODE_TOO_MANY_COLUMNS), + errmsg("cannot use more than %d columns in partition key", + PARTITION_MAX_KEYS))); + + if (stmt->partby->strategy == PARTITION_STRAT_LIST && + partnatts > 1) + ereport(ERROR, + (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), + errmsg("cannot use more than one column in partition key"), + errdetail("Only one column allowed with list partitioning."))); + } + /* * Run through each primary element in the table creation clause. Separate * column defs from constraints, and do preliminary analysis. We have to @@ -582,6 +602,12 @@ transformColumnDefinition(CreateStmtContext *cxt, ColumnDef *column) errmsg("primary key constraints are not supported on foreign tables"), parser_errposition(cxt->pstate, constraint->location))); + if (cxt->ispartitioned) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("primary key constraints are not supported on partitioned tables"), + parser_errposition(cxt->pstate, + constraint->location))); /* FALL THRU */ case CONSTR_UNIQUE: @@ -591,6 +617,12 @@ transformColumnDefinition(CreateStmtContext *cxt, ColumnDef *column) errmsg("unique constraints are not supported on foreign tables"), parser_errposition(cxt->pstate, constraint->location))); + if (cxt->ispartitioned) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("unique constraints are not supported on partitioned tables"), + parser_errposition(cxt->pstate, + constraint->location))); if (constraint->keys == NIL) constraint->keys = list_make1(makeString(column->colname)); cxt->ixconstraints = lappend(cxt->ixconstraints, constraint); @@ -608,6 +640,12 @@ transformColumnDefinition(CreateStmtContext *cxt, ColumnDef *column) errmsg("foreign key constraints are not supported on foreign tables"), parser_errposition(cxt->pstate, constraint->location))); + if (cxt->ispartitioned) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("foreign key constraints are not supported on partitioned tables"), + parser_errposition(cxt->pstate, + constraint->location))); /* * Fill in the current attribute's name and throw it into the @@ -673,6 +711,12 @@ transformTableConstraint(CreateStmtContext *cxt, Constraint *constraint) errmsg("primary key constraints are not supported on foreign tables"), parser_errposition(cxt->pstate, constraint->location))); + if (cxt->ispartitioned) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("primary key constraints are not supported on partitioned tables"), + parser_errposition(cxt->pstate, + constraint->location))); cxt->ixconstraints = lappend(cxt->ixconstraints, constraint); break; @@ -683,6 +727,12 @@ transformTableConstraint(CreateStmtContext *cxt, Constraint *constraint) errmsg("unique constraints are not supported on foreign tables"), parser_errposition(cxt->pstate, constraint->location))); + if (cxt->ispartitioned) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("unique constraints are not supported on partitioned tables"), + parser_errposition(cxt->pstate, + constraint->location))); cxt->ixconstraints = lappend(cxt->ixconstraints, constraint); break; @@ -693,6 +743,12 @@ transformTableConstraint(CreateStmtContext *cxt, Constraint *constraint) errmsg("exclusion constraints are not supported on foreign tables"), parser_errposition(cxt->pstate, constraint->location))); + if (cxt->ispartitioned) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("exclusion constraints are not supported on partitioned tables"), + parser_errposition(cxt->pstate, + constraint->location))); cxt->ixconstraints = lappend(cxt->ixconstraints, constraint); break; @@ -707,6 +763,12 @@ transformTableConstraint(CreateStmtContext *cxt, Constraint *constraint) errmsg("foreign key constraints are not supported on foreign tables"), parser_errposition(cxt->pstate, constraint->location))); + if (cxt->ispartitioned) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("foreign key constraints are not supported on partitioned tables"), + parser_errposition(cxt->pstate, + constraint->location))); cxt->fkconstraints = lappend(cxt->fkconstraints, constraint); break; @@ -2515,6 +2577,7 @@ transformAlterTableStmt(Oid relid, AlterTableStmt *stmt, cxt.blist = NIL; cxt.alist = NIL; cxt.pkey = NULL; + cxt.ispartitioned = false; /* * The only subtypes that currently require parse transformation handling diff --git a/src/include/commands/defrem.h b/src/include/commands/defrem.h index b064eb4..28024f8 100644 --- a/src/include/commands/defrem.h +++ b/src/include/commands/defrem.h @@ -42,6 +42,8 @@ extern bool CheckIndexCompatible(Oid oldId, List *attributeList, List *exclusionOpNames); extern Oid GetDefaultOpClass(Oid type_id, Oid am_id); +extern Oid GetIndexOpClass(List *opclass, Oid attrType, + char *accessMethodName, Oid accessMethodId); /* commands/functioncmds.c */ extern ObjectAddress CreateFunction(CreateFunctionStmt *stmt, const char *queryString); diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h index ea65f2e..9e582a5 100644 --- a/src/include/nodes/nodes.h +++ b/src/include/nodes/nodes.h @@ -452,6 +452,8 @@ typedef enum NodeTag T_OnConflictClause, T_CommonTableExpr, T_RoleSpec, + T_PartitionElem, + T_PartitionBy, /* * TAGS FOR REPLICATION GRAMMAR PARSE NODES (replnodes.h) diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h index 714cf15..4f697b8 100644 --- a/src/include/nodes/parsenodes.h +++ b/src/include/nodes/parsenodes.h @@ -696,6 +696,40 @@ typedef struct XmlSerialize int location; /* token location, or -1 if unknown */ } XmlSerialize; +/* Partitioning related definitions */ + +/* + * PartitionElem - a partition key column + * + * 'name' Name of the table column included in the key + * 'expr' Expression node tree of expressional key column + * 'opclass' Operator class name associated with the column + */ +typedef struct PartitionElem +{ + NodeTag type; + char *name; /* name of column to partition on, or NULL */ + Node *expr; /* expression to partition on, or NULL */ + List *opclass; /* name of desired opclass; NIL = default */ + int location; /* token location, or -1 if unknown */ +} PartitionElem; + +/* + * PartitionBy - partition key definition including the strategy + * + * 'strategy' partition strategy to use (one of the below defined) + * 'partParams' List of PartitionElems, one for each key column + */ +#define PARTITION_STRAT_LIST 'l' +#define PARTITION_STRAT_RANGE 'r' + +typedef struct PartitionBy +{ + NodeTag type; + char strategy; + List *partParams; + int location; /* token location, or -1 if unknown */ +} PartitionBy; /**************************************************************************** * Nodes for a Query tree @@ -1750,6 +1784,7 @@ typedef struct CreateStmt List *tableElts; /* column definitions (list of ColumnDef) */ List *inhRelations; /* relations to inherit from (list of * inhRelation) */ + PartitionBy *partby; /* PARTITION BY clause */ TypeName *ofTypename; /* OF typename */ List *constraints; /* constraints (list of Constraint nodes) */ List *options; /* options from WITH clause */ diff --git a/src/include/parser/kwlist.h b/src/include/parser/kwlist.h index 17ffef5..40da67a 100644 --- a/src/include/parser/kwlist.h +++ b/src/include/parser/kwlist.h @@ -227,6 +227,7 @@ PG_KEYWORD("left", LEFT, TYPE_FUNC_NAME_KEYWORD) PG_KEYWORD("level", LEVEL, UNRESERVED_KEYWORD) PG_KEYWORD("like", LIKE, TYPE_FUNC_NAME_KEYWORD) PG_KEYWORD("limit", LIMIT, RESERVED_KEYWORD) +PG_KEYWORD("list", LIST, UNRESERVED_KEYWORD) PG_KEYWORD("listen", LISTEN, UNRESERVED_KEYWORD) PG_KEYWORD("load", LOAD, UNRESERVED_KEYWORD) PG_KEYWORD("local", LOCAL, UNRESERVED_KEYWORD) diff --git a/src/include/parser/parse_node.h b/src/include/parser/parse_node.h index e3e359c..a13c6fb 100644 --- a/src/include/parser/parse_node.h +++ b/src/include/parser/parse_node.h @@ -64,7 +64,8 @@ typedef enum ParseExprKind EXPR_KIND_ALTER_COL_TRANSFORM, /* transform expr in ALTER COLUMN TYPE */ EXPR_KIND_EXECUTE_PARAMETER, /* parameter value in EXECUTE */ EXPR_KIND_TRIGGER_WHEN, /* WHEN condition in CREATE TRIGGER */ - EXPR_KIND_POLICY /* USING or WITH CHECK expr in policy */ + EXPR_KIND_POLICY, /* USING or WITH CHECK expr in policy */ + EXPR_KIND_PARTITION_KEY /* partition key expression */ } ParseExprKind; diff --git a/src/include/pg_config_manual.h b/src/include/pg_config_manual.h index 8d5a378..850251b 100644 --- a/src/include/pg_config_manual.h +++ b/src/include/pg_config_manual.h @@ -46,6 +46,11 @@ #define INDEX_MAX_KEYS 32 /* + * Maximum number of columns in a partition key + */ +#define PARTITION_MAX_KEYS 32 + +/* * Set the upper and lower bounds of sequence values. */ #define SEQ_MAXVALUE PG_INT64_MAX diff --git a/src/test/regress/expected/create_table.out b/src/test/regress/expected/create_table.out index 41ceb87..aaae9f9 100644 --- a/src/test/regress/expected/create_table.out +++ b/src/test/regress/expected/create_table.out @@ -253,3 +253,82 @@ DROP TABLE as_select1; -- check that the oid column is added before the primary key is checked CREATE TABLE oid_pk (f1 INT, PRIMARY KEY(oid)) WITH OIDS; DROP TABLE oid_pk; +-- +-- partitioned tables +-- +-- cannot use system columns in partition key +CREATE TABLE fail_oid_pk ( + a int +) PARTITION BY RANGE (oid) WITH OIDS; -- fail +ERROR: cannot use system column "oid" in partition key +-- cannot use more than 1 column as partition key for list partitioned table +CREATE TABLE two_col_tab ( + a1 int, + a2 int +) PARTITION BY LIST (a1, a2); -- fail +ERROR: cannot use more than one column in partition key +DETAIL: Only one column allowed with list partitioning. +-- cannot use more than 32 columns as partition key for range partitioned table +CREATE TABLE wide_tab ( + a01 int, a02 int, a03 int, a04 int, a05 int, a06 int, a07 int, a08 int, + a09 int, a10 int, a11 int, a12 int, a13 int, a14 int, a15 int, a16 int, + a17 int, a18 int, a19 int, a20 int, a21 int, a22 int, a23 int, a24 int, + a25 int, a26 int, a27 int, a28 int, a29 int, a30 int, a31 int, a32 int, + a33 int +) PARTITION BY RANGE (a01, a02, a03, a04, a05, a06, a07, a08, + a09, a10, a11, a12, a13, a14, a15, a16, + a17, a18, a19, a20, a21, a22, a23, a24, + a25, a26, a27, a28, a29, a30, a31, a32, a33); -- fail +ERROR: cannot use more than 32 columns in partition key +-- Partitioning requires to use columns with data type having a suitable +-- btree operator class +CREATE TABLE point_tab ( + a point +) PARTITION BY LIST (a); -- fail +ERROR: data type point has no default btree operator class +HINT: You must specify an existing btree operator class or define one for the type. +CREATE TABLE point_tab ( + a point +) PARTITION BY LIST (a USING point_ops); -- fail +ERROR: operator class "point_ops" does not exist for access method "btree" +CREATE TABLE point_tab ( + a point +) PARTITION BY RANGE (a); -- fail +ERROR: data type point has no default btree operator class +HINT: You must specify an existing btree operator class or define one for the type. +CREATE TABLE point_tab ( + a point +) PARTITION BY RANGE (a USING point_ops); -- fail +ERROR: operator class "point_ops" does not exist for access method "btree" +-- fail to create a partitioned table with PRIMARY KEY constraint +CREATE TABLE pk_fail ( + a int PRIMARY KEY +) PARTITION BY RANGE (a); +ERROR: primary key constraints are not supported on partitioned tables +LINE 2: a int PRIMARY KEY + ^ +-- fail to create a partitioned table with foreign key constraint +CREATE TABLE pk_rel( + a int PRIMARY KEY +); +CREATE TABLE fk_fail ( + a int REFERENCES pk_rel(a) +) PARTITION BY RANGE (a); +ERROR: foreign key constraints are not supported on partitioned tables +LINE 2: a int REFERENCES pk_rel(a) + ^ +DROP TABLE pk_rel; +-- fail to create a partitioned table with prohibited expressions in key +CREATE TABLE fail_const_key ( + a int +) PARTITION BY RANGE (('a')); +ERROR: cannot use a constant expression as partition key +CREATE TABLE fail_agg_in_key ( + a int +) PARTITION BY RANGE ((avg(a))); +ERROR: aggregate functions are not allowed in partition key expressions +CREATE TABLE fail_window_fun_in_key ( + a int, + b int +) PARTITION BY RANGE ((avg(a) OVER (PARTITION BY b))); +ERROR: window functions are not allowed in partition key expressions diff --git a/src/test/regress/sql/create_table.sql b/src/test/regress/sql/create_table.sql index 78bdc8b..df47656 100644 --- a/src/test/regress/sql/create_table.sql +++ b/src/test/regress/sql/create_table.sql @@ -269,3 +269,71 @@ DROP TABLE as_select1; -- check that the oid column is added before the primary key is checked CREATE TABLE oid_pk (f1 INT, PRIMARY KEY(oid)) WITH OIDS; DROP TABLE oid_pk; + +-- +-- partitioned tables +-- + +-- cannot use system columns in partition key +CREATE TABLE fail_oid_pk ( + a int +) PARTITION BY RANGE (oid) WITH OIDS; -- fail + +-- cannot use more than 1 column as partition key for list partitioned table +CREATE TABLE two_col_tab ( + a1 int, + a2 int +) PARTITION BY LIST (a1, a2); -- fail + +-- cannot use more than 32 columns as partition key for range partitioned table +CREATE TABLE wide_tab ( + a01 int, a02 int, a03 int, a04 int, a05 int, a06 int, a07 int, a08 int, + a09 int, a10 int, a11 int, a12 int, a13 int, a14 int, a15 int, a16 int, + a17 int, a18 int, a19 int, a20 int, a21 int, a22 int, a23 int, a24 int, + a25 int, a26 int, a27 int, a28 int, a29 int, a30 int, a31 int, a32 int, + a33 int +) PARTITION BY RANGE (a01, a02, a03, a04, a05, a06, a07, a08, + a09, a10, a11, a12, a13, a14, a15, a16, + a17, a18, a19, a20, a21, a22, a23, a24, + a25, a26, a27, a28, a29, a30, a31, a32, a33); -- fail + +-- Partitioning requires to use columns with data type having a suitable +-- btree operator class +CREATE TABLE point_tab ( + a point +) PARTITION BY LIST (a); -- fail +CREATE TABLE point_tab ( + a point +) PARTITION BY LIST (a USING point_ops); -- fail +CREATE TABLE point_tab ( + a point +) PARTITION BY RANGE (a); -- fail +CREATE TABLE point_tab ( + a point +) PARTITION BY RANGE (a USING point_ops); -- fail + +-- fail to create a partitioned table with PRIMARY KEY constraint +CREATE TABLE pk_fail ( + a int PRIMARY KEY +) PARTITION BY RANGE (a); + +-- fail to create a partitioned table with foreign key constraint +CREATE TABLE pk_rel( + a int PRIMARY KEY +); +CREATE TABLE fk_fail ( + a int REFERENCES pk_rel(a) +) PARTITION BY RANGE (a); +DROP TABLE pk_rel; + +-- fail to create a partitioned table with prohibited expressions in key +CREATE TABLE fail_const_key ( + a int +) PARTITION BY RANGE (('a')); +CREATE TABLE fail_agg_in_key ( + a int +) PARTITION BY RANGE ((avg(a))); +CREATE TABLE fail_window_fun_in_key ( + a int, + b int +) PARTITION BY RANGE ((avg(a) OVER (PARTITION BY b))); -- 1.7.1