1 /*------------------------------------------------------------------------- 2 * 3 * parse_target.c 4 * handle target lists 5 * 6 * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group 7 * Portions Copyright (c) 1994, Regents of the University of California 8 * 9 * 10 * IDENTIFICATION 11 * src/backend/parser/parse_target.c 12 * 13 *------------------------------------------------------------------------- 14 */ 15 #include "postgres.h" 16 17 #include "catalog/pg_type.h" 18 #include "commands/dbcommands.h" 19 #include "funcapi.h" 20 #include "miscadmin.h" 21 #include "nodes/makefuncs.h" 22 #include "nodes/nodeFuncs.h" 23 #include "parser/parsetree.h" 24 #include "parser/parse_coerce.h" 25 #include "parser/parse_expr.h" 26 #include "parser/parse_func.h" 27 #include "parser/parse_relation.h" 28 #include "parser/parse_target.h" 29 #include "parser/parse_type.h" 30 #include "utils/builtins.h" 31 #include "utils/lsyscache.h" 32 #include "utils/rel.h" 33 #include "utils/typcache.h" 34 35 36 static void markTargetListOrigin(ParseState *pstate, TargetEntry *tle, 37 Var *var, int levelsup); 38 static Node *transformAssignmentIndirection(ParseState *pstate, 39 Node *basenode, 40 const char *targetName, 41 bool targetIsSubscripting, 42 Oid targetTypeId, 43 int32 targetTypMod, 44 Oid targetCollation, 45 ListCell *indirection, 46 Node *rhs, 47 int location); 48 static Node *transformAssignmentSubscripts(ParseState *pstate, 49 Node *basenode, 50 const char *targetName, 51 Oid targetTypeId, 52 int32 targetTypMod, 53 Oid targetCollation, 54 List *subscripts, 55 bool isSlice, 56 ListCell *next_indirection, 57 Node *rhs, 58 int location); 59 static List *ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref, 60 bool make_target_entry); 61 static List *ExpandAllTables(ParseState *pstate, int location); 62 static List *ExpandIndirectionStar(ParseState *pstate, A_Indirection *ind, 63 bool make_target_entry, ParseExprKind exprKind); 64 static List *ExpandSingleTable(ParseState *pstate, RangeTblEntry *rte, 65 int location, bool make_target_entry); 66 static List *ExpandRowReference(ParseState *pstate, Node *expr, 67 bool make_target_entry); 68 static int FigureColnameInternal(Node *node, char **name); 69 70 71 /* 72 * transformTargetEntry() 73 * Transform any ordinary "expression-type" node into a targetlist entry. 74 * This is exported so that parse_clause.c can generate targetlist entries 75 * for ORDER/GROUP BY items that are not already in the targetlist. 76 * 77 * node the (untransformed) parse tree for the value expression. 78 * expr the transformed expression, or NULL if caller didn't do it yet. 79 * exprKind expression kind (EXPR_KIND_SELECT_TARGET, etc) 80 * colname the column name to be assigned, or NULL if none yet set. 81 * resjunk true if the target should be marked resjunk, ie, it is not 82 * wanted in the final projected tuple. 83 */ 84 TargetEntry * 85 transformTargetEntry(ParseState *pstate, 86 Node *node, 87 Node *expr, 88 ParseExprKind exprKind, 89 char *colname, 90 bool resjunk) 91 { 92 /* Transform the node if caller didn't do it already */ 93 if (expr == NULL) 94 { 95 /* 96 * If it's a SetToDefault node and we should allow that, pass it 97 * through unmodified. (transformExpr will throw the appropriate 98 * error if we're disallowing it.) 99 */ 100 if (exprKind == EXPR_KIND_UPDATE_SOURCE && IsA(node, SetToDefault)) 101 expr = node; 102 else 103 expr = transformExpr(pstate, node, exprKind); 104 } 105 106 if (colname == NULL && !resjunk) 107 { 108 /* 109 * Generate a suitable column name for a column without any explicit 110 * 'AS ColumnName' clause. 111 */ 112 colname = FigureColname(node); 113 } 114 115 return makeTargetEntry((Expr *) expr, 116 (AttrNumber) pstate->p_next_resno++, 117 colname, 118 resjunk); 119 } 120 121 122 /* 123 * transformTargetList() 124 * Turns a list of ResTarget's into a list of TargetEntry's. 125 * 126 * This code acts mostly the same for SELECT, UPDATE, or RETURNING lists; 127 * the main thing is to transform the given expressions (the "val" fields). 128 * The exprKind parameter distinguishes these cases when necessary. 129 */ 130 List * 131 transformTargetList(ParseState *pstate, List *targetlist, 132 ParseExprKind exprKind) 133 { 134 List *p_target = NIL; 135 bool expand_star; 136 ListCell *o_target; 137 138 /* Shouldn't have any leftover multiassign items at start */ 139 Assert(pstate->p_multiassign_exprs == NIL); 140 141 /* Expand "something.*" in SELECT and RETURNING, but not UPDATE */ 142 expand_star = (exprKind != EXPR_KIND_UPDATE_SOURCE); 143 144 foreach(o_target, targetlist) 145 { 146 ResTarget *res = (ResTarget *) lfirst(o_target); 147 148 /* 149 * Check for "something.*". Depending on the complexity of the 150 * "something", the star could appear as the last field in ColumnRef, 151 * or as the last indirection item in A_Indirection. 152 */ 153 if (expand_star) 154 { 155 if (IsA(res->val, ColumnRef)) 156 { 157 ColumnRef *cref = (ColumnRef *) res->val; 158 159 if (IsA(llast(cref->fields), A_Star)) 160 { 161 /* It is something.*, expand into multiple items */ 162 p_target = list_concat(p_target, 163 ExpandColumnRefStar(pstate, 164 cref, 165 true)); 166 continue; 167 } 168 } 169 else if (IsA(res->val, A_Indirection)) 170 { 171 A_Indirection *ind = (A_Indirection *) res->val; 172 173 if (IsA(llast(ind->indirection), A_Star)) 174 { 175 /* It is something.*, expand into multiple items */ 176 p_target = list_concat(p_target, 177 ExpandIndirectionStar(pstate, 178 ind, 179 true, 180 exprKind)); 181 continue; 182 } 183 } 184 } 185 186 /* 187 * Not "something.*", or we want to treat that as a plain whole-row 188 * variable, so transform as a single expression 189 */ 190 p_target = lappend(p_target, 191 transformTargetEntry(pstate, 192 res->val, 193 NULL, 194 exprKind, 195 res->name, 196 false)); 197 } 198 199 /* 200 * If any multiassign resjunk items were created, attach them to the end 201 * of the targetlist. This should only happen in an UPDATE tlist. We 202 * don't need to worry about numbering of these items; transformUpdateStmt 203 * will set their resnos. 204 */ 205 if (pstate->p_multiassign_exprs) 206 { 207 Assert(exprKind == EXPR_KIND_UPDATE_SOURCE); 208 p_target = list_concat(p_target, pstate->p_multiassign_exprs); 209 pstate->p_multiassign_exprs = NIL; 210 } 211 212 return p_target; 213 } 214 215 216 /* 217 * transformExpressionList() 218 * 219 * This is the identical transformation to transformTargetList, except that 220 * the input list elements are bare expressions without ResTarget decoration, 221 * and the output elements are likewise just expressions without TargetEntry 222 * decoration. Also, we don't expect any multiassign constructs within the 223 * list, so there's nothing to do for that. We use this for ROW() and 224 * VALUES() constructs. 225 * 226 * exprKind is not enough to tell us whether to allow SetToDefault, so 227 * an additional flag is needed for that. 228 */ 229 List * 230 transformExpressionList(ParseState *pstate, List *exprlist, 231 ParseExprKind exprKind, bool allowDefault) 232 { 233 List *result = NIL; 234 ListCell *lc; 235 236 foreach(lc, exprlist) 237 { 238 Node *e = (Node *) lfirst(lc); 239 240 /* 241 * Check for "something.*". Depending on the complexity of the 242 * "something", the star could appear as the last field in ColumnRef, 243 * or as the last indirection item in A_Indirection. 244 */ 245 if (IsA(e, ColumnRef)) 246 { 247 ColumnRef *cref = (ColumnRef *) e; 248 249 if (IsA(llast(cref->fields), A_Star)) 250 { 251 /* It is something.*, expand into multiple items */ 252 result = list_concat(result, 253 ExpandColumnRefStar(pstate, cref, 254 false)); 255 continue; 256 } 257 } 258 else if (IsA(e, A_Indirection)) 259 { 260 A_Indirection *ind = (A_Indirection *) e; 261 262 if (IsA(llast(ind->indirection), A_Star)) 263 { 264 /* It is something.*, expand into multiple items */ 265 result = list_concat(result, 266 ExpandIndirectionStar(pstate, ind, 267 false, exprKind)); 268 continue; 269 } 270 } 271 272 /* 273 * Not "something.*", so transform as a single expression. If it's a 274 * SetToDefault node and we should allow that, pass it through 275 * unmodified. (transformExpr will throw the appropriate error if 276 * we're disallowing it.) 277 */ 278 if (allowDefault && IsA(e, SetToDefault)) 279 /* do nothing */ ; 280 else 281 e = transformExpr(pstate, e, exprKind); 282 283 result = lappend(result, e); 284 } 285 286 return result; 287 } 288 289 290 /* 291 * resolveTargetListUnknowns() 292 * Convert any unknown-type targetlist entries to type TEXT. 293 * 294 * We do this after we've exhausted all other ways of identifying the output 295 * column types of a query. 296 */ 297 void 298 resolveTargetListUnknowns(ParseState *pstate, List *targetlist) 299 { 300 ListCell *l; 301 302 foreach(l, targetlist) 303 { 304 TargetEntry *tle = (TargetEntry *) lfirst(l); 305 Oid restype = exprType((Node *) tle->expr); 306 307 if (restype == UNKNOWNOID) 308 { 309 tle->expr = (Expr *) coerce_type(pstate, (Node *) tle->expr, 310 restype, TEXTOID, -1, 311 COERCION_IMPLICIT, 312 COERCE_IMPLICIT_CAST, 313 -1); 314 } 315 } 316 } 317 318 319 /* 320 * markTargetListOrigins() 321 * Mark targetlist columns that are simple Vars with the source 322 * table's OID and column number. 323 * 324 * Currently, this is done only for SELECT targetlists and RETURNING lists, 325 * since we only need the info if we are going to send it to the frontend. 326 */ 327 void 328 markTargetListOrigins(ParseState *pstate, List *targetlist) 329 { 330 ListCell *l; 331 332 foreach(l, targetlist) 333 { 334 TargetEntry *tle = (TargetEntry *) lfirst(l); 335 336 markTargetListOrigin(pstate, tle, (Var *) tle->expr, 0); 337 } 338 } 339 340 /* 341 * markTargetListOrigin() 342 * If 'var' is a Var of a plain relation, mark 'tle' with its origin 343 * 344 * levelsup is an extra offset to interpret the Var's varlevelsup correctly. 345 * 346 * This is split out so it can recurse for join references. Note that we 347 * do not drill down into views, but report the view as the column owner. 348 */ 349 static void 350 markTargetListOrigin(ParseState *pstate, TargetEntry *tle, 351 Var *var, int levelsup) 352 { 353 int netlevelsup; 354 RangeTblEntry *rte; 355 AttrNumber attnum; 356 357 if (var == NULL || !IsA(var, Var)) 358 return; 359 netlevelsup = var->varlevelsup + levelsup; 360 rte = GetRTEByRangeTablePosn(pstate, var->varno, netlevelsup); 361 attnum = var->varattno; 362 363 switch (rte->rtekind) 364 { 365 case RTE_RELATION: 366 /* It's a table or view, report it */ 367 tle->resorigtbl = rte->relid; 368 tle->resorigcol = attnum; 369 break; 370 case RTE_SUBQUERY: 371 /* Subselect-in-FROM: copy up from the subselect */ 372 if (attnum != InvalidAttrNumber) 373 { 374 TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList, 375 attnum); 376 377 if (ste == NULL || ste->resjunk) 378 elog(ERROR, "subquery %s does not have attribute %d", 379 rte->eref->aliasname, attnum); 380 tle->resorigtbl = ste->resorigtbl; 381 tle->resorigcol = ste->resorigcol; 382 } 383 break; 384 case RTE_JOIN: 385 /* Join RTE --- recursively inspect the alias variable */ 386 if (attnum != InvalidAttrNumber) 387 { 388 Var *aliasvar; 389 390 Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars)); 391 aliasvar = (Var *) list_nth(rte->joinaliasvars, attnum - 1); 392 /* We intentionally don't strip implicit coercions here */ 393 markTargetListOrigin(pstate, tle, aliasvar, netlevelsup); 394 } 395 break; 396 case RTE_FUNCTION: 397 case RTE_VALUES: 398 case RTE_TABLEFUNC: 399 case RTE_NAMEDTUPLESTORE: 400 case RTE_RESULT: 401 /* not a simple relation, leave it unmarked */ 402 break; 403 case RTE_CTE: 404 405 /* 406 * CTE reference: copy up from the subquery, if possible. If the 407 * RTE is a recursive self-reference then we can't do anything 408 * because we haven't finished analyzing it yet. However, it's no 409 * big loss because we must be down inside the recursive term of a 410 * recursive CTE, and so any markings on the current targetlist 411 * are not going to affect the results anyway. 412 */ 413 if (attnum != InvalidAttrNumber && !rte->self_reference) 414 { 415 CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup); 416 TargetEntry *ste; 417 418 ste = get_tle_by_resno(GetCTETargetList(cte), attnum); 419 if (ste == NULL || ste->resjunk) 420 elog(ERROR, "subquery %s does not have attribute %d", 421 rte->eref->aliasname, attnum); 422 tle->resorigtbl = ste->resorigtbl; 423 tle->resorigcol = ste->resorigcol; 424 } 425 break; 426 } 427 } 428 429 430 /* 431 * transformAssignedExpr() 432 * This is used in INSERT and UPDATE statements only. It prepares an 433 * expression for assignment to a column of the target table. 434 * This includes coercing the given value to the target column's type 435 * (if necessary), and dealing with any subfield names or subscripts 436 * attached to the target column itself. The input expression has 437 * already been through transformExpr(). 438 * 439 * pstate parse state 440 * expr expression to be modified 441 * exprKind indicates which type of statement we're dealing with 442 * colname target column name (ie, name of attribute to be assigned to) 443 * attrno target attribute number 444 * indirection subscripts/field names for target column, if any 445 * location error cursor position for the target column, or -1 446 * 447 * Returns the modified expression. 448 * 449 * Note: location points at the target column name (SET target or INSERT 450 * column name list entry), and must therefore be -1 in an INSERT that 451 * omits the column name list. So we should usually prefer to use 452 * exprLocation(expr) for errors that can happen in a default INSERT. 453 */ 454 Expr * 455 transformAssignedExpr(ParseState *pstate, 456 Expr *expr, 457 ParseExprKind exprKind, 458 const char *colname, 459 int attrno, 460 List *indirection, 461 int location) 462 { 463 Relation rd = pstate->p_target_relation; 464 Oid type_id; /* type of value provided */ 465 Oid attrtype; /* type of target column */ 466 int32 attrtypmod; 467 Oid attrcollation; /* collation of target column */ 468 ParseExprKind sv_expr_kind; 469 470 /* 471 * Save and restore identity of expression type we're parsing. We must 472 * set p_expr_kind here because we can parse subscripts without going 473 * through transformExpr(). 474 */ 475 Assert(exprKind != EXPR_KIND_NONE); 476 sv_expr_kind = pstate->p_expr_kind; 477 pstate->p_expr_kind = exprKind; 478 479 Assert(rd != NULL); 480 if (attrno <= 0) 481 ereport(ERROR, 482 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), 483 errmsg("cannot assign to system column \"%s\"", 484 colname), 485 parser_errposition(pstate, location))); 486 attrtype = attnumTypeId(rd, attrno); 487 attrtypmod = TupleDescAttr(rd->rd_att, attrno - 1)->atttypmod; 488 attrcollation = TupleDescAttr(rd->rd_att, attrno - 1)->attcollation; 489 490 /* 491 * If the expression is a DEFAULT placeholder, insert the attribute's 492 * type/typmod/collation into it so that exprType etc will report the 493 * right things. (We expect that the eventually substituted default 494 * expression will in fact have this type and typmod. The collation 495 * likely doesn't matter, but let's set it correctly anyway.) Also, 496 * reject trying to update a subfield or array element with DEFAULT, since 497 * there can't be any default for portions of a column. 498 */ 499 if (expr && IsA(expr, SetToDefault)) 500 { 501 SetToDefault *def = (SetToDefault *) expr; 502 503 def->typeId = attrtype; 504 def->typeMod = attrtypmod; 505 def->collation = attrcollation; 506 if (indirection) 507 { 508 if (IsA(linitial(indirection), A_Indices)) 509 ereport(ERROR, 510 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), 511 errmsg("cannot set an array element to DEFAULT"), 512 parser_errposition(pstate, location))); 513 else 514 ereport(ERROR, 515 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), 516 errmsg("cannot set a subfield to DEFAULT"), 517 parser_errposition(pstate, location))); 518 } 519 } 520 521 /* Now we can use exprType() safely. */ 522 type_id = exprType((Node *) expr); 523 524 /* 525 * If there is indirection on the target column, prepare an array or 526 * subfield assignment expression. This will generate a new column value 527 * that the source value has been inserted into, which can then be placed 528 * in the new tuple constructed by INSERT or UPDATE. 529 */ 530 if (indirection) 531 { 532 Node *colVar; 533 534 if (pstate->p_is_insert) 535 { 536 /* 537 * The command is INSERT INTO table (col.something) ... so there 538 * is not really a source value to work with. Insert a NULL 539 * constant as the source value. 540 */ 541 colVar = (Node *) makeNullConst(attrtype, attrtypmod, 542 attrcollation); 543 } 544 else 545 { 546 /* 547 * Build a Var for the column to be updated. 548 */ 549 colVar = (Node *) make_var(pstate, 550 pstate->p_target_rangetblentry, 551 attrno, 552 location); 553 } 554 555 expr = (Expr *) 556 transformAssignmentIndirection(pstate, 557 colVar, 558 colname, 559 false, 560 attrtype, 561 attrtypmod, 562 attrcollation, 563 list_head(indirection), 564 (Node *) expr, 565 location); 566 } 567 else 568 { 569 /* 570 * For normal non-qualified target column, do type checking and 571 * coercion. 572 */ 573 Node *orig_expr = (Node *) expr; 574 575 expr = (Expr *) 576 coerce_to_target_type(pstate, 577 orig_expr, type_id, 578 attrtype, attrtypmod, 579 COERCION_ASSIGNMENT, 580 COERCE_IMPLICIT_CAST, 581 -1); 582 if (expr == NULL) 583 ereport(ERROR, 584 (errcode(ERRCODE_DATATYPE_MISMATCH), 585 errmsg("column \"%s\" is of type %s" 586 " but expression is of type %s", 587 colname, 588 format_type_be(attrtype), 589 format_type_be(type_id)), 590 errhint("You will need to rewrite or cast the expression."), 591 parser_errposition(pstate, exprLocation(orig_expr)))); 592 } 593 594 pstate->p_expr_kind = sv_expr_kind; 595 596 return expr; 597 } 598 599 600 /* 601 * updateTargetListEntry() 602 * This is used in UPDATE statements (and ON CONFLICT DO UPDATE) 603 * only. It prepares an UPDATE TargetEntry for assignment to a 604 * column of the target table. This includes coercing the given 605 * value to the target column's type (if necessary), and dealing with 606 * any subfield names or subscripts attached to the target column 607 * itself. 608 * 609 * pstate parse state 610 * tle target list entry to be modified 611 * colname target column name (ie, name of attribute to be assigned to) 612 * attrno target attribute number 613 * indirection subscripts/field names for target column, if any 614 * location error cursor position (should point at column name), or -1 615 */ 616 void 617 updateTargetListEntry(ParseState *pstate, 618 TargetEntry *tle, 619 char *colname, 620 int attrno, 621 List *indirection, 622 int location) 623 { 624 /* Fix up expression as needed */ 625 tle->expr = transformAssignedExpr(pstate, 626 tle->expr, 627 EXPR_KIND_UPDATE_TARGET, 628 colname, 629 attrno, 630 indirection, 631 location); 632 633 /* 634 * Set the resno to identify the target column --- the rewriter and 635 * planner depend on this. We also set the resname to identify the target 636 * column, but this is only for debugging purposes; it should not be 637 * relied on. (In particular, it might be out of date in a stored rule.) 638 */ 639 tle->resno = (AttrNumber) attrno; 640 tle->resname = colname; 641 } 642 643 644 /* 645 * Process indirection (field selection or subscripting) of the target 646 * column in INSERT/UPDATE. This routine recurses for multiple levels 647 * of indirection --- but note that several adjacent A_Indices nodes in 648 * the indirection list are treated as a single multidimensional subscript 649 * operation. 650 * 651 * In the initial call, basenode is a Var for the target column in UPDATE, 652 * or a null Const of the target's type in INSERT. In recursive calls, 653 * basenode is NULL, indicating that a substitute node should be consed up if 654 * needed. 655 * 656 * targetName is the name of the field or subfield we're assigning to, and 657 * targetIsSubscripting is true if we're subscripting it. These are just for 658 * error reporting. 659 * 660 * targetTypeId, targetTypMod, targetCollation indicate the datatype and 661 * collation of the object to be assigned to (initially the target column, 662 * later some subobject). 663 * 664 * indirection is the sublist remaining to process. When it's NULL, we're 665 * done recursing and can just coerce and return the RHS. 666 * 667 * rhs is the already-transformed value to be assigned; note it has not been 668 * coerced to any particular type. 669 * 670 * location is the cursor error position for any errors. (Note: this points 671 * to the head of the target clause, eg "foo" in "foo.bar[baz]". Later we 672 * might want to decorate indirection cells with their own location info, 673 * in which case the location argument could probably be dropped.) 674 */ 675 static Node * 676 transformAssignmentIndirection(ParseState *pstate, 677 Node *basenode, 678 const char *targetName, 679 bool targetIsSubscripting, 680 Oid targetTypeId, 681 int32 targetTypMod, 682 Oid targetCollation, 683 ListCell *indirection, 684 Node *rhs, 685 int location) 686 { 687 Node *result; 688 List *subscripts = NIL; 689 bool isSlice = false; 690 ListCell *i; 691 692 if (indirection && !basenode) 693 { 694 /* 695 * Set up a substitution. We abuse CaseTestExpr for this. It's safe 696 * to do so because the only nodes that will be above the CaseTestExpr 697 * in the finished expression will be FieldStore and SubscriptingRef 698 * nodes. (There could be other stuff in the tree, but it will be 699 * within other child fields of those node types.) 700 */ 701 CaseTestExpr *ctest = makeNode(CaseTestExpr); 702 703 ctest->typeId = targetTypeId; 704 ctest->typeMod = targetTypMod; 705 ctest->collation = targetCollation; 706 basenode = (Node *) ctest; 707 } 708 709 /* 710 * We have to split any field-selection operations apart from 711 * subscripting. Adjacent A_Indices nodes have to be treated as a single 712 * multidimensional subscript operation. 713 */ 714 for_each_cell(i, indirection) 715 { 716 Node *n = lfirst(i); 717 718 if (IsA(n, A_Indices)) 719 { 720 subscripts = lappend(subscripts, n); 721 if (((A_Indices *) n)->is_slice) 722 isSlice = true; 723 } 724 else if (IsA(n, A_Star)) 725 { 726 ereport(ERROR, 727 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), 728 errmsg("row expansion via \"*\" is not supported here"), 729 parser_errposition(pstate, location))); 730 } 731 else 732 { 733 FieldStore *fstore; 734 Oid baseTypeId; 735 int32 baseTypeMod; 736 Oid typrelid; 737 AttrNumber attnum; 738 Oid fieldTypeId; 739 int32 fieldTypMod; 740 Oid fieldCollation; 741 742 Assert(IsA(n, String)); 743 744 /* process subscripts before this field selection */ 745 if (subscripts) 746 { 747 /* recurse, and then return because we're done */ 748 return transformAssignmentSubscripts(pstate, 749 basenode, 750 targetName, 751 targetTypeId, 752 targetTypMod, 753 targetCollation, 754 subscripts, 755 isSlice, 756 i, 757 rhs, 758 location); 759 } 760 761 /* No subscripts, so can process field selection here */ 762 763 /* 764 * Look up the composite type, accounting for possibility that 765 * what we are given is a domain over composite. 766 */ 767 baseTypeMod = targetTypMod; 768 baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod); 769 770 typrelid = typeidTypeRelid(baseTypeId); 771 if (!typrelid) 772 ereport(ERROR, 773 (errcode(ERRCODE_DATATYPE_MISMATCH), 774 errmsg("cannot assign to field \"%s\" of column \"%s\" because its type %s is not a composite type", 775 strVal(n), targetName, 776 format_type_be(targetTypeId)), 777 parser_errposition(pstate, location))); 778 779 attnum = get_attnum(typrelid, strVal(n)); 780 if (attnum == InvalidAttrNumber) 781 ereport(ERROR, 782 (errcode(ERRCODE_UNDEFINED_COLUMN), 783 errmsg("cannot assign to field \"%s\" of column \"%s\" because there is no such column in data type %s", 784 strVal(n), targetName, 785 format_type_be(targetTypeId)), 786 parser_errposition(pstate, location))); 787 if (attnum < 0) 788 ereport(ERROR, 789 (errcode(ERRCODE_UNDEFINED_COLUMN), 790 errmsg("cannot assign to system column \"%s\"", 791 strVal(n)), 792 parser_errposition(pstate, location))); 793 794 get_atttypetypmodcoll(typrelid, attnum, 795 &fieldTypeId, &fieldTypMod, &fieldCollation); 796 797 /* recurse to create appropriate RHS for field assign */ 798 rhs = transformAssignmentIndirection(pstate, 799 NULL, 800 strVal(n), 801 false, 802 fieldTypeId, 803 fieldTypMod, 804 fieldCollation, 805 lnext(i), 806 rhs, 807 location); 808 809 /* and build a FieldStore node */ 810 fstore = makeNode(FieldStore); 811 fstore->arg = (Expr *) basenode; 812 fstore->newvals = list_make1(rhs); 813 fstore->fieldnums = list_make1_int(attnum); 814 fstore->resulttype = baseTypeId; 815 816 /* If target is a domain, apply constraints */ 817 if (baseTypeId != targetTypeId) 818 return coerce_to_domain((Node *) fstore, 819 baseTypeId, baseTypeMod, 820 targetTypeId, 821 COERCION_IMPLICIT, 822 COERCE_IMPLICIT_CAST, 823 location, 824 false); 825 826 return (Node *) fstore; 827 } 828 } 829 830 /* process trailing subscripts, if any */ 831 if (subscripts) 832 { 833 /* recurse, and then return because we're done */ 834 return transformAssignmentSubscripts(pstate, 835 basenode, 836 targetName, 837 targetTypeId, 838 targetTypMod, 839 targetCollation, 840 subscripts, 841 isSlice, 842 NULL, 843 rhs, 844 location); 845 } 846 847 /* base case: just coerce RHS to match target type ID */ 848 849 result = coerce_to_target_type(pstate, 850 rhs, exprType(rhs), 851 targetTypeId, targetTypMod, 852 COERCION_ASSIGNMENT, 853 COERCE_IMPLICIT_CAST, 854 -1); 855 if (result == NULL) 856 { 857 if (targetIsSubscripting) 858 ereport(ERROR, 859 (errcode(ERRCODE_DATATYPE_MISMATCH), 860 errmsg("array assignment to \"%s\" requires type %s" 861 " but expression is of type %s", 862 targetName, 863 format_type_be(targetTypeId), 864 format_type_be(exprType(rhs))), 865 errhint("You will need to rewrite or cast the expression."), 866 parser_errposition(pstate, location))); 867 else 868 ereport(ERROR, 869 (errcode(ERRCODE_DATATYPE_MISMATCH), 870 errmsg("subfield \"%s\" is of type %s" 871 " but expression is of type %s", 872 targetName, 873 format_type_be(targetTypeId), 874 format_type_be(exprType(rhs))), 875 errhint("You will need to rewrite or cast the expression."), 876 parser_errposition(pstate, location))); 877 } 878 879 return result; 880 } 881 882 /* 883 * helper for transformAssignmentIndirection: process container assignment 884 */ 885 static Node * 886 transformAssignmentSubscripts(ParseState *pstate, 887 Node *basenode, 888 const char *targetName, 889 Oid targetTypeId, 890 int32 targetTypMod, 891 Oid targetCollation, 892 List *subscripts, 893 bool isSlice, 894 ListCell *next_indirection, 895 Node *rhs, 896 int location) 897 { 898 Node *result; 899 Oid containerType; 900 int32 containerTypMod; 901 Oid elementTypeId; 902 Oid typeNeeded; 903 Oid collationNeeded; 904 905 Assert(subscripts != NIL); 906 907 /* Identify the actual array type and element type involved */ 908 containerType = targetTypeId; 909 containerTypMod = targetTypMod; 910 elementTypeId = transformContainerType(&containerType, &containerTypMod); 911 912 /* Identify type that RHS must provide */ 913 typeNeeded = isSlice ? containerType : elementTypeId; 914 915 /* 916 * container normally has same collation as elements, but there's an 917 * exception: we might be subscripting a domain over a container type. In 918 * that case use collation of the base type. 919 */ 920 if (containerType == targetTypeId) 921 collationNeeded = targetCollation; 922 else 923 collationNeeded = get_typcollation(containerType); 924 925 /* recurse to create appropriate RHS for container assign */ 926 rhs = transformAssignmentIndirection(pstate, 927 NULL, 928 targetName, 929 true, 930 typeNeeded, 931 containerTypMod, 932 collationNeeded, 933 next_indirection, 934 rhs, 935 location); 936 937 /* process subscripts */ 938 result = (Node *) transformContainerSubscripts(pstate, 939 basenode, 940 containerType, 941 elementTypeId, 942 containerTypMod, 943 subscripts, 944 rhs); 945 946 /* If target was a domain over container, need to coerce up to the domain */ 947 if (containerType != targetTypeId) 948 { 949 Oid resulttype = exprType(result); 950 951 result = coerce_to_target_type(pstate, 952 result, resulttype, 953 targetTypeId, targetTypMod, 954 COERCION_ASSIGNMENT, 955 COERCE_IMPLICIT_CAST, 956 -1); 957 /* can fail if we had int2vector/oidvector, but not for true domains */ 958 if (result == NULL) 959 ereport(ERROR, 960 (errcode(ERRCODE_CANNOT_COERCE), 961 errmsg("cannot cast type %s to %s", 962 format_type_be(resulttype), 963 format_type_be(targetTypeId)), 964 parser_errposition(pstate, location))); 965 } 966 967 return result; 968 } 969 970 971 /* 972 * checkInsertTargets - 973 * generate a list of INSERT column targets if not supplied, or 974 * test supplied column names to make sure they are in target table. 975 * Also return an integer list of the columns' attribute numbers. 976 */ 977 List * 978 checkInsertTargets(ParseState *pstate, List *cols, List **attrnos) 979 { 980 *attrnos = NIL; 981 982 if (cols == NIL) 983 { 984 /* 985 * Generate default column list for INSERT. 986 */ 987 int numcol = RelationGetNumberOfAttributes(pstate->p_target_relation); 988 989 int i; 990 991 for (i = 0; i < numcol; i++) 992 { 993 ResTarget *col; 994 Form_pg_attribute attr; 995 996 attr = TupleDescAttr(pstate->p_target_relation->rd_att, i); 997 998 if (attr->attisdropped) 999 continue; 1000 1001 col = makeNode(ResTarget); 1002 col->name = pstrdup(NameStr(attr->attname)); 1003 col->indirection = NIL; 1004 col->val = NULL; 1005 col->location = -1; 1006 cols = lappend(cols, col); 1007 *attrnos = lappend_int(*attrnos, i + 1); 1008 } 1009 } 1010 else 1011 { 1012 /* 1013 * Do initial validation of user-supplied INSERT column list. 1014 */ 1015 Bitmapset *wholecols = NULL; 1016 Bitmapset *partialcols = NULL; 1017 ListCell *tl; 1018 1019 foreach(tl, cols) 1020 { 1021 ResTarget *col = (ResTarget *) lfirst(tl); 1022 char *name = col->name; 1023 int attrno; 1024 1025 /* Lookup column name, ereport on failure */ 1026 attrno = attnameAttNum(pstate->p_target_relation, name, false); 1027 if (attrno == InvalidAttrNumber) 1028 ereport(ERROR, 1029 (errcode(ERRCODE_UNDEFINED_COLUMN), 1030 errmsg("column \"%s\" of relation \"%s\" does not exist", 1031 name, 1032 RelationGetRelationName(pstate->p_target_relation)), 1033 parser_errposition(pstate, col->location))); 1034 1035 /* 1036 * Check for duplicates, but only of whole columns --- we allow 1037 * INSERT INTO foo (col.subcol1, col.subcol2) 1038 */ 1039 if (col->indirection == NIL) 1040 { 1041 /* whole column; must not have any other assignment */ 1042 if (bms_is_member(attrno, wholecols) || 1043 bms_is_member(attrno, partialcols)) 1044 ereport(ERROR, 1045 (errcode(ERRCODE_DUPLICATE_COLUMN), 1046 errmsg("column \"%s\" specified more than once", 1047 name), 1048 parser_errposition(pstate, col->location))); 1049 wholecols = bms_add_member(wholecols, attrno); 1050 } 1051 else 1052 { 1053 /* partial column; must not have any whole assignment */ 1054 if (bms_is_member(attrno, wholecols)) 1055 ereport(ERROR, 1056 (errcode(ERRCODE_DUPLICATE_COLUMN), 1057 errmsg("column \"%s\" specified more than once", 1058 name), 1059 parser_errposition(pstate, col->location))); 1060 partialcols = bms_add_member(partialcols, attrno); 1061 } 1062 1063 *attrnos = lappend_int(*attrnos, attrno); 1064 } 1065 } 1066 1067 return cols; 1068 } 1069 1070 /* 1071 * ExpandColumnRefStar() 1072 * Transforms foo.* into a list of expressions or targetlist entries. 1073 * 1074 * This handles the case where '*' appears as the last or only item in a 1075 * ColumnRef. The code is shared between the case of foo.* at the top level 1076 * in a SELECT target list (where we want TargetEntry nodes in the result) 1077 * and foo.* in a ROW() or VALUES() construct (where we want just bare 1078 * expressions). 1079 * 1080 * The referenced columns are marked as requiring SELECT access. 1081 */ 1082 static List * 1083 ExpandColumnRefStar(ParseState *pstate, ColumnRef *cref, 1084 bool make_target_entry) 1085 { 1086 List *fields = cref->fields; 1087 int numnames = list_length(fields); 1088 1089 if (numnames == 1) 1090 { 1091 /* 1092 * Target item is a bare '*', expand all tables 1093 * 1094 * (e.g., SELECT * FROM emp, dept) 1095 * 1096 * Since the grammar only accepts bare '*' at top level of SELECT, we 1097 * need not handle the make_target_entry==false case here. 1098 */ 1099 Assert(make_target_entry); 1100 return ExpandAllTables(pstate, cref->location); 1101 } 1102 else 1103 { 1104 /* 1105 * Target item is relation.*, expand that table 1106 * 1107 * (e.g., SELECT emp.*, dname FROM emp, dept) 1108 * 1109 * Note: this code is a lot like transformColumnRef; it's tempting to 1110 * call that instead and then replace the resulting whole-row Var with 1111 * a list of Vars. However, that would leave us with the RTE's 1112 * selectedCols bitmap showing the whole row as needing select 1113 * permission, as well as the individual columns. That would be 1114 * incorrect (since columns added later shouldn't need select 1115 * permissions). We could try to remove the whole-row permission bit 1116 * after the fact, but duplicating code is less messy. 1117 */ 1118 char *nspname = NULL; 1119 char *relname = NULL; 1120 RangeTblEntry *rte = NULL; 1121 int levels_up; 1122 enum 1123 { 1124 CRSERR_NO_RTE, 1125 CRSERR_WRONG_DB, 1126 CRSERR_TOO_MANY 1127 } crserr = CRSERR_NO_RTE; 1128 1129 /* 1130 * Give the PreParseColumnRefHook, if any, first shot. If it returns 1131 * non-null then we should use that expression. 1132 */ 1133 if (pstate->p_pre_columnref_hook != NULL) 1134 { 1135 Node *node; 1136 1137 node = pstate->p_pre_columnref_hook(pstate, cref); 1138 if (node != NULL) 1139 return ExpandRowReference(pstate, node, make_target_entry); 1140 } 1141 1142 switch (numnames) 1143 { 1144 case 2: 1145 relname = strVal(linitial(fields)); 1146 rte = refnameRangeTblEntry(pstate, nspname, relname, 1147 cref->location, 1148 &levels_up); 1149 break; 1150 case 3: 1151 nspname = strVal(linitial(fields)); 1152 relname = strVal(lsecond(fields)); 1153 rte = refnameRangeTblEntry(pstate, nspname, relname, 1154 cref->location, 1155 &levels_up); 1156 break; 1157 case 4: 1158 { 1159 char *catname = strVal(linitial(fields)); 1160 1161 /* 1162 * We check the catalog name and then ignore it. 1163 */ 1164 if (strcmp(catname, get_database_name(MyDatabaseId)) != 0) 1165 { 1166 crserr = CRSERR_WRONG_DB; 1167 break; 1168 } 1169 nspname = strVal(lsecond(fields)); 1170 relname = strVal(lthird(fields)); 1171 rte = refnameRangeTblEntry(pstate, nspname, relname, 1172 cref->location, 1173 &levels_up); 1174 break; 1175 } 1176 default: 1177 crserr = CRSERR_TOO_MANY; 1178 break; 1179 } 1180 1181 /* 1182 * Now give the PostParseColumnRefHook, if any, a chance. We cheat a 1183 * bit by passing the RangeTblEntry, not a Var, as the planned 1184 * translation. (A single Var wouldn't be strictly correct anyway. 1185 * This convention allows hooks that really care to know what is 1186 * happening.) 1187 */ 1188 if (pstate->p_post_columnref_hook != NULL) 1189 { 1190 Node *node; 1191 1192 node = pstate->p_post_columnref_hook(pstate, cref, 1193 (Node *) rte); 1194 if (node != NULL) 1195 { 1196 if (rte != NULL) 1197 ereport(ERROR, 1198 (errcode(ERRCODE_AMBIGUOUS_COLUMN), 1199 errmsg("column reference \"%s\" is ambiguous", 1200 NameListToString(cref->fields)), 1201 parser_errposition(pstate, cref->location))); 1202 return ExpandRowReference(pstate, node, make_target_entry); 1203 } 1204 } 1205 1206 /* 1207 * Throw error if no translation found. 1208 */ 1209 if (rte == NULL) 1210 { 1211 switch (crserr) 1212 { 1213 case CRSERR_NO_RTE: 1214 errorMissingRTE(pstate, makeRangeVar(nspname, relname, 1215 cref->location)); 1216 break; 1217 case CRSERR_WRONG_DB: 1218 ereport(ERROR, 1219 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), 1220 errmsg("cross-database references are not implemented: %s", 1221 NameListToString(cref->fields)), 1222 parser_errposition(pstate, cref->location))); 1223 break; 1224 case CRSERR_TOO_MANY: 1225 ereport(ERROR, 1226 (errcode(ERRCODE_SYNTAX_ERROR), 1227 errmsg("improper qualified name (too many dotted names): %s", 1228 NameListToString(cref->fields)), 1229 parser_errposition(pstate, cref->location))); 1230 break; 1231 } 1232 } 1233 1234 /* 1235 * OK, expand the RTE into fields. 1236 */ 1237 return ExpandSingleTable(pstate, rte, cref->location, make_target_entry); 1238 } 1239 } 1240 1241 /* 1242 * ExpandAllTables() 1243 * Transforms '*' (in the target list) into a list of targetlist entries. 1244 * 1245 * tlist entries are generated for each relation visible for unqualified 1246 * column name access. We do not consider qualified-name-only entries because 1247 * that would include input tables of aliasless JOINs, NEW/OLD pseudo-entries, 1248 * etc. 1249 * 1250 * The referenced relations/columns are marked as requiring SELECT access. 1251 */ 1252 static List * 1253 ExpandAllTables(ParseState *pstate, int location) 1254 { 1255 List *target = NIL; 1256 bool found_table = false; 1257 ListCell *l; 1258 1259 foreach(l, pstate->p_namespace) 1260 { 1261 ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l); 1262 RangeTblEntry *rte = nsitem->p_rte; 1263 1264 /* Ignore table-only items */ 1265 if (!nsitem->p_cols_visible) 1266 continue; 1267 /* Should not have any lateral-only items when parsing targetlist */ 1268 Assert(!nsitem->p_lateral_only); 1269 /* Remember we found a p_cols_visible item */ 1270 found_table = true; 1271 1272 target = list_concat(target, 1273 expandRelAttrs(pstate, 1274 rte, 1275 RTERangeTablePosn(pstate, rte, 1276 NULL), 1277 0, 1278 location)); 1279 } 1280 1281 /* 1282 * Check for "SELECT *;". We do it this way, rather than checking for 1283 * target == NIL, because we want to allow SELECT * FROM a zero_column 1284 * table. 1285 */ 1286 if (!found_table) 1287 ereport(ERROR, 1288 (errcode(ERRCODE_SYNTAX_ERROR), 1289 errmsg("SELECT * with no tables specified is not valid"), 1290 parser_errposition(pstate, location))); 1291 1292 return target; 1293 } 1294 1295 /* 1296 * ExpandIndirectionStar() 1297 * Transforms foo.* into a list of expressions or targetlist entries. 1298 * 1299 * This handles the case where '*' appears as the last item in A_Indirection. 1300 * The code is shared between the case of foo.* at the top level in a SELECT 1301 * target list (where we want TargetEntry nodes in the result) and foo.* in 1302 * a ROW() or VALUES() construct (where we want just bare expressions). 1303 * For robustness, we use a separate "make_target_entry" flag to control 1304 * this rather than relying on exprKind. 1305 */ 1306 static List * 1307 ExpandIndirectionStar(ParseState *pstate, A_Indirection *ind, 1308 bool make_target_entry, ParseExprKind exprKind) 1309 { 1310 Node *expr; 1311 1312 /* Strip off the '*' to create a reference to the rowtype object */ 1313 ind = copyObject(ind); 1314 ind->indirection = list_truncate(ind->indirection, 1315 list_length(ind->indirection) - 1); 1316 1317 /* And transform that */ 1318 expr = transformExpr(pstate, (Node *) ind, exprKind); 1319 1320 /* Expand the rowtype expression into individual fields */ 1321 return ExpandRowReference(pstate, expr, make_target_entry); 1322 } 1323 1324 /* 1325 * ExpandSingleTable() 1326 * Transforms foo.* into a list of expressions or targetlist entries. 1327 * 1328 * This handles the case where foo has been determined to be a simple 1329 * reference to an RTE, so we can just generate Vars for the expressions. 1330 * 1331 * The referenced columns are marked as requiring SELECT access. 1332 */ 1333 static List * 1334 ExpandSingleTable(ParseState *pstate, RangeTblEntry *rte, 1335 int location, bool make_target_entry) 1336 { 1337 int sublevels_up; 1338 int rtindex; 1339 1340 rtindex = RTERangeTablePosn(pstate, rte, &sublevels_up); 1341 1342 if (make_target_entry) 1343 { 1344 /* expandRelAttrs handles permissions marking */ 1345 return expandRelAttrs(pstate, rte, rtindex, sublevels_up, 1346 location); 1347 } 1348 else 1349 { 1350 List *vars; 1351 ListCell *l; 1352 1353 expandRTE(rte, rtindex, sublevels_up, location, false, 1354 NULL, &vars); 1355 1356 /* 1357 * Require read access to the table. This is normally redundant with 1358 * the markVarForSelectPriv calls below, but not if the table has zero 1359 * columns. 1360 */ 1361 rte->requiredPerms |= ACL_SELECT; 1362 1363 /* Require read access to each column */ 1364 foreach(l, vars) 1365 { 1366 Var *var = (Var *) lfirst(l); 1367 1368 markVarForSelectPriv(pstate, var, rte); 1369 } 1370 1371 return vars; 1372 } 1373 } 1374 1375 /* 1376 * ExpandRowReference() 1377 * Transforms foo.* into a list of expressions or targetlist entries. 1378 * 1379 * This handles the case where foo is an arbitrary expression of composite 1380 * type. 1381 */ 1382 static List * 1383 ExpandRowReference(ParseState *pstate, Node *expr, 1384 bool make_target_entry) 1385 { 1386 List *result = NIL; 1387 TupleDesc tupleDesc; 1388 int numAttrs; 1389 int i; 1390 1391 /* 1392 * If the rowtype expression is a whole-row Var, we can expand the fields 1393 * as simple Vars. Note: if the RTE is a relation, this case leaves us 1394 * with the RTE's selectedCols bitmap showing the whole row as needing 1395 * select permission, as well as the individual columns. However, we can 1396 * only get here for weird notations like (table.*).*, so it's not worth 1397 * trying to clean up --- arguably, the permissions marking is correct 1398 * anyway for such cases. 1399 */ 1400 if (IsA(expr, Var) && 1401 ((Var *) expr)->varattno == InvalidAttrNumber) 1402 { 1403 Var *var = (Var *) expr; 1404 RangeTblEntry *rte; 1405 1406 rte = GetRTEByRangeTablePosn(pstate, var->varno, var->varlevelsup); 1407 return ExpandSingleTable(pstate, rte, var->location, make_target_entry); 1408 } 1409 1410 /* 1411 * Otherwise we have to do it the hard way. Our current implementation is 1412 * to generate multiple copies of the expression and do FieldSelects. 1413 * (This can be pretty inefficient if the expression involves nontrivial 1414 * computation :-(.) 1415 * 1416 * Verify it's a composite type, and get the tupdesc. 1417 * get_expr_result_tupdesc() handles this conveniently. 1418 * 1419 * If it's a Var of type RECORD, we have to work even harder: we have to 1420 * find what the Var refers to, and pass that to get_expr_result_tupdesc. 1421 * That task is handled by expandRecordVariable(). 1422 */ 1423 if (IsA(expr, Var) && 1424 ((Var *) expr)->vartype == RECORDOID) 1425 tupleDesc = expandRecordVariable(pstate, (Var *) expr, 0); 1426 else 1427 tupleDesc = get_expr_result_tupdesc(expr, false); 1428 Assert(tupleDesc); 1429 1430 /* Generate a list of references to the individual fields */ 1431 numAttrs = tupleDesc->natts; 1432 for (i = 0; i < numAttrs; i++) 1433 { 1434 Form_pg_attribute att = TupleDescAttr(tupleDesc, i); 1435 FieldSelect *fselect; 1436 1437 if (att->attisdropped) 1438 continue; 1439 1440 fselect = makeNode(FieldSelect); 1441 fselect->arg = (Expr *) copyObject(expr); 1442 fselect->fieldnum = i + 1; 1443 fselect->resulttype = att->atttypid; 1444 fselect->resulttypmod = att->atttypmod; 1445 /* save attribute's collation for parse_collate.c */ 1446 fselect->resultcollid = att->attcollation; 1447 1448 if (make_target_entry) 1449 { 1450 /* add TargetEntry decoration */ 1451 TargetEntry *te; 1452 1453 te = makeTargetEntry((Expr *) fselect, 1454 (AttrNumber) pstate->p_next_resno++, 1455 pstrdup(NameStr(att->attname)), 1456 false); 1457 result = lappend(result, te); 1458 } 1459 else 1460 result = lappend(result, fselect); 1461 } 1462 1463 return result; 1464 } 1465 1466 /* 1467 * expandRecordVariable 1468 * Get the tuple descriptor for a Var of type RECORD, if possible. 1469 * 1470 * Since no actual table or view column is allowed to have type RECORD, such 1471 * a Var must refer to a JOIN or FUNCTION RTE or to a subquery output. We 1472 * drill down to find the ultimate defining expression and attempt to infer 1473 * the tupdesc from it. We ereport if we can't determine the tupdesc. 1474 * 1475 * levelsup is an extra offset to interpret the Var's varlevelsup correctly. 1476 */ 1477 TupleDesc 1478 expandRecordVariable(ParseState *pstate, Var *var, int levelsup) 1479 { 1480 TupleDesc tupleDesc; 1481 int netlevelsup; 1482 RangeTblEntry *rte; 1483 AttrNumber attnum; 1484 Node *expr; 1485 1486 /* Check my caller didn't mess up */ 1487 Assert(IsA(var, Var)); 1488 Assert(var->vartype == RECORDOID); 1489 1490 netlevelsup = var->varlevelsup + levelsup; 1491 rte = GetRTEByRangeTablePosn(pstate, var->varno, netlevelsup); 1492 attnum = var->varattno; 1493 1494 if (attnum == InvalidAttrNumber) 1495 { 1496 /* Whole-row reference to an RTE, so expand the known fields */ 1497 List *names, 1498 *vars; 1499 ListCell *lname, 1500 *lvar; 1501 int i; 1502 1503 expandRTE(rte, var->varno, 0, var->location, false, 1504 &names, &vars); 1505 1506 tupleDesc = CreateTemplateTupleDesc(list_length(vars)); 1507 i = 1; 1508 forboth(lname, names, lvar, vars) 1509 { 1510 char *label = strVal(lfirst(lname)); 1511 Node *varnode = (Node *) lfirst(lvar); 1512 1513 TupleDescInitEntry(tupleDesc, i, 1514 label, 1515 exprType(varnode), 1516 exprTypmod(varnode), 1517 0); 1518 TupleDescInitEntryCollation(tupleDesc, i, 1519 exprCollation(varnode)); 1520 i++; 1521 } 1522 Assert(lname == NULL && lvar == NULL); /* lists same length? */ 1523 1524 return tupleDesc; 1525 } 1526 1527 expr = (Node *) var; /* default if we can't drill down */ 1528 1529 switch (rte->rtekind) 1530 { 1531 case RTE_RELATION: 1532 case RTE_VALUES: 1533 case RTE_NAMEDTUPLESTORE: 1534 case RTE_RESULT: 1535 1536 /* 1537 * This case should not occur: a column of a table, values list, 1538 * or ENR shouldn't have type RECORD. Fall through and fail (most 1539 * likely) at the bottom. 1540 */ 1541 break; 1542 case RTE_SUBQUERY: 1543 { 1544 /* Subselect-in-FROM: examine sub-select's output expr */ 1545 TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList, 1546 attnum); 1547 1548 if (ste == NULL || ste->resjunk) 1549 elog(ERROR, "subquery %s does not have attribute %d", 1550 rte->eref->aliasname, attnum); 1551 expr = (Node *) ste->expr; 1552 if (IsA(expr, Var)) 1553 { 1554 /* 1555 * Recurse into the sub-select to see what its Var refers 1556 * to. We have to build an additional level of ParseState 1557 * to keep in step with varlevelsup in the subselect. 1558 */ 1559 ParseState mypstate; 1560 1561 MemSet(&mypstate, 0, sizeof(mypstate)); 1562 mypstate.parentParseState = pstate; 1563 mypstate.p_rtable = rte->subquery->rtable; 1564 /* don't bother filling the rest of the fake pstate */ 1565 1566 return expandRecordVariable(&mypstate, (Var *) expr, 0); 1567 } 1568 /* else fall through to inspect the expression */ 1569 } 1570 break; 1571 case RTE_JOIN: 1572 /* Join RTE --- recursively inspect the alias variable */ 1573 Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars)); 1574 expr = (Node *) list_nth(rte->joinaliasvars, attnum - 1); 1575 Assert(expr != NULL); 1576 /* We intentionally don't strip implicit coercions here */ 1577 if (IsA(expr, Var)) 1578 return expandRecordVariable(pstate, (Var *) expr, netlevelsup); 1579 /* else fall through to inspect the expression */ 1580 break; 1581 case RTE_FUNCTION: 1582 1583 /* 1584 * We couldn't get here unless a function is declared with one of 1585 * its result columns as RECORD, which is not allowed. 1586 */ 1587 break; 1588 case RTE_TABLEFUNC: 1589 1590 /* 1591 * Table function cannot have columns with RECORD type. 1592 */ 1593 break; 1594 case RTE_CTE: 1595 /* CTE reference: examine subquery's output expr */ 1596 if (!rte->self_reference) 1597 { 1598 CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup); 1599 TargetEntry *ste; 1600 1601 ste = get_tle_by_resno(GetCTETargetList(cte), attnum); 1602 if (ste == NULL || ste->resjunk) 1603 elog(ERROR, "subquery %s does not have attribute %d", 1604 rte->eref->aliasname, attnum); 1605 expr = (Node *) ste->expr; 1606 if (IsA(expr, Var)) 1607 { 1608 /* 1609 * Recurse into the CTE to see what its Var refers to. We 1610 * have to build an additional level of ParseState to keep 1611 * in step with varlevelsup in the CTE; furthermore it 1612 * could be an outer CTE. 1613 */ 1614 ParseState mypstate; 1615 Index levelsup; 1616 1617 MemSet(&mypstate, 0, sizeof(mypstate)); 1618 /* this loop must work, since GetCTEForRTE did */ 1619 for (levelsup = 0; 1620 levelsup < rte->ctelevelsup + netlevelsup; 1621 levelsup++) 1622 pstate = pstate->parentParseState; 1623 mypstate.parentParseState = pstate; 1624 mypstate.p_rtable = ((Query *) cte->ctequery)->rtable; 1625 /* don't bother filling the rest of the fake pstate */ 1626 1627 return expandRecordVariable(&mypstate, (Var *) expr, 0); 1628 } 1629 /* else fall through to inspect the expression */ 1630 } 1631 break; 1632 } 1633 1634 /* 1635 * We now have an expression we can't expand any more, so see if 1636 * get_expr_result_tupdesc() can do anything with it. 1637 */ 1638 return get_expr_result_tupdesc(expr, false); 1639 } 1640 1641 1642 /* 1643 * FigureColname - 1644 * if the name of the resulting column is not specified in the target 1645 * list, we have to guess a suitable name. The SQL spec provides some 1646 * guidance, but not much... 1647 * 1648 * Note that the argument is the *untransformed* parse tree for the target 1649 * item. This is a shade easier to work with than the transformed tree. 1650 */ 1651 char * 1652 FigureColname(Node *node) 1653 { 1654 char *name = NULL; 1655 1656 (void) FigureColnameInternal(node, &name); 1657 if (name != NULL) 1658 return name; 1659 /* default result if we can't guess anything */ 1660 return "?column?"; 1661 } 1662 1663 /* 1664 * FigureIndexColname - 1665 * choose the name for an expression column in an index 1666 * 1667 * This is actually just like FigureColname, except we return NULL if 1668 * we can't pick a good name. 1669 */ 1670 char * 1671 FigureIndexColname(Node *node) 1672 { 1673 char *name = NULL; 1674 1675 (void) FigureColnameInternal(node, &name); 1676 return name; 1677 } 1678 1679 /* 1680 * FigureColnameInternal - 1681 * internal workhorse for FigureColname 1682 * 1683 * Return value indicates strength of confidence in result: 1684 * 0 - no information 1685 * 1 - second-best name choice 1686 * 2 - good name choice 1687 * The return value is actually only used internally. 1688 * If the result isn't zero, *name is set to the chosen name. 1689 */ 1690 static int 1691 FigureColnameInternal(Node *node, char **name) 1692 { 1693 int strength = 0; 1694 1695 if (node == NULL) 1696 return strength; 1697 1698 switch (nodeTag(node)) 1699 { 1700 case T_ColumnRef: 1701 { 1702 char *fname = NULL; 1703 ListCell *l; 1704 1705 /* find last field name, if any, ignoring "*" */ 1706 foreach(l, ((ColumnRef *) node)->fields) 1707 { 1708 Node *i = lfirst(l); 1709 1710 if (IsA(i, String)) 1711 fname = strVal(i); 1712 } 1713 if (fname) 1714 { 1715 *name = fname; 1716 return 2; 1717 } 1718 } 1719 break; 1720 case T_A_Indirection: 1721 { 1722 A_Indirection *ind = (A_Indirection *) node; 1723 char *fname = NULL; 1724 ListCell *l; 1725 1726 /* find last field name, if any, ignoring "*" and subscripts */ 1727 foreach(l, ind->indirection) 1728 { 1729 Node *i = lfirst(l); 1730 1731 if (IsA(i, String)) 1732 fname = strVal(i); 1733 } 1734 if (fname) 1735 { 1736 *name = fname; 1737 return 2; 1738 } 1739 return FigureColnameInternal(ind->arg, name); 1740 } 1741 break; 1742 case T_FuncCall: 1743 *name = strVal(llast(((FuncCall *) node)->funcname)); 1744 return 2; 1745 case T_A_Expr: 1746 if (((A_Expr *) node)->kind == AEXPR_NULLIF) 1747 { 1748 /* make nullif() act like a regular function */ 1749 *name = "nullif"; 1750 return 2; 1751 } 1752 if (((A_Expr *) node)->kind == AEXPR_PAREN) 1753 { 1754 /* look through dummy parenthesis node */ 1755 return FigureColnameInternal(((A_Expr *) node)->lexpr, name); 1756 } 1757 break; 1758 case T_TypeCast: 1759 strength = FigureColnameInternal(((TypeCast *) node)->arg, 1760 name); 1761 if (strength <= 1) 1762 { 1763 if (((TypeCast *) node)->typeName != NULL) 1764 { 1765 *name = strVal(llast(((TypeCast *) node)->typeName->names)); 1766 return 1; 1767 } 1768 } 1769 break; 1770 case T_CollateClause: 1771 return FigureColnameInternal(((CollateClause *) node)->arg, name); 1772 case T_GroupingFunc: 1773 /* make GROUPING() act like a regular function */ 1774 *name = "grouping"; 1775 return 2; 1776 case T_SubLink: 1777 switch (((SubLink *) node)->subLinkType) 1778 { 1779 case EXISTS_SUBLINK: 1780 *name = "exists"; 1781 return 2; 1782 case ARRAY_SUBLINK: 1783 *name = "array"; 1784 return 2; 1785 case EXPR_SUBLINK: 1786 { 1787 /* Get column name of the subquery's single target */ 1788 SubLink *sublink = (SubLink *) node; 1789 Query *query = (Query *) sublink->subselect; 1790 1791 /* 1792 * The subquery has probably already been transformed, 1793 * but let's be careful and check that. (The reason 1794 * we can see a transformed subquery here is that 1795 * transformSubLink is lazy and modifies the SubLink 1796 * node in-place.) 1797 */ 1798 if (IsA(query, Query)) 1799 { 1800 TargetEntry *te = (TargetEntry *) linitial(query->targetList); 1801 1802 if (te->resname) 1803 { 1804 *name = te->resname; 1805 return 2; 1806 } 1807 } 1808 } 1809 break; 1810 /* As with other operator-like nodes, these have no names */ 1811 case MULTIEXPR_SUBLINK: 1812 case ALL_SUBLINK: 1813 case ANY_SUBLINK: 1814 case ROWCOMPARE_SUBLINK: 1815 case CTE_SUBLINK: 1816 break; 1817 } 1818 break; 1819 case T_CaseExpr: 1820 strength = FigureColnameInternal((Node *) ((CaseExpr *) node)->defresult, 1821 name); 1822 if (strength <= 1) 1823 { 1824 *name = "case"; 1825 return 1; 1826 } 1827 break; 1828 case T_A_ArrayExpr: 1829 /* make ARRAY[] act like a function */ 1830 *name = "array"; 1831 return 2; 1832 case T_RowExpr: 1833 /* make ROW() act like a function */ 1834 *name = "row"; 1835 return 2; 1836 case T_CoalesceExpr: 1837 /* make coalesce() act like a regular function */ 1838 *name = "coalesce"; 1839 return 2; 1840 case T_MinMaxExpr: 1841 /* make greatest/least act like a regular function */ 1842 switch (((MinMaxExpr *) node)->op) 1843 { 1844 case IS_GREATEST: 1845 *name = "greatest"; 1846 return 2; 1847 case IS_LEAST: 1848 *name = "least"; 1849 return 2; 1850 } 1851 break; 1852 case T_SQLValueFunction: 1853 /* make these act like a function or variable */ 1854 switch (((SQLValueFunction *) node)->op) 1855 { 1856 case SVFOP_CURRENT_DATE: 1857 *name = "current_date"; 1858 return 2; 1859 case SVFOP_CURRENT_TIME: 1860 case SVFOP_CURRENT_TIME_N: 1861 *name = "current_time"; 1862 return 2; 1863 case SVFOP_CURRENT_TIMESTAMP: 1864 case SVFOP_CURRENT_TIMESTAMP_N: 1865 *name = "current_timestamp"; 1866 return 2; 1867 case SVFOP_LOCALTIME: 1868 case SVFOP_LOCALTIME_N: 1869 *name = "localtime"; 1870 return 2; 1871 case SVFOP_LOCALTIMESTAMP: 1872 case SVFOP_LOCALTIMESTAMP_N: 1873 *name = "localtimestamp"; 1874 return 2; 1875 case SVFOP_CURRENT_ROLE: 1876 *name = "current_role"; 1877 return 2; 1878 case SVFOP_CURRENT_USER: 1879 *name = "current_user"; 1880 return 2; 1881 case SVFOP_USER: 1882 *name = "user"; 1883 return 2; 1884 case SVFOP_SESSION_USER: 1885 *name = "session_user"; 1886 return 2; 1887 case SVFOP_CURRENT_CATALOG: 1888 *name = "current_catalog"; 1889 return 2; 1890 case SVFOP_CURRENT_SCHEMA: 1891 *name = "current_schema"; 1892 return 2; 1893 } 1894 break; 1895 case T_XmlExpr: 1896 /* make SQL/XML functions act like a regular function */ 1897 switch (((XmlExpr *) node)->op) 1898 { 1899 case IS_XMLCONCAT: 1900 *name = "xmlconcat"; 1901 return 2; 1902 case IS_XMLELEMENT: 1903 *name = "xmlelement"; 1904 return 2; 1905 case IS_XMLFOREST: 1906 *name = "xmlforest"; 1907 return 2; 1908 case IS_XMLPARSE: 1909 *name = "xmlparse"; 1910 return 2; 1911 case IS_XMLPI: 1912 *name = "xmlpi"; 1913 return 2; 1914 case IS_XMLROOT: 1915 *name = "xmlroot"; 1916 return 2; 1917 case IS_XMLSERIALIZE: 1918 *name = "xmlserialize"; 1919 return 2; 1920 case IS_DOCUMENT: 1921 /* nothing */ 1922 break; 1923 } 1924 break; 1925 case T_XmlSerialize: 1926 *name = "xmlserialize"; 1927 return 2; 1928 default: 1929 break; 1930 } 1931 1932 return strength; 1933 } 1934