开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
rewriteHandler.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：70k
源码类别：

数据库系统

开发平台：

Unix_Linux

rewriteHandler.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * rewriteHandler.c
  4.  *
  5.  * Copyright (c) 1994, Regents of the University of California
  6.  *
  7.  *
  8.  * IDENTIFICATION
  9.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.48 1999/07/11 17:54:30 tgl Exp $
  10.  *
  11.  *-------------------------------------------------------------------------
  12.  */
  13. #include <string.h>
  14. #include "postgres.h"
  15. #include "miscadmin.h"
  16. #include "utils/palloc.h"
  17. #include "utils/elog.h"
  18. #include "utils/rel.h"
  19. #include "nodes/pg_list.h"
  20. #include "nodes/primnodes.h"
  21. #include "nodes/relation.h"
  23. #include "parser/parsetree.h" /* for parsetree manipulation */
  24. #include "parser/parse_relation.h"
  25. #include "nodes/parsenodes.h"
  27. /***S*I***/
  28. #include "parser/parse_node.h"
  29. #include "parser/parse_target.h"
  31. #include "parser/analyze.h"
  32. #include "optimizer/clauses.h"
  33. #include "optimizer/prep.h"
  35. #include "rewrite/rewriteSupport.h"
  36. #include "rewrite/rewriteHandler.h"
  37. #include "rewrite/rewriteManip.h"
  38. #include "rewrite/locks.h"
  40. #include "commands/creatinh.h"
  41. #include "access/heapam.h"
  43. #include "utils/lsyscache.h"
  44. #include "utils/syscache.h"
  45. #include "utils/acl.h"
  46. #include "catalog/pg_shadow.h"
  47. #include "catalog/pg_type.h"
  50. static RewriteInfo *gatherRewriteMeta(Query *parsetree,
  51.   Query *rule_action,
  52.   Node *rule_qual,
  53.   int rt_index,
  54.   CmdType event,
  55.   bool *instead_flag);
  56. static bool rangeTableEntry_used(Node *node, int rt_index, int sublevels_up);
  57. static bool attribute_used(Node *node, int rt_index, int attno, int sublevels_up);
  58. static void modifyAggrefUplevel(Node *node);
  59. static void modifyAggrefChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int sublevels_up);
  60. static void modifyAggrefDropQual(Node **nodePtr, Node *orignode, Expr *expr);
  61. static SubLink *modifyAggrefMakeSublink(Expr *origexp, Query *parsetree);
  62. static void modifyAggrefQual(Node **nodePtr, Query *parsetree);
  63. static bool checkQueryHasAggs(Node *node);
  64. static bool checkQueryHasAggs_walker(Node *node, void *context);
  65. static bool checkQueryHasSubLink(Node *node);
  66. static bool checkQueryHasSubLink_walker(Node *node, void *context);
  67. static Query *fireRIRrules(Query *parsetree);
  68. static Query *Except_Intersect_Rewrite(Query *parsetree);
  69. static void check_targetlists_are_compatible(List *prev_target,
  70.  List *current_target);
  71. static void create_intersect_list(Node *ptr, List **intersect_list);
  72. static Node *intersect_tree_analyze(Node *tree, Node *first_select,
  73. Node *parsetree);
  75. /*
  76.  * gatherRewriteMeta -
  77.  *   Gather meta information about parsetree, and rule. Fix rule body
  78.  *   and qualifier so that they can be mixed with the parsetree and
  79.  *   maintain semantic validity
  80.  */
  81. static RewriteInfo *
  82. gatherRewriteMeta(Query *parsetree,
  83.   Query *rule_action,
  84.   Node *rule_qual,
  85.   int rt_index,
  86.   CmdType event,
  87.   bool *instead_flag)
  88. {
  89. RewriteInfo *info;
  90. int rt_length;
  91. int result_reln;
  93. info = (RewriteInfo *) palloc(sizeof(RewriteInfo));
  94. info->rt_index = rt_index;
  95. info->event = event;
  96. info->instead_flag = *instead_flag;
  97. info->rule_action = (Query *) copyObject(rule_action);
  98. info->rule_qual = (Node *) copyObject(rule_qual);
  99. if (info->rule_action == NULL)
  100. info->nothing = TRUE;
  101. else
  102. {
  103. info->nothing = FALSE;
  104. info->action = info->rule_action->commandType;
  105. info->current_varno = rt_index;
  106. info->rt = parsetree->rtable;
  107. rt_length = length(info->rt);
  108. info->rt = nconc(info->rt, copyObject(info->rule_action->rtable));
  110. info->new_varno = PRS2_NEW_VARNO + rt_length;
  111. OffsetVarNodes(info->rule_action->qual, rt_length, 0);
  112. OffsetVarNodes((Node *) info->rule_action->targetList, rt_length, 0);
  113. OffsetVarNodes(info->rule_qual, rt_length, 0);
  114. ChangeVarNodes((Node *) info->rule_action->qual,
  115.    PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
  116. ChangeVarNodes((Node *) info->rule_action->targetList,
  117.    PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
  118. ChangeVarNodes(info->rule_qual,
  119.    PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
  121. /*
  122.  * bug here about replace CURRENT  -- sort of replace current is
  123.  * deprecated now so this code shouldn't really need to be so
  124.  * clutzy but.....
  125.  */
  126. if (info->action != CMD_SELECT)
  127. { /* i.e update XXXXX */
  128. int new_result_reln = 0;
  130. result_reln = info->rule_action->resultRelation;
  131. switch (result_reln)
  132. {
  133. case PRS2_CURRENT_VARNO:
  134. new_result_reln = rt_index;
  135. break;
  136. case PRS2_NEW_VARNO: /* XXX */
  137. default:
  138. new_result_reln = result_reln + rt_length;
  139. break;
  140. }
  141. info->rule_action->resultRelation = new_result_reln;
  142. }
  143. }
  144. return info;
  145. }
  148. /*
  149.  * rangeTableEntry_used -
  150.  * we need to process a RTE for RIR rules only if it is
  151.  * referenced somewhere in var nodes of the query.
  152.  */
  153. static bool
  154. rangeTableEntry_used(Node *node, int rt_index, int sublevels_up)
  155. {
  156. if (node == NULL)
  157. return FALSE;
  159. switch (nodeTag(node))
  160. {
  161. case T_TargetEntry:
  162. {
  163. TargetEntry *tle = (TargetEntry *) node;
  165. return rangeTableEntry_used(
  166. (Node *) (tle->expr),
  167. rt_index,
  168. sublevels_up);
  169. }
  170. break;
  172. case T_Aggref:
  173. {
  174. Aggref    *aggref = (Aggref *) node;
  176. return rangeTableEntry_used(
  177. (Node *) (aggref->target),
  178. rt_index,
  179. sublevels_up);
  180. }
  181. break;
  183. case T_GroupClause:
  184. return FALSE;
  186. case T_Expr:
  187. {
  188. Expr    *exp = (Expr *) node;
  190. return rangeTableEntry_used(
  191. (Node *) (exp->args),
  192. rt_index,
  193. sublevels_up);
  194. }
  195. break;
  197. case T_Iter:
  198. {
  199. Iter    *iter = (Iter *) node;
  201. return rangeTableEntry_used(
  202. (Node *) (iter->iterexpr),
  203. rt_index,
  204. sublevels_up);
  205. }
  206. break;
  208. case T_ArrayRef:
  209. {
  210. ArrayRef   *ref = (ArrayRef *) node;
  212. if (rangeTableEntry_used(
  213.  (Node *) (ref->refupperindexpr),
  214.  rt_index,
  215.  sublevels_up))
  216. return TRUE;
  218. if (rangeTableEntry_used(
  219.  (Node *) (ref->reflowerindexpr),
  220.  rt_index,
  221.  sublevels_up))
  222. return TRUE;
  224. if (rangeTableEntry_used(
  225.  (Node *) (ref->refexpr),
  226.  rt_index,
  227.  sublevels_up))
  228. return TRUE;
  230. if (rangeTableEntry_used(
  231.  (Node *) (ref->refassgnexpr),
  232.  rt_index,
  233.  sublevels_up))
  234. return TRUE;
  236. return FALSE;
  237. }
  238. break;
  240. case T_Var:
  241. {
  242. Var    *var = (Var *) node;
  244. if (var->varlevelsup == sublevels_up)
  245. return var->varno == rt_index;
  246. else
  247. return FALSE;
  248. }
  249. break;
  251. case T_Param:
  252. return FALSE;
  254. case T_Const:
  255. return FALSE;
  257. case T_List:
  258. {
  259. List    *l;
  261. foreach(l, (List *) node)
  262. {
  263. if (rangeTableEntry_used(
  264.  (Node *) lfirst(l),
  265.  rt_index,
  266.  sublevels_up))
  267. return TRUE;
  268. }
  269. return FALSE;
  270. }
  271. break;
  273. case T_SubLink:
  274. {
  275. SubLink    *sub = (SubLink *) node;
  277. if (rangeTableEntry_used(
  278.  (Node *) (sub->lefthand),
  279.  rt_index,
  280.  sublevels_up))
  281. return TRUE;
  283. if (rangeTableEntry_used(
  284.  (Node *) (sub->subselect),
  285.  rt_index,
  286.  sublevels_up + 1))
  287. return TRUE;
  289. return FALSE;
  290. }
  291. break;
  293. case T_CaseExpr:
  294. {
  295. CaseExpr   *exp = (CaseExpr *) node;
  297. if (rangeTableEntry_used(
  298.  (Node *) (exp->args),
  299.  rt_index,
  300.  sublevels_up))
  301. return TRUE;
  303. if (rangeTableEntry_used(
  304.  (Node *) (exp->defresult),
  305.  rt_index,
  306.  sublevels_up))
  307. return TRUE;
  309. return FALSE;
  310. }
  311. break;
  313. case T_CaseWhen:
  314. {
  315. CaseWhen   *when = (CaseWhen *) node;
  317. if (rangeTableEntry_used(
  318.  (Node *) (when->expr),
  319.  rt_index,
  320.  sublevels_up))
  321. return TRUE;
  323. if (rangeTableEntry_used(
  324.  (Node *) (when->result),
  325.  rt_index,
  326.  sublevels_up))
  327. return TRUE;
  329. return FALSE;
  330. }
  331. break;
  333. case T_Query:
  334. {
  335. Query    *qry = (Query *) node;
  337. if (rangeTableEntry_used(
  338.  (Node *) (qry->targetList),
  339.  rt_index,
  340.  sublevels_up))
  341. return TRUE;
  343. if (rangeTableEntry_used(
  344.  (Node *) (qry->qual),
  345.  rt_index,
  346.  sublevels_up))
  347. return TRUE;
  349. if (rangeTableEntry_used(
  350.  (Node *) (qry->havingQual),
  351.  rt_index,
  352.  sublevels_up))
  353. return TRUE;
  355. return FALSE;
  356. }
  357. break;
  359. default:
  360. elog(NOTICE, "unknown node tag %d in rangeTableEntry_used()", nodeTag(node));
  361. elog(NOTICE, "Node is: %s", nodeToString(node));
  362. break;
  365. }
  367. return FALSE;
  368. }
  371. /*
  372.  * attribute_used -
  373.  * Check if a specific attribute number of a RTE is used
  374.  * somewhere in the query
  375.  */
  376. static bool
  377. attribute_used(Node *node, int rt_index, int attno, int sublevels_up)
  378. {
  379. if (node == NULL)
  380. return FALSE;
  382. switch (nodeTag(node))
  383. {
  384. case T_TargetEntry:
  385. {
  386. TargetEntry *tle = (TargetEntry *) node;
  388. return attribute_used(
  389.   (Node *) (tle->expr),
  390.   rt_index,
  391.   attno,
  392.   sublevels_up);
  393. }
  394. break;
  396. case T_Aggref:
  397. {
  398. Aggref    *aggref = (Aggref *) node;
  400. return attribute_used(
  401.   (Node *) (aggref->target),
  402.   rt_index,
  403.   attno,
  404.   sublevels_up);
  405. }
  406. break;
  408. case T_GroupClause:
  409. return FALSE;
  411. case T_Expr:
  412. {
  413. Expr    *exp = (Expr *) node;
  415. return attribute_used(
  416.   (Node *) (exp->args),
  417.   rt_index,
  418.   attno,
  419.   sublevels_up);
  420. }
  421. break;
  423. case T_Iter:
  424. {
  425. Iter    *iter = (Iter *) node;
  427. return attribute_used(
  428.   (Node *) (iter->iterexpr),
  429.   rt_index,
  430.   attno,
  431.   sublevels_up);
  432. }
  433. break;
  435. case T_ArrayRef:
  436. {
  437. ArrayRef   *ref = (ArrayRef *) node;
  439. if (attribute_used(
  440.    (Node *) (ref->refupperindexpr),
  441.    rt_index,
  442.    attno,
  443.    sublevels_up))
  444. return TRUE;
  446. if (attribute_used(
  447.    (Node *) (ref->reflowerindexpr),
  448.    rt_index,
  449.    attno,
  450.    sublevels_up))
  451. return TRUE;
  453. if (attribute_used(
  454.    (Node *) (ref->refexpr),
  455.    rt_index,
  456.    attno,
  457.    sublevels_up))
  458. return TRUE;
  460. if (attribute_used(
  461.    (Node *) (ref->refassgnexpr),
  462.    rt_index,
  463.    attno,
  464.    sublevels_up))
  465. return TRUE;
  467. return FALSE;
  468. }
  469. break;
  471. case T_Var:
  472. {
  473. Var    *var = (Var *) node;
  475. if (var->varlevelsup == sublevels_up)
  476. return var->varno == rt_index;
  477. else
  478. return FALSE;
  479. }
  480. break;
  482. case T_Param:
  483. return FALSE;
  485. case T_Const:
  486. return FALSE;
  488. case T_List:
  489. {
  490. List    *l;
  492. foreach(l, (List *) node)
  493. {
  494. if (attribute_used(
  495.    (Node *) lfirst(l),
  496.    rt_index,
  497.    attno,
  498.    sublevels_up))
  499. return TRUE;
  500. }
  501. return FALSE;
  502. }
  503. break;
  505. case T_SubLink:
  506. {
  507. SubLink    *sub = (SubLink *) node;
  509. if (attribute_used(
  510.    (Node *) (sub->lefthand),
  511.    rt_index,
  512.    attno,
  513.    sublevels_up))
  514. return TRUE;
  516. if (attribute_used(
  517.    (Node *) (sub->subselect),
  518.    rt_index,
  519.    attno,
  520.    sublevels_up + 1))
  521. return TRUE;
  523. return FALSE;
  524. }
  525. break;
  527. case T_Query:
  528. {
  529. Query    *qry = (Query *) node;
  531. if (attribute_used(
  532.    (Node *) (qry->targetList),
  533.    rt_index,
  534.    attno,
  535.    sublevels_up))
  536. return TRUE;
  538. if (attribute_used(
  539.    (Node *) (qry->qual),
  540.    rt_index,
  541.    attno,
  542.    sublevels_up))
  543. return TRUE;
  545. if (attribute_used(
  546.    (Node *) (qry->havingQual),
  547.    rt_index,
  548.    attno,
  549.    sublevels_up))
  550. return TRUE;
  552. return FALSE;
  553. }
  554. break;
  556. default:
  557. elog(NOTICE, "unknown node tag %d in attribute_used()", nodeTag(node));
  558. elog(NOTICE, "Node is: %s", nodeToString(node));
  559. break;
  562. }
  564. return FALSE;
  565. }
  568. /*
  569.  * modifyAggrefUplevel -
  570.  * In the newly created sublink for an aggregate column used in
  571.  * the qualification, we must adjust the varlevelsup in all the
  572.  * var nodes.
  573.  */
  574. static void
  575. modifyAggrefUplevel(Node *node)
  576. {
  577. if (node == NULL)
  578. return;
  580. switch (nodeTag(node))
  581. {
  582. case T_TargetEntry:
  583. {
  584. TargetEntry *tle = (TargetEntry *) node;
  586. modifyAggrefUplevel(
  587. (Node *) (tle->expr));
  588. }
  589. break;
  591. case T_Aggref:
  592. {
  593. Aggref    *aggref = (Aggref *) node;
  595. modifyAggrefUplevel(
  596. (Node *) (aggref->target));
  597. }
  598. break;
  600. case T_Expr:
  601. {
  602. Expr    *exp = (Expr *) node;
  604. modifyAggrefUplevel(
  605. (Node *) (exp->args));
  606. }
  607. break;
  609. case T_Iter:
  610. {
  611. Iter    *iter = (Iter *) node;
  613. modifyAggrefUplevel(
  614. (Node *) (iter->iterexpr));
  615. }
  616. break;
  618. case T_ArrayRef:
  619. {
  620. ArrayRef   *ref = (ArrayRef *) node;
  622. modifyAggrefUplevel(
  623. (Node *) (ref->refupperindexpr));
  624. modifyAggrefUplevel(
  625. (Node *) (ref->reflowerindexpr));
  626. modifyAggrefUplevel(
  627. (Node *) (ref->refexpr));
  628. modifyAggrefUplevel(
  629. (Node *) (ref->refassgnexpr));
  630. }
  631. break;
  633. case T_Var:
  634. {
  635. Var    *var = (Var *) node;
  637. var->varlevelsup++;
  638. }
  639. break;
  641. case T_Param:
  642. break;
  644. case T_Const:
  645. break;
  647. case T_List:
  648. {
  649. List    *l;
  651. foreach(l, (List *) node)
  652. modifyAggrefUplevel(
  653. (Node *) lfirst(l));
  654. }
  655. break;
  657. case T_SubLink:
  658. {
  659. SubLink    *sub = (SubLink *) node;
  661. modifyAggrefUplevel(
  662. (Node *) (sub->lefthand));
  664. modifyAggrefUplevel(
  665. (Node *) (sub->oper));
  667. modifyAggrefUplevel(
  668. (Node *) (sub->subselect));
  669. }
  670. break;
  672. case T_Query:
  673. {
  674. Query    *qry = (Query *) node;
  676. modifyAggrefUplevel(
  677. (Node *) (qry->targetList));
  679. modifyAggrefUplevel(
  680. (Node *) (qry->qual));
  682. modifyAggrefUplevel(
  683. (Node *) (qry->havingQual));
  685. }
  686. break;
  688. default:
  689. elog(NOTICE, "unknown node tag %d in modifyAggrefUplevel()", nodeTag(node));
  690. elog(NOTICE, "Node is: %s", nodeToString(node));
  691. break;
  694. }
  695. }
  698. /*
  699.  * modifyAggrefChangeVarnodes -
  700.  * Change the var nodes in a sublink created for an aggregate column
  701.  * used in the qualification that is subject of the aggregate
  702.  * function to point to the correct local RTE.
  703.  */
  704. static void
  705. modifyAggrefChangeVarnodes(Node **nodePtr, int rt_index, int new_index, int sublevels_up)
  706. {
  707. Node    *node = *nodePtr;
  709. if (node == NULL)
  710. return;
  712. switch (nodeTag(node))
  713. {
  714. case T_TargetEntry:
  715. {
  716. TargetEntry *tle = (TargetEntry *) node;
  718. modifyAggrefChangeVarnodes(
  719.    (Node **) (&(tle->expr)),
  720.    rt_index,
  721.    new_index,
  722.    sublevels_up);
  723. }
  724. break;
  726. case T_Aggref:
  727. {
  728. Aggref    *aggref = (Aggref *) node;
  730. modifyAggrefChangeVarnodes(
  731.    (Node **) (&(aggref->target)),
  732.    rt_index,
  733.    new_index,
  734.    sublevels_up);
  735. }
  736. break;
  738. case T_GroupClause:
  739. break;
  741. case T_Expr:
  742. {
  743. Expr    *exp = (Expr *) node;
  745. modifyAggrefChangeVarnodes(
  746.    (Node **) (&(exp->args)),
  747.    rt_index,
  748.    new_index,
  749.    sublevels_up);
  750. }
  751. break;
  753. case T_Iter:
  754. {
  755. Iter    *iter = (Iter *) node;
  757. modifyAggrefChangeVarnodes(
  758.    (Node **) (&(iter->iterexpr)),
  759.    rt_index,
  760.    new_index,
  761.    sublevels_up);
  762. }
  763. break;
  765. case T_ArrayRef:
  766. {
  767. ArrayRef   *ref = (ArrayRef *) node;
  769. modifyAggrefChangeVarnodes(
  770.  (Node **) (&(ref->refupperindexpr)),
  771.    rt_index,
  772.    new_index,
  773.    sublevels_up);
  774. modifyAggrefChangeVarnodes(
  775.  (Node **) (&(ref->reflowerindexpr)),
  776.    rt_index,
  777.    new_index,
  778.    sublevels_up);
  779. modifyAggrefChangeVarnodes(
  780.    (Node **) (&(ref->refexpr)),
  781.    rt_index,
  782.    new_index,
  783.    sublevels_up);
  784. modifyAggrefChangeVarnodes(
  785. (Node **) (&(ref->refassgnexpr)),
  786.    rt_index,
  787.    new_index,
  788.    sublevels_up);
  789. }
  790. break;
  792. case T_Var:
  793. {
  794. Var    *var = (Var *) node;
  796. if (var->varlevelsup == sublevels_up &&
  797. var->varno == rt_index)
  798. {
  799. var = copyObject(var);
  800. var->varno = new_index;
  801. var->varnoold = new_index;
  802. var->varlevelsup = 0;
  804. *nodePtr = (Node *) var;
  805. }
  806. }
  807. break;
  809. case T_Param:
  810. break;
  812. case T_Const:
  813. break;
  815. case T_List:
  816. {
  817. List    *l;
  819. foreach(l, (List *) node)
  820. modifyAggrefChangeVarnodes(
  821.    (Node **) (&lfirst(l)),
  822.    rt_index,
  823.    new_index,
  824.    sublevels_up);
  825. }
  826. break;
  828. case T_SubLink:
  829. {
  830. SubLink    *sub = (SubLink *) node;
  832. modifyAggrefChangeVarnodes(
  833.    (Node **) (&(sub->lefthand)),
  834.    rt_index,
  835.    new_index,
  836.    sublevels_up);
  838. modifyAggrefChangeVarnodes(
  839.    (Node **) (&(sub->oper)),
  840.    rt_index,
  841.    new_index,
  842.    sublevels_up);
  844. modifyAggrefChangeVarnodes(
  845.    (Node **) (&(sub->subselect)),
  846.    rt_index,
  847.    new_index,
  848.    sublevels_up + 1);
  849. }
  850. break;
  852. case T_Query:
  853. {
  854. Query    *qry = (Query *) node;
  856. modifyAggrefChangeVarnodes(
  857.    (Node **) (&(qry->targetList)),
  858.    rt_index,
  859.    new_index,
  860.    sublevels_up);
  862. modifyAggrefChangeVarnodes(
  863.    (Node **) (&(qry->qual)),
  864.    rt_index,
  865.    new_index,
  866.    sublevels_up);
  868. modifyAggrefChangeVarnodes(
  869.    (Node **) (&(qry->havingQual)),
  870.    rt_index,
  871.    new_index,
  872.    sublevels_up);
  873. }
  874. break;
  876. default:
  877. elog(NOTICE, "unknown node tag %d in modifyAggrefChangeVarnodes()", nodeTag(node));
  878. elog(NOTICE, "Node is: %s", nodeToString(node));
  879. break;
  882. }
  883. }
  886. /*
  887.  * modifyAggrefDropQual -
  888.  * remove the pure aggref clase from a qualification
  889.  */
  890. static void
  891. modifyAggrefDropQual(Node **nodePtr, Node *orignode, Expr *expr)
  892. {
  893. Node    *node = *nodePtr;
  895. if (node == NULL)
  896. return;
  898. switch (nodeTag(node))
  899. {
  900. case T_Var:
  901. break;
  903. case T_Aggref:
  904. {
  905. Aggref    *aggref = (Aggref *) node;
  906. Aggref    *oaggref = (Aggref *) orignode;
  908. modifyAggrefDropQual(
  909.  (Node **) (&(aggref->target)),
  910.  (Node *) (oaggref->target),
  911.  expr);
  912. }
  913. break;
  915. case T_Param:
  916. break;
  918. case T_Const:
  919. break;
  921. case T_GroupClause:
  922. break;
  924. case T_Expr:
  925. {
  926. Expr    *this_expr = (Expr *) node;
  927. Expr    *orig_expr = (Expr *) orignode;
  929. if (orig_expr == expr)
  930. {
  931. Const    *ctrue;
  933. if (expr->typeOid != BOOLOID)
  934. elog(ERROR,
  935.  "aggregate expression in qualification isn't of type bool");
  936. ctrue = makeNode(Const);
  937. ctrue->consttype = BOOLOID;
  938. ctrue->constlen = 1;
  939. ctrue->constisnull = FALSE;
  940. ctrue->constvalue = (Datum) TRUE;
  941. ctrue->constbyval = TRUE;
  943. *nodePtr = (Node *) ctrue;
  944. }
  945. else
  946. modifyAggrefDropQual(
  947.  (Node **) (&(this_expr->args)),
  948.  (Node *) (orig_expr->args),
  949.  expr);
  950. }
  951. break;
  953. case T_Iter:
  954. {
  955. Iter    *iter = (Iter *) node;
  956. Iter    *oiter = (Iter *) orignode;
  958. modifyAggrefDropQual(
  959.  (Node **) (&(iter->iterexpr)),
  960.  (Node *) (oiter->iterexpr),
  961.  expr);
  962. }
  963. break;
  965. case T_ArrayRef:
  966. {
  967. ArrayRef   *ref = (ArrayRef *) node;
  968. ArrayRef   *oref = (ArrayRef *) orignode;
  970. modifyAggrefDropQual(
  971.  (Node **) (&(ref->refupperindexpr)),
  972.  (Node *) (oref->refupperindexpr),
  973.  expr);
  974. modifyAggrefDropQual(
  975.  (Node **) (&(ref->reflowerindexpr)),
  976.  (Node *) (oref->reflowerindexpr),
  977.  expr);
  978. modifyAggrefDropQual(
  979.  (Node **) (&(ref->refexpr)),
  980.  (Node *) (oref->refexpr),
  981.  expr);
  982. modifyAggrefDropQual(
  983.  (Node **) (&(ref->refassgnexpr)),
  984.  (Node *) (oref->refassgnexpr),
  985.  expr);
  986. }
  987. break;
  989. case T_List:
  990. {
  991. List    *l;
  992. List    *ol = (List *) orignode;
  993. int li = 0;
  995. foreach(l, (List *) node)
  996. {
  997. modifyAggrefDropQual(
  998.  (Node **) (&(lfirst(l))),
  999.  (Node *) nth(li, ol),
  1000.  expr);
  1001. li++;
  1002. }
  1003. }
  1004. break;
  1006. case T_SubLink:
  1007. {
  1008. SubLink    *sub = (SubLink *) node;
  1009. SubLink    *osub = (SubLink *) orignode;
  1011. modifyAggrefDropQual(
  1012.  (Node **) (&(sub->subselect)),
  1013.  (Node *) (osub->subselect),
  1014.  expr);
  1015. }
  1016. break;
  1018. case T_Query:
  1019. {
  1020. Query    *qry = (Query *) node;
  1021. Query    *oqry = (Query *) orignode;
  1023. modifyAggrefDropQual(
  1024.  (Node **) (&(qry->qual)),
  1025.  (Node *) (oqry->qual),
  1026.  expr);
  1028. modifyAggrefDropQual(
  1029.  (Node **) (&(qry->havingQual)),
  1030.  (Node *) (oqry->havingQual),
  1031.  expr);
  1032. }
  1033. break;
  1035. default:
  1036. elog(NOTICE, "unknown node tag %d in modifyAggrefDropQual()", nodeTag(node));
  1037. elog(NOTICE, "Node is: %s", nodeToString(node));
  1038. break;
  1041. }
  1042. }
  1045. /*
  1046.  * modifyAggrefMakeSublink -
  1047.  * Create a sublink node for a qualification expression that
  1048.  * uses an aggregate column of a view
  1049.  */
  1050. static SubLink *
  1051. modifyAggrefMakeSublink(Expr *origexp, Query *parsetree)
  1052. {
  1053. SubLink    *sublink;
  1054. Query    *subquery;
  1055. Node    *subqual;
  1056. RangeTblEntry *rte;
  1057. Aggref    *aggref;
  1058. Var    *target;
  1059. TargetEntry *tle;
  1060. Resdom    *resdom;
  1061. Expr    *exp = copyObject(origexp);
  1063. if (nodeTag(nth(0, exp->args)) == T_Aggref)
  1064. {
  1065. if (nodeTag(nth(1, exp->args)) == T_Aggref)
  1066. elog(ERROR, "rewrite: comparision of 2 aggregate columns not supported");
  1067. else
  1068. elog(ERROR, "rewrite: aggregate column of view must be at rigth side in qual");
  1069. }
  1071. aggref = (Aggref *) nth(1, exp->args);
  1072. target = (Var *) (aggref->target);
  1073. rte = (RangeTblEntry *) nth(target->varno - 1, parsetree->rtable);
  1074. tle = makeNode(TargetEntry);
  1075. resdom = makeNode(Resdom);
  1077. aggref->usenulls = TRUE;
  1079. resdom->resno = 1;
  1080. resdom->restype = ((Oper *) (exp->oper))->opresulttype;
  1081. resdom->restypmod = -1;
  1082. resdom->resname = pstrdup("<noname>");
  1083. resdom->reskey = 0;
  1084. resdom->reskeyop = 0;
  1085. resdom->resjunk = false;
  1087. tle->resdom = resdom;
  1088. tle->expr = (Node *) aggref;
  1090. subqual = copyObject(parsetree->qual);
  1091. modifyAggrefDropQual((Node **) &subqual, (Node *) parsetree->qual, origexp);
  1093. sublink = makeNode(SubLink);
  1094. sublink->subLinkType = EXPR_SUBLINK;
  1095. sublink->useor = FALSE;
  1096. sublink->lefthand = lappend(NIL, copyObject(lfirst(exp->args)));
  1097. sublink->oper = lappend(NIL, copyObject(exp));
  1098. sublink->subselect = NULL;
  1100. subquery = makeNode(Query);
  1101. sublink->subselect = (Node *) subquery;
  1103. subquery->commandType = CMD_SELECT;
  1104. subquery->utilityStmt = NULL;
  1105. subquery->resultRelation = 0;
  1106. subquery->into = NULL;
  1107. subquery->isPortal = FALSE;
  1108. subquery->isBinary = FALSE;
  1109. subquery->isTemp = FALSE;
  1110. subquery->unionall = FALSE;
  1111. subquery->uniqueFlag = NULL;
  1112. subquery->sortClause = NULL;
  1113. subquery->rtable = lappend(NIL, rte);
  1114. subquery->targetList = lappend(NIL, tle);
  1115. subquery->qual = subqual;
  1116. subquery->groupClause = NIL;
  1117. subquery->havingQual = NULL;
  1118. subquery->hasAggs = TRUE;
  1119. subquery->hasSubLinks = FALSE;
  1120. subquery->unionClause = NULL;
  1123. modifyAggrefUplevel((Node *) sublink);
  1125. modifyAggrefChangeVarnodes((Node **) &(sublink->lefthand), target->varno,
  1126.    1, target->varlevelsup);
  1127. modifyAggrefChangeVarnodes((Node **) &(sublink->oper), target->varno,
  1128.    1, target->varlevelsup);
  1129. modifyAggrefChangeVarnodes((Node **) &(sublink->subselect), target->varno,
  1130.    1, target->varlevelsup);
  1132. return sublink;
  1133. }
  1136. /*
  1137.  * modifyAggrefQual -
  1138.  * Search for qualification expressions that contain aggregate
  1139.  * functions and substiture them by sublinks. These expressions
  1140.  * originally come from qualifications that use aggregate columns
  1141.  * of a view.
  1142.  */
  1143. static void
  1144. modifyAggrefQual(Node **nodePtr, Query *parsetree)
  1145. {
  1146. Node    *node = *nodePtr;
  1148. if (node == NULL)
  1149. return;
  1151. switch (nodeTag(node))
  1152. {
  1153. case T_Var:
  1154. break;
  1156. case T_Param:
  1157. break;
  1159. case T_Const:
  1160. break;
  1162. case T_GroupClause:
  1163. break;
  1165. case T_Expr:
  1166. {
  1167. Expr    *exp = (Expr *) node;
  1168. SubLink    *sub;
  1171. if (length(exp->args) != 2)
  1172. {
  1173. modifyAggrefQual(
  1174.  (Node **) (&(exp->args)),
  1175.  parsetree);
  1176. break;
  1177. }
  1179. if (nodeTag(nth(0, exp->args)) != T_Aggref &&
  1180. nodeTag(nth(1, exp->args)) != T_Aggref)
  1181. {
  1183. modifyAggrefQual(
  1184.  (Node **) (&(exp->args)),
  1185.  parsetree);
  1186. break;
  1187. }
  1189. sub = modifyAggrefMakeSublink(exp,
  1190.   parsetree);
  1192. *nodePtr = (Node *) sub;
  1193. parsetree->hasSubLinks = TRUE;
  1194. }
  1195. break;
  1197. case T_CaseExpr:
  1198. {
  1200. /*
  1201.  * We're calling recursively, and this routine knows how
  1202.  * to handle lists so let it do the work to handle the
  1203.  * WHEN clauses...
  1204.  */
  1205. modifyAggrefQual(
  1206.  (Node **) (&(((CaseExpr *) node)->args)),
  1207.  parsetree);
  1209. modifyAggrefQual(
  1210.    (Node **) (&(((CaseExpr *) node)->defresult)),
  1211.  parsetree);
  1212. }
  1213. break;
  1215. case T_CaseWhen:
  1216. {
  1217. modifyAggrefQual(
  1218.  (Node **) (&(((CaseWhen *) node)->expr)),
  1219.  parsetree);
  1221. modifyAggrefQual(
  1222.   (Node **) (&(((CaseWhen *) node)->result)),
  1223.  parsetree);
  1224. }
  1225. break;
  1227. case T_Iter:
  1228. {
  1229. Iter    *iter = (Iter *) node;
  1231. modifyAggrefQual(
  1232.  (Node **) (&(iter->iterexpr)),
  1233.  parsetree);
  1234. }
  1235. break;
  1237. case T_ArrayRef:
  1238. {
  1239. ArrayRef   *ref = (ArrayRef *) node;
  1241. modifyAggrefQual(
  1242.  (Node **) (&(ref->refupperindexpr)),
  1243.  parsetree);
  1244. modifyAggrefQual(
  1245.  (Node **) (&(ref->reflowerindexpr)),
  1246.  parsetree);
  1247. modifyAggrefQual(
  1248.  (Node **) (&(ref->refexpr)),
  1249.  parsetree);
  1250. modifyAggrefQual(
  1251.  (Node **) (&(ref->refassgnexpr)),
  1252.  parsetree);
  1253. }
  1254. break;
  1256. case T_List:
  1257. {
  1258. List    *l;
  1260. foreach(l, (List *) node)
  1261. modifyAggrefQual(
  1262.  (Node **) (&(lfirst(l))),
  1263.  parsetree);
  1264. }
  1265. break;
  1267. case T_SubLink:
  1268. {
  1269. SubLink    *sub = (SubLink *) node;
  1271. modifyAggrefQual(
  1272.  (Node **) (&(sub->subselect)),
  1273.  (Query *) (sub->subselect));
  1274. }
  1275. break;
  1277. case T_Query:
  1278. {
  1279. Query    *qry = (Query *) node;
  1281. modifyAggrefQual(
  1282.  (Node **) (&(qry->qual)),
  1283.  parsetree);
  1285. modifyAggrefQual(
  1286.  (Node **) (&(qry->havingQual)),
  1287.  parsetree);
  1288. }
  1289. break;
  1291. default:
  1292. elog(NOTICE, "unknown node tag %d in modifyAggrefQual()", nodeTag(node));
  1293. elog(NOTICE, "Node is: %s", nodeToString(node));
  1294. break;
  1297. }
  1298. }
  1301. /*
  1302.  * checkQueryHasAggs -
  1303.  * Queries marked hasAggs might not have them any longer after
  1304.  * rewriting. Check it.
  1305.  */
  1306. static bool
  1307. checkQueryHasAggs(Node *node)
  1308. {
  1309. return checkQueryHasAggs_walker(node, NULL);
  1310. }
  1312. static bool
  1313. checkQueryHasAggs_walker(Node *node, void *context)
  1314. {
  1315. if (node == NULL)
  1316. return false;
  1317. if (IsA(node, Aggref))
  1318. return true; /* abort the tree traversal and return true */
  1319. return expression_tree_walker(node, checkQueryHasAggs_walker, context);
  1320. }
  1322. /*
  1323.  * checkQueryHasSubLink -
  1324.  * Queries marked hasSubLinks might not have them any longer after
  1325.  * rewriting. Check it.
  1326.  */
  1327. static bool
  1328. checkQueryHasSubLink(Node *node)
  1329. {
  1330. return checkQueryHasSubLink_walker(node, NULL);
  1331. }
  1333. static bool
  1334. checkQueryHasSubLink_walker(Node *node, void *context)
  1335. {
  1336. if (node == NULL)
  1337. return false;
  1338. if (IsA(node, SubLink))
  1339. return true; /* abort the tree traversal and return true */
  1340. /* Note: we assume the tree has not yet been rewritten by subselect.c,
  1341.  * therefore we will find bare SubLink nodes and not SUBPLAN nodes.
  1342.  */
  1343. return expression_tree_walker(node, checkQueryHasSubLink_walker, context);
  1344. }
  1347. static Node *
  1348. FindMatchingTLEntry(List *tlist, char *e_attname)
  1349. {
  1350. List    *i;
  1352. foreach(i, tlist)
  1353. {
  1354. TargetEntry *tle = lfirst(i);
  1355. char    *resname;
  1357. resname = tle->resdom->resname;
  1358. if (!strcmp(e_attname, resname))
  1359. return (tle->expr);
  1360. }
  1361. return NULL;
  1362. }
  1365. static Node *
  1366. make_null(Oid type)
  1367. {
  1368. Const    *c = makeNode(Const);
  1370. c->consttype = type;
  1371. c->constlen = get_typlen(type);
  1372. c->constvalue = PointerGetDatum(NULL);
  1373. c->constisnull = true;
  1374. c->constbyval = get_typbyval(type);
  1375. return (Node *) c;
  1376. }
  1379. static void
  1380. apply_RIR_adjust_sublevel(Node *node, int sublevels_up)
  1381. {
  1382. if (node == NULL)
  1383. return;
  1385. switch (nodeTag(node))
  1386. {
  1387. case T_TargetEntry:
  1388. {
  1389. TargetEntry *tle = (TargetEntry *) node;
  1391. apply_RIR_adjust_sublevel(
  1392.   (Node *) (tle->expr),
  1393.   sublevels_up);
  1394. }
  1395. break;
  1397. case T_Aggref:
  1398. {
  1399. Aggref    *aggref = (Aggref *) node;
  1401. apply_RIR_adjust_sublevel(
  1402.   (Node *) (aggref->target),
  1403.   sublevels_up);
  1404. }
  1405. break;
  1407. case T_GroupClause:
  1408. break;
  1410. case T_Expr:
  1411. {
  1412. Expr    *exp = (Expr *) node;
  1414. apply_RIR_adjust_sublevel(
  1415.   (Node *) (exp->args),
  1416.   sublevels_up);
  1417. }
  1418. break;
  1420. case T_Iter:
  1421. {
  1422. Iter    *iter = (Iter *) node;
  1424. apply_RIR_adjust_sublevel(
  1425.   (Node *) (iter->iterexpr),
  1426.   sublevels_up);
  1427. }
  1428. break;
  1430. case T_ArrayRef:
  1431. {
  1432. ArrayRef   *ref = (ArrayRef *) node;
  1434. apply_RIR_adjust_sublevel(
  1435.   (Node *) (ref->refupperindexpr),
  1436.   sublevels_up);
  1438. apply_RIR_adjust_sublevel(
  1439.   (Node *) (ref->reflowerindexpr),
  1440.   sublevels_up);
  1442. apply_RIR_adjust_sublevel(
  1443.   (Node *) (ref->refexpr),
  1444.   sublevels_up);
  1446. apply_RIR_adjust_sublevel(
  1447.   (Node *) (ref->refassgnexpr),
  1448.   sublevels_up);
  1449. }
  1450. break;
  1452. case T_Var:
  1453. {
  1454. Var    *var = (Var *) node;
  1456. var->varlevelsup = sublevels_up;
  1457. }
  1458. break;
  1460. case T_Param:
  1461. break;
  1463. case T_Const:
  1464. break;
  1466. case T_List:
  1467. {
  1468. List    *l;
  1470. foreach(l, (List *) node)
  1471. {
  1472. apply_RIR_adjust_sublevel(
  1473.   (Node *) lfirst(l),
  1474.   sublevels_up);
  1475. }
  1476. }
  1477. break;
  1479. case T_CaseExpr:
  1480. {
  1481. CaseExpr   *exp = (CaseExpr *) node;
  1483. apply_RIR_adjust_sublevel(
  1484.   (Node *) (exp->args),
  1485.   sublevels_up);
  1487. apply_RIR_adjust_sublevel(
  1488.   (Node *) (exp->defresult),
  1489.   sublevels_up);
  1490. }
  1491. break;
  1493. case T_CaseWhen:
  1494. {
  1495. CaseWhen   *exp = (CaseWhen *) node;
  1497. apply_RIR_adjust_sublevel(
  1498.   (Node *) (exp->expr),
  1499.   sublevels_up);
  1501. apply_RIR_adjust_sublevel(
  1502.   (Node *) (exp->result),
  1503.   sublevels_up);
  1504. }
  1505. break;
  1507. default:
  1508. elog(NOTICE, "unknown node tag %d in attribute_used()", nodeTag(node));
  1509. elog(NOTICE, "Node is: %s", nodeToString(node));
  1510. break;
  1513. }
  1514. }
  1517. static void
  1518. apply_RIR_view(Node **nodePtr, int rt_index, RangeTblEntry *rte, List *tlist, int *modified, int sublevels_up)
  1519. {
  1520. Node    *node = *nodePtr;
  1522. if (node == NULL)
  1523. return;
  1525. switch (nodeTag(node))
  1526. {
  1527. case T_TargetEntry:
  1528. {
  1529. TargetEntry *tle = (TargetEntry *) node;
  1531. apply_RIR_view(
  1532.    (Node **) (&(tle->expr)),
  1533.    rt_index,
  1534.    rte,
  1535.    tlist,
  1536.    modified,
  1537.    sublevels_up);
  1538. }
  1539. break;
  1541. case T_Aggref:
  1542. {
  1543. Aggref    *aggref = (Aggref *) node;
  1545. apply_RIR_view(
  1546.    (Node **) (&(aggref->target)),
  1547.    rt_index,
  1548.    rte,
  1549.    tlist,
  1550.    modified,
  1551.    sublevels_up);
  1552. }
  1553. break;
  1555. case T_GroupClause:
  1556. break;
  1558. case T_Expr:
  1559. {
  1560. Expr    *exp = (Expr *) node;
  1562. apply_RIR_view(
  1563.    (Node **) (&(exp->args)),
  1564.    rt_index,
  1565.    rte,
  1566.    tlist,
  1567.    modified,
  1568.    sublevels_up);
  1569. }
  1570. break;
  1572. case T_Iter:
  1573. {
  1574. Iter    *iter = (Iter *) node;
  1576. apply_RIR_view(
  1577.    (Node **) (&(iter->iterexpr)),
  1578.    rt_index,
  1579.    rte,
  1580.    tlist,
  1581.    modified,
  1582.    sublevels_up);
  1583. }
  1584. break;
  1586. case T_ArrayRef:
  1587. {
  1588. ArrayRef   *ref = (ArrayRef *) node;
  1590. apply_RIR_view(
  1591.    (Node **) (&(ref->refupperindexpr)),
  1592.    rt_index,
  1593.    rte,
  1594.    tlist,
  1595.    modified,
  1596.    sublevels_up);
  1597. apply_RIR_view(
  1598.    (Node **) (&(ref->reflowerindexpr)),
  1599.    rt_index,
  1600.    rte,
  1601.    tlist,
  1602.    modified,
  1603.    sublevels_up);
  1604. apply_RIR_view(
  1605.    (Node **) (&(ref->refexpr)),
  1606.    rt_index,
  1607.    rte,
  1608.    tlist,
  1609.    modified,
  1610.    sublevels_up);
  1611. apply_RIR_view(
  1612.    (Node **) (&(ref->refassgnexpr)),
  1613.    rt_index,
  1614.    rte,
  1615.    tlist,
  1616.    modified,
  1617.    sublevels_up);
  1618. }
  1619. break;
  1621. case T_Var:
  1622. {
  1623. Var    *var = (Var *) node;
  1625. if (var->varlevelsup == sublevels_up &&
  1626. var->varno == rt_index)
  1627. {
  1628. Node    *exp;
  1630. if (var->varattno < 0)
  1631. elog(ERROR, "system column %s not available - %s is a view", get_attname(rte->relid, var->varattno), rte->relname);
  1632. exp = FindMatchingTLEntry(
  1633.   tlist,
  1634.   get_attname(rte->relid,
  1635.   var->varattno));
  1637. if (exp == NULL)
  1638. {
  1639. *nodePtr = make_null(var->vartype);
  1640. return;
  1641. }
  1643. exp = copyObject(exp);
  1644. if (var->varlevelsup > 0)
  1645. apply_RIR_adjust_sublevel(exp, var->varlevelsup);
  1646. *nodePtr = exp;
  1647. *modified = TRUE;
  1648. }
  1649. }
  1650. break;
  1652. case T_Param:
  1653. break;
  1655. case T_Const:
  1656. break;
  1658. case T_List:
  1659. {
  1660. List    *l;
  1662. foreach(l, (List *) node)
  1663. apply_RIR_view(
  1664.    (Node **) (&(lfirst(l))),
  1665.    rt_index,
  1666.    rte,
  1667.    tlist,
  1668.    modified,
  1669.    sublevels_up);
  1670. }
  1671. break;
  1673. case T_SubLink:
  1674. {
  1675. SubLink    *sub = (SubLink *) node;
  1676. List    *tmp_lefthand,
  1677.    *tmp_oper;
  1679. apply_RIR_view(
  1680.    (Node **) (&(sub->lefthand)),
  1681.    rt_index,
  1682.    rte,
  1683.    tlist,
  1684.    modified,
  1685.    sublevels_up);
  1687. apply_RIR_view(
  1688.    (Node **) (&(sub->subselect)),
  1689.    rt_index,
  1690.    rte,
  1691.    tlist,
  1692.    modified,
  1693.    sublevels_up + 1);
  1695. /***S*I***/
  1696. tmp_lefthand = sub->lefthand;
  1697. foreach(tmp_oper, sub->oper)
  1698. {
  1699. lfirst(((Expr *) lfirst(tmp_oper))->args) =
  1700. lfirst(tmp_lefthand);
  1701. tmp_lefthand = lnext(tmp_lefthand);
  1702. }
  1703. }
  1704. break;
  1706. case T_Query:
  1707. {
  1708. Query    *qry = (Query *) node;
  1710. apply_RIR_view(
  1711.    (Node **) (&(qry->targetList)),
  1712.    rt_index,
  1713.    rte,
  1714.    tlist,
  1715.    modified,
  1716.    sublevels_up);
  1718. apply_RIR_view(
  1719.    (Node **) (&(qry->qual)),
  1720.    rt_index,
  1721.    rte,
  1722.    tlist,
  1723.    modified,
  1724.    sublevels_up);
  1726. apply_RIR_view(
  1727.    (Node **) (&(qry->havingQual)),
  1728.    rt_index,
  1729.    rte,
  1730.    tlist,
  1731.    modified,
  1732.    sublevels_up);
  1733. }
  1734. break;
  1736. case T_CaseExpr:
  1737. {
  1738. CaseExpr   *exp = (CaseExpr *) node;
  1740. apply_RIR_view(
  1741.    (Node **) (&(exp->args)),
  1742.    rt_index,
  1743.    rte,
  1744.    tlist,
  1745.    modified,
  1746.    sublevels_up);
  1748. apply_RIR_view(
  1749.    (Node **) (&(exp->defresult)),
  1750.    rt_index,
  1751.    rte,
  1752.    tlist,
  1753.    modified,
  1754.    sublevels_up);
  1755. }
  1756. break;
  1758. case T_CaseWhen:
  1759. {
  1760. CaseWhen   *exp = (CaseWhen *) node;
  1762. apply_RIR_view(
  1763.    (Node **) (&(exp->expr)),
  1764.    rt_index,
  1765.    rte,
  1766.    tlist,
  1767.    modified,
  1768.    sublevels_up);
  1770. apply_RIR_view(
  1771.    (Node **) (&(exp->result)),
  1772.    rt_index,
  1773.    rte,
  1774.    tlist,
  1775.    modified,
  1776.    sublevels_up);
  1777. }
  1778. break;
  1780. default:
  1781. elog(NOTICE, "unknown node tag %d in apply_RIR_view()", nodeTag(node));
  1782. elog(NOTICE, "Node is: %s", nodeToString(node));
  1783. break;
  1784. }
  1785. }
  1787. extern void CheckSelectForUpdate(Query *rule_action); /* in analyze.c */
  1789. static void
  1790. ApplyRetrieveRule(Query *parsetree,
  1791.   RewriteRule *rule,
  1792.   int rt_index,
  1793.   int relation_level,
  1794.   Relation relation,
  1795.   int *modified)
  1796. {
  1797. Query    *rule_action = NULL;
  1798. Node    *rule_qual;
  1799. List    *rtable,
  1800.    *rt,
  1801.    *l;
  1802. int nothing,
  1803. rt_length;
  1804. int badsql = FALSE;
  1806. rule_qual = rule->qual;
  1807. if (rule->actions)
  1808. {
  1809. if (length(rule->actions) > 1) /* ??? because we don't handle
  1810.  * rules with more than one
  1811.  * action? -ay */
  1813. return;
  1814. rule_action = copyObject(lfirst(rule->actions));
  1815. nothing = FALSE;
  1816. }
  1817. else
  1818. nothing = TRUE;
  1820. rtable = copyObject(parsetree->rtable);
  1821. foreach(rt, rtable)
  1822. {
  1823. RangeTblEntry *rte = lfirst(rt);
  1825. /*
  1826.  * this is to prevent add_missing_vars_to_base_rels() from adding
  1827.  * a bogus entry to the new target list.
  1828.  */
  1829. rte->inFromCl = false;
  1830. }
  1831. rt_length = length(rtable);
  1833. rtable = nconc(rtable, copyObject(rule_action->rtable));
  1834. parsetree->rtable = rtable;
  1836. /* FOR UPDATE of view... */
  1837. foreach(l, parsetree->rowMark)
  1838. {
  1839. if (((RowMark *) lfirst(l))->rti == rt_index)
  1840. break;
  1841. }
  1842. if (l != NULL) /* oh, hell -:) */
  1843. {
  1844. RowMark    *newrm;
  1845. Index rti = 1;
  1846. List    *l2;
  1848. CheckSelectForUpdate(rule_action);
  1850. /*
  1851.  * We believe that rt_index is VIEW - nothing should be marked for
  1852.  * VIEW, but ACL check must be done. As for real tables of VIEW -
  1853.  * their rows must be marked, but we have to skip ACL check for
  1854.  * them.
  1855.  */
  1856. ((RowMark *) lfirst(l))->info &= ~ROW_MARK_FOR_UPDATE;
  1857. foreach(l2, rule_action->rtable)
  1858. {
  1860. /*
  1861.  * RTable of VIEW has two entries of VIEW itself - we use
  1862.  * relid to skip them.
  1863.  */
  1864. if (relation->rd_id != ((RangeTblEntry *) lfirst(l2))->relid)
  1865. {
  1866. newrm = makeNode(RowMark);
  1867. newrm->rti = rti + rt_length;
  1868. newrm->info = ROW_MARK_FOR_UPDATE;
  1869. lnext(l) = lcons(newrm, lnext(l));
  1870. l = lnext(l);
  1871. }
  1872. rti++;
  1873. }
  1874. }
  1876. rule_action->rtable = rtable;
  1877. OffsetVarNodes((Node *) rule_qual, rt_length, 0);
  1878. OffsetVarNodes((Node *) rule_action, rt_length, 0);
  1880. ChangeVarNodes((Node *) rule_qual,
  1881.    PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
  1882. ChangeVarNodes((Node *) rule_action,
  1883.    PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
  1885. if (relation_level)
  1886. {
  1887. apply_RIR_view((Node **) &parsetree, rt_index,
  1888.    (RangeTblEntry *) nth(rt_index - 1, rtable),
  1889.    rule_action->targetList, modified, 0);
  1890. apply_RIR_view((Node **) &rule_action, rt_index,
  1891.    (RangeTblEntry *) nth(rt_index - 1, rtable),
  1892.    rule_action->targetList, modified, 0);
  1893. }
  1894. else
  1895. {
  1896. HandleRIRAttributeRule(parsetree, rtable, rule_action->targetList,
  1897.    rt_index, rule->attrno, modified, &badsql);
  1898. }
  1899. if (*modified && !badsql)
  1900. {
  1901. AddQual(parsetree, rule_action->qual);
  1902. AddGroupClause(parsetree, rule_action->groupClause,
  1903.    rule_action->targetList);
  1904. AddHavingQual(parsetree, rule_action->havingQual);
  1905. parsetree->hasAggs = (rule_action->hasAggs || parsetree->hasAggs);
  1906. parsetree->hasSubLinks = (rule_action->hasSubLinks || parsetree->hasSubLinks);
  1907. }
  1908. }
  1911. static void
  1912. fireRIRonSubselect(Node *node)
  1913. {
  1914. if (node == NULL)
  1915. return;
  1917. switch (nodeTag(node))
  1918. {
  1919. case T_TargetEntry:
  1920. {
  1921. TargetEntry *tle = (TargetEntry *) node;
  1923. fireRIRonSubselect(
  1924.    (Node *) (tle->expr));
  1925. }
  1926. break;
  1928. case T_Aggref:
  1929. {
  1930. Aggref    *aggref = (Aggref *) node;
  1932. fireRIRonSubselect(
  1933.    (Node *) (aggref->target));
  1934. }
  1935. break;
  1937. case T_GroupClause:
  1938. break;
  1940. case T_Expr:
  1941. {
  1942. Expr    *exp = (Expr *) node;
  1944. fireRIRonSubselect(
  1945.    (Node *) (exp->args));
  1946. }
  1947. break;
  1949. case T_Iter:
  1950. {
  1951. Iter    *iter = (Iter *) node;
  1953. fireRIRonSubselect(
  1954.    (Node *) (iter->iterexpr));
  1955. }
  1956. break;
  1958. case T_ArrayRef:
  1959. {
  1960. ArrayRef   *ref = (ArrayRef *) node;
  1962. fireRIRonSubselect(
  1963.    (Node *) (ref->refupperindexpr));
  1964. fireRIRonSubselect(
  1965.    (Node *) (ref->reflowerindexpr));
  1966. fireRIRonSubselect(
  1967.    (Node *) (ref->refexpr));
  1968. fireRIRonSubselect(
  1969.    (Node *) (ref->refassgnexpr));
  1970. }
  1971. break;
  1973. case T_Var:
  1974. break;
  1976. case T_Param:
  1977. break;
  1979. case T_Const:
  1980. break;
  1982. case T_List:
  1983. {
  1984. List    *l;
  1986. foreach(l, (List *) node)
  1987. fireRIRonSubselect(
  1988.    (Node *) (lfirst(l)));
  1989. }
  1990. break;
  1992. case T_SubLink:
  1993. {
  1994. SubLink    *sub = (SubLink *) node;
  1995. Query    *qry;
  1997. fireRIRonSubselect(
  1998.    (Node *) (sub->lefthand));
  2000. qry = fireRIRrules((Query *) (sub->subselect));
  2002. fireRIRonSubselect(
  2003.    (Node *) qry);
  2005. sub->subselect = (Node *) qry;
  2006. }
  2007. break;
  2009. case T_CaseExpr:
  2010. {
  2011. CaseExpr   *exp = (CaseExpr *) node;
  2013. fireRIRonSubselect(
  2014.    (Node *) (exp->args));
  2016. fireRIRonSubselect(
  2017.    (Node *) (exp->defresult));
  2018. }
  2019. break;
  2021. case T_CaseWhen:
  2022. {
  2023. CaseWhen   *exp = (CaseWhen *) node;
  2025. fireRIRonSubselect(
  2026.    (Node *) (exp->expr));
  2028. fireRIRonSubselect(
  2029.    (Node *) (exp->result));
  2030. }
  2031. break;
  2033. case T_Query:
  2034. {
  2035. Query    *qry = (Query *) node;
  2037. fireRIRonSubselect(
  2038.    (Node *) (qry->targetList));
  2040. fireRIRonSubselect(
  2041.    (Node *) (qry->qual));
  2043. fireRIRonSubselect(
  2044.    (Node *) (qry->havingQual));
  2045. }
  2046. break;
  2048. default:
  2049. elog(NOTICE, "unknown node tag %d in fireRIRonSubselect()", nodeTag(node));
  2050. elog(NOTICE, "Node is: %s", nodeToString(node));
  2051. break;
  2054. }
  2055. }
  2058. /*
  2059.  * fireRIRrules -
  2060.  * Apply all RIR rules on each rangetable entry in a query
  2061.  */
  2062. static Query *
  2063. fireRIRrules(Query *parsetree)
  2064. {
  2065. int rt_index;
  2066. RangeTblEntry *rte;
  2067. Relation rel;
  2068. List    *locks;
  2069. RuleLock   *rules;
  2070. RewriteRule *rule;
  2071. RewriteRule RIRonly;
  2072. int modified;
  2073. int i;
  2074. List    *l;
  2076. rt_index = 0;
  2077. while (rt_index < length(parsetree->rtable))
  2078. {
  2079. ++rt_index;
  2081. rte = nth(rt_index - 1, parsetree->rtable);
  2083. if (!rangeTableEntry_used((Node *) parsetree, rt_index, 0))
  2084. {
  2086. /*
  2087.  * Unused range table entries must not be marked as coming
  2088.  * from a clause. Otherwise the planner will generate joins
  2089.  * over relations that in fact shouldn't be scanned at all and
  2090.  * the result will contain duplicates
  2091.  *
  2092.  * Jan
  2093.  *
  2094.  */
  2095. rte->inFromCl = FALSE;
  2096. continue;
  2097. }
  2099. rel = heap_openr(rte->relname);
  2100. if (rel->rd_rules == NULL)
  2101. {
  2102. heap_close(rel);
  2103. continue;
  2104. }
  2106. rules = rel->rd_rules;
  2107. locks = NIL;
  2109. /*
  2110.  * Collect the RIR rules that we must apply
  2111.  */
  2112. for (i = 0; i < rules->numLocks; i++)
  2113. {
  2114. rule = rules->rules[i];
  2115. if (rule->event != CMD_SELECT)
  2116. continue;
  2118. if (rule->attrno > 0 &&
  2119. !attribute_used((Node *) parsetree,
  2120. rt_index,
  2121. rule->attrno, 0))
  2122. continue;
  2124. locks = lappend(locks, rule);
  2125. }
  2127. /*
  2128.  * Check permissions
  2129.  */
  2130. checkLockPerms(locks, parsetree, rt_index);
  2132. /*
  2133.  * Now apply them
  2134.  */
  2135. foreach(l, locks)
  2136. {
  2137. rule = lfirst(l);
  2139. RIRonly.event = rule->event;
  2140. RIRonly.attrno = rule->attrno;
  2141. RIRonly.qual = rule->qual;
  2142. RIRonly.actions = rule->actions;
  2144. ApplyRetrieveRule(parsetree,
  2145.   &RIRonly,
  2146.   rt_index,
  2147.   RIRonly.attrno == -1,
  2148.   rel,
  2149.   &modified);
  2150. }
  2152. heap_close(rel);
  2153. }
  2155. fireRIRonSubselect((Node *) parsetree);
  2156. modifyAggrefQual((Node **) &(parsetree->qual), parsetree);
  2158. return parsetree;
  2159. }
  2162. /*
  2163.  * idea is to fire regular rules first, then qualified instead
  2164.  * rules and unqualified instead rules last. Any lemming is counted for.
  2165.  */
  2166. static List *
  2167. orderRules(List *locks)
  2168. {
  2169. List    *regular = NIL;
  2170. List    *instead_rules = NIL;
  2171. List    *instead_qualified = NIL;
  2172. List    *i;
  2174. foreach(i, locks)
  2175. {
  2176. RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
  2178. if (rule_lock->isInstead)
  2179. {
  2180. if (rule_lock->qual == NULL)
  2181. instead_rules = lappend(instead_rules, rule_lock);
  2182. else
  2183. instead_qualified = lappend(instead_qualified, rule_lock);
  2184. }
  2185. else
  2186. regular = lappend(regular, rule_lock);
  2187. }
  2188. regular = nconc(regular, instead_qualified);
  2189. return nconc(regular, instead_rules);
  2190. }
  2194. static Query *
  2195. CopyAndAddQual(Query *parsetree,
  2196.    List *actions,
  2197.    Node *rule_qual,
  2198.    int rt_index,
  2199.    CmdType event)
  2200. {
  2201. Query    *new_tree = (Query *) copyObject(parsetree);
  2202. Node    *new_qual = NULL;
  2203. Query    *rule_action = NULL;
  2205. if (actions)
  2206. rule_action = lfirst(actions);
  2207. if (rule_qual != NULL)
  2208. new_qual = (Node *) copyObject(rule_qual);
  2209. if (rule_action != NULL)
  2210. {
  2211. List    *rtable;
  2212. int rt_length;
  2214. rtable = new_tree->rtable;
  2215. rt_length = length(rtable);
  2216. rtable = nconc(rtable, copyObject(rule_action->rtable));
  2217. new_tree->rtable = rtable;
  2218. OffsetVarNodes(new_qual, rt_length, 0);
  2219. ChangeVarNodes(new_qual, PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
  2220. }
  2221. /* XXX -- where current doesn't work for instead nothing.... yet */
  2222. AddNotQual(new_tree, new_qual);
  2224. return new_tree;
  2225. }
  2229. /*
  2230.  * fireRules -
  2231.  *    Iterate through rule locks applying rules.
  2232.  *    All rules create their own parsetrees. Instead rules
  2233.  *    with rule qualification save the original parsetree
  2234.  *    and add their negated qualification to it. Real instead
  2235.  *    rules finally throw away the original parsetree.
  2236.  *
  2237.  *    remember: reality is for dead birds -- glass
  2238.  *
  2239.  */
  2240. static List *
  2241. fireRules(Query *parsetree,
  2242.   int rt_index,
  2243.   CmdType event,
  2244.   bool *instead_flag,
  2245.   List *locks,
  2246.   List **qual_products)
  2247. {
  2248. RewriteInfo *info;
  2249. List    *results = NIL;
  2250. List    *i;
  2252. /* choose rule to fire from list of rules */
  2253. if (locks == NIL)
  2254. return NIL;
  2256. locks = orderRules(locks); /* real instead rules last */
  2257. foreach(i, locks)
  2258. {
  2259. RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
  2260. Node    *qual,
  2261.    *event_qual;
  2262. List    *actions;
  2263. List    *r;
  2265. /*
  2266.  * Instead rules change the resultRelation of the query. So the
  2267.  * permission checks on the initial resultRelation would never be
  2268.  * done (this is normally done in the executor deep down). So we
  2269.  * must do it here. The result relations resulting from earlier
  2270.  * rewrites are already checked against the rules eventrelation
  2271.  * owner (during matchLocks) and have the skipAcl flag set.
  2272.  */
  2273. if (rule_lock->isInstead &&
  2274. parsetree->commandType != CMD_SELECT)
  2275. {
  2276. RangeTblEntry *rte;
  2277. int32 acl_rc;
  2278. int32 reqperm;
  2280. switch (parsetree->commandType)
  2281. {
  2282. case CMD_INSERT:
  2283. reqperm = ACL_AP;
  2284. break;
  2285. default:
  2286. reqperm = ACL_WR;
  2287. break;
  2288. }
  2290. rte = (RangeTblEntry *) nth(parsetree->resultRelation - 1,
  2291. parsetree->rtable);
  2292. if (!rte->skipAcl)
  2293. {
  2294. acl_rc = pg_aclcheck(rte->relname,
  2295.  GetPgUserName(), reqperm);
  2296. if (acl_rc != ACLCHECK_OK)
  2297. {
  2298. elog(ERROR, "%s: %s",
  2299.  rte->relname,
  2300.  aclcheck_error_strings[acl_rc]);
  2301. }
  2302. }
  2303. }
  2305. /* multiple rule action time */
  2306. *instead_flag = rule_lock->isInstead;
  2307. event_qual = rule_lock->qual;
  2308. actions = rule_lock->actions;
  2309. if (event_qual != NULL && *instead_flag)
  2310. {
  2311. Query    *qual_product;
  2312. RewriteInfo qual_info;
  2314. /* ----------
  2315.  * If there are instead rules with qualifications,
  2316.  * the original query is still performed. But all
  2317.  * the negated rule qualifications of the instead
  2318.  * rules are added so it does it's actions only
  2319.  * in cases where the rule quals of all instead
  2320.  * rules are false. Think of it as the default
  2321.  * action in a case. We save this in *qual_products
  2322.  * so deepRewriteQuery() can add it to the query
  2323.  * list after we mangled it up enough.
  2324.  * ----------
  2325.  */
  2326. if (*qual_products == NIL)
  2327. qual_product = parsetree;
  2328. else
  2329. qual_product = (Query *) nth(0, *qual_products);
  2331. qual_info.event = qual_product->commandType;
  2332. qual_info.new_varno = length(qual_product->rtable) + 2;
  2333. qual_product = CopyAndAddQual(qual_product,
  2334.   actions,
  2335.   event_qual,
  2336.   rt_index,
  2337.   event);
  2339. qual_info.rule_action = qual_product;
  2341. if (event == CMD_INSERT || event == CMD_UPDATE)
  2342. FixNew(&qual_info, qual_product);
  2344. *qual_products = lappend(NIL, qual_product);
  2345. }
  2347. foreach(r, actions)
  2348. {
  2349. Query    *rule_action = lfirst(r);
  2350. Node    *rule_qual = copyObject(event_qual);
  2352. if (rule_action->commandType == CMD_NOTHING)
  2353. continue;
  2355. /*--------------------------------------------------
  2356.  * We copy the qualifications of the parsetree
  2357.  * to the action and vice versa. So force
  2358.  * hasSubLinks if one of them has it.
  2359.  *
  2360.  * As of 6.4 only parsetree qualifications can
  2361.  * have sublinks. If this changes, we must make
  2362.  * this a node lookup at the end of rewriting.
  2363.  *
  2364.  * Jan
  2365.  *--------------------------------------------------
  2366.  */
  2367. if (parsetree->hasSubLinks && !rule_action->hasSubLinks)
  2368. {
  2369. rule_action = copyObject(rule_action);
  2370. rule_action->hasSubLinks = TRUE;
  2371. }
  2372. if (!parsetree->hasSubLinks && rule_action->hasSubLinks)
  2373. parsetree->hasSubLinks = TRUE;
  2375. /*--------------------------------------------------
  2376.  * Step 1:
  2377.  *   Rewrite current.attribute or current to tuple variable
  2378.  *   this appears to be done in parser?
  2379.  *--------------------------------------------------
  2380.  */
  2381. info = gatherRewriteMeta(parsetree, rule_action, rule_qual,
  2382.  rt_index, event, instead_flag);
  2384. /* handle escapable cases, or those handled by other code */
  2385. if (info->nothing)
  2386. {
  2387. if (*instead_flag)
  2388. return NIL;
  2389. else
  2390. continue;
  2391. }
  2393. if (info->action == info->event &&
  2394. info->event == CMD_SELECT)
  2395. continue;
  2397. /*
  2398.  * Event Qualification forces copying of parsetree and
  2399.  * splitting into two queries one w/rule_qual, one w/NOT
  2400.  * rule_qual. Also add user query qual onto rule action
  2401.  */
  2402. qual = parsetree->qual;
  2403. AddQual(info->rule_action, qual);
  2405. if (info->rule_qual != NULL)
  2406. AddQual(info->rule_action, info->rule_qual);
  2408. /*--------------------------------------------------
  2409.  * Step 2:
  2410.  *   Rewrite new.attribute w/ right hand side of target-list
  2411.  *   entry for appropriate field name in insert/update
  2412.  *--------------------------------------------------
  2413.  */
  2414. if ((info->event == CMD_INSERT) || (info->event == CMD_UPDATE))
  2415. FixNew(info, parsetree);
  2417. /*--------------------------------------------------
  2418.  * Step 3:
  2419.  *   rewriting due to retrieve rules
  2420.  *--------------------------------------------------
  2421.  */
  2422. info->rule_action->rtable = info->rt;
  2424. /*
  2425.  * ProcessRetrieveQuery(info->rule_action, info->rt,
  2426.  * &orig_instead_flag, TRUE);
  2427.  */
  2429. /*--------------------------------------------------
  2430.  * Step 4
  2431.  *   Simplify? hey, no algorithm for simplification... let
  2432.  *   the planner do it.
  2433.  *--------------------------------------------------
  2434.  */
  2435. results = lappend(results, info->rule_action);
  2437. pfree(info);
  2438. }
  2440. /* ----------
  2441.  * If this was an unqualified instead rule,
  2442.  * throw away an eventually saved 'default' parsetree
  2443.  * ----------
  2444.  */
  2445. if (event_qual == NULL && *instead_flag)
  2446. *qual_products = NIL;
  2447. }
  2448. return results;
  2449. }
  2453. static List *
  2454. RewriteQuery(Query *parsetree, bool *instead_flag, List **qual_products)
  2455. {
  2456. CmdType event;
  2457. List    *product_queries = NIL;
  2458. int result_relation = 0;
  2459. RangeTblEntry *rt_entry;
  2460. Relation rt_entry_relation = NULL;
  2461. RuleLock   *rt_entry_locks = NULL;
  2463. Assert(parsetree != NULL);
  2465. event = parsetree->commandType;
  2467. /*
  2468.  * SELECT rules are handled later when we have all the queries that
  2469.  * should get executed
  2470.  */
  2471. if (event == CMD_SELECT)
  2472. return NIL;
  2474. /*
  2475.  * Utilities aren't rewritten at all - why is this here?
  2476.  */
  2477. if (event == CMD_UTILITY)
  2478. return NIL;
  2480. /*
  2481.  * only for a delete may the targetlist be NULL
  2482.  */
  2483. if (event != CMD_DELETE)
  2484. Assert(parsetree->targetList != NULL);
  2486. result_relation = parsetree->resultRelation;
  2488. /*
  2489.  * the statement is an update, insert or delete - fire rules on it.
  2490.  */
  2491. rt_entry = rt_fetch(result_relation, parsetree->rtable);
  2492. rt_entry_relation = heap_openr(rt_entry->relname);
  2493. rt_entry_locks = rt_entry_relation->rd_rules;
  2494. heap_close(rt_entry_relation);
  2496. if (rt_entry_locks != NULL)
  2497. {
  2498. List    *locks = matchLocks(event, rt_entry_locks, result_relation, parsetree);
  2500. product_queries = fireRules(parsetree,
  2501. result_relation,
  2502. event,
  2503. instead_flag,
  2504. locks,
  2505. qual_products);
  2506. }
  2508. return product_queries;
  2510. }
  2513. /*
  2514.  * to avoid infinite recursion, we restrict the number of times a query
  2515.  * can be rewritten. Detecting cycles is left for the reader as an excercise.
  2516.  */
  2517. #ifndef REWRITE_INVOKE_MAX
  2518. #define REWRITE_INVOKE_MAX 10
  2519. #endif
  2521. static int numQueryRewriteInvoked = 0;
  2523. /*
  2524.  * deepRewriteQuery -
  2525.  *   rewrites the query and apply the rules again on the queries rewritten
  2526.  */
  2527. static List *
  2528. deepRewriteQuery(Query *parsetree)
  2529. {
  2530. List    *n;
  2531. List    *rewritten = NIL;
  2532. List    *result = NIL;
  2533. bool instead;
  2534. List    *qual_products = NIL;
  2538. if (++numQueryRewriteInvoked > REWRITE_INVOKE_MAX)
  2539. {
  2540. elog(ERROR, "query rewritten %d times, may contain cycles",
  2541.  numQueryRewriteInvoked - 1);
  2542. }
  2544. instead = FALSE;
  2545. result = RewriteQuery(parsetree, &instead, &qual_products);
  2547. foreach(n, result)
  2548. {
  2549. Query    *pt = lfirst(n);
  2550. List    *newstuff = NIL;
  2552. newstuff = deepRewriteQuery(pt);
  2553. if (newstuff != NIL)
  2554. rewritten = nconc(rewritten, newstuff);
  2555. }
  2557. /* ----------
  2558.  * qual_products are the original query with the negated
  2559.  * rule qualification of an instead rule
  2560.  * ----------
  2561.  */
  2562. if (qual_products != NIL)
  2563. rewritten = nconc(rewritten, qual_products);
  2565. /* ----------
  2566.  * The original query is appended last if not instead
  2567.  * because update and delete rule actions might not do
  2568.  * anything if they are invoked after the update or
  2569.  * delete is performed. The command counter increment
  2570.  * between the query execution makes the deleted (and
  2571.  * maybe the updated) tuples disappear so the scans
  2572.  * for them in the rule actions cannot find them.
  2573.  * ----------
  2574.  */
  2575. if (!instead)
  2576. rewritten = lappend(rewritten, parsetree);
  2578. return rewritten;
  2579. }
  2582. /*
  2583.  * QueryOneRewrite -
  2584.  *   rewrite one query
  2585.  */
  2586. static List *
  2587. QueryRewriteOne(Query *parsetree)
  2588. {
  2589. numQueryRewriteInvoked = 0;
  2591. /*
  2592.  * take a deep breath and apply all the rewrite rules - ay
  2593.  */
  2594. return deepRewriteQuery(parsetree);
  2595. }
  2598. /* ----------
  2599.  * RewritePreprocessQuery -
  2600.  * adjust details in the parsetree, the rule system
  2601.  * depends on
  2602.  * ----------
  2603.  */
  2604. static void
  2605. RewritePreprocessQuery(Query *parsetree)
  2606. {
  2607. /* ----------
  2608.  * if the query has a resultRelation, reassign the
  2609.  * result domain numbers to the attribute numbers in the
  2610.  * target relation. FixNew() depends on it when replacing
  2611.  * *new* references in a rule action by the expressions
  2612.  * from the rewritten query.
  2613.  * resjunk targets are somewhat arbitrarily given a resno of 0;
  2614.  * this is to prevent FixNew() from matching them to var nodes.
  2615.  * ----------
  2616.  */
  2617. if (parsetree->resultRelation > 0)
  2618. {
  2619. RangeTblEntry *rte;
  2620. Relation rd;
  2621. List    *tl;
  2623. rte = (RangeTblEntry *) nth(parsetree->resultRelation - 1,
  2624. parsetree->rtable);
  2625. rd = heap_openr(rte->relname);
  2627. foreach(tl, parsetree->targetList)
  2628. {
  2629. TargetEntry *tle = (TargetEntry *) lfirst(tl);
  2631. if (! tle->resdom->resjunk)
  2632. tle->resdom->resno = attnameAttNum(rd, tle->resdom->resname);
  2633. else
  2634. tle->resdom->resno = 0;
  2635. }
  2637. heap_close(rd);
  2638. }
  2639. }
  2642. /*
  2643.  * BasicQueryRewrite -
  2644.  *   rewrite one query via query rewrite system, possibly returning 0
  2645.  *   or many queries
  2646.  */
  2647. static List *
  2648. BasicQueryRewrite(Query *parsetree)
  2649. {
  2650. List    *querylist;
  2651. List    *results = NIL;
  2652. List    *l;
  2653. Query    *query;
  2655. /*
  2656.  * Step 1
  2657.  *
  2658.  * There still seems something broken with the resdom numbers so we
  2659.  * reassign them first.
  2660.  */
  2661. RewritePreprocessQuery(parsetree);
  2663. /*
  2664.  * Step 2
  2665.  *
  2666.  * Apply all non-SELECT rules possibly getting 0 or many queries
  2667.  */
  2668. querylist = QueryRewriteOne(parsetree);
  2670. /*
  2671.  * Step 3
  2672.  *
  2673.  * Apply all the RIR rules on each query
  2674.  */
  2675. foreach(l, querylist)
  2676. {
  2677. query = fireRIRrules((Query *) lfirst(l));
  2679. /*
  2680.  * If the query was marked having aggregates, check if this is
  2681.  * still true after rewriting. This check must get expanded when
  2682.  * someday aggregates can appear somewhere else than in the
  2683.  * targetlist or the having qual.
  2684.  */
  2685. if (query->hasAggs)
  2686. query->hasAggs = checkQueryHasAggs((Node *) (query->targetList))
  2687. | checkQueryHasAggs((Node *) (query->havingQual));
  2688. query->hasSubLinks = checkQueryHasSubLink((Node *) (query->qual))
  2689. | checkQueryHasSubLink((Node *) (query->havingQual));
  2690. results = lappend(results, query);
  2691. }
  2692. return results;
  2693. }
  2695. /*
  2696.  * QueryRewrite -
  2697.  *   Primary entry point to the query rewriter.
  2698.  *   Rewrite one query via query rewrite system, possibly returning 0
  2699.  *   or many queries.
  2700.  *
  2701.  * NOTE: The code in QueryRewrite was formerly in pg_parse_and_plan(), and was
  2702.  * moved here so that it would be invoked during EXPLAIN.  The division of
  2703.  * labor between this routine and BasicQueryRewrite is not obviously correct
  2704.  * ... at least not to me ... tgl 5/99.
  2705.  */
  2706. List *
  2707. QueryRewrite(Query *parsetree)
  2708. {
  2709. List    *rewritten,
  2710.    *rewritten_item;
  2712. /***S*I***/
  2714. /*
  2715.  * Rewrite Union, Intersect and Except Queries to normal Union Queries
  2716.  * using IN and NOT IN subselects
  2717.  */
  2718. if (parsetree->intersectClause)
  2719. parsetree = Except_Intersect_Rewrite(parsetree);
  2721. /* Rewrite basic queries (retrieve, append, delete, replace) */
  2722. rewritten = BasicQueryRewrite(parsetree);
  2724. /*
  2725.  * Rewrite the UNIONS.
  2726.  */
  2727. foreach(rewritten_item, rewritten)
  2728. {
  2729. Query    *qry = (Query *) lfirst(rewritten_item);
  2730. List    *union_result = NIL;
  2731. List    *union_item;
  2733. foreach(union_item, qry->unionClause)
  2734. {
  2735. union_result = nconc(union_result,
  2736. BasicQueryRewrite((Query *) lfirst(union_item)));
  2737. }
  2738. qry->unionClause = union_result;
  2739. }
  2741. return rewritten;
  2742. }
  2744. /***S*I***/
  2745. /* This function takes two targetlists as arguments and checks if the
  2746.  * targetlists are compatible (i.e. both select for the same number of
  2747.  * attributes and the types are compatible */
  2748. static void
  2749. check_targetlists_are_compatible(List *prev_target, List *current_target)
  2750. {
  2751. List    *tl,
  2752.    *next_target;
  2753. int prev_len = 0,
  2754. next_len = 0;
  2756. foreach(tl, prev_target)
  2757. if (!((TargetEntry *) lfirst(tl))->resdom->resjunk)
  2758. prev_len++;
  2760. foreach(next_target, current_target)
  2761. if (!((TargetEntry *) lfirst(next_target))->resdom->resjunk)
  2762. next_len++;
  2764. if (prev_len != next_len)
  2765. elog(ERROR, "Each UNION | EXCEPT | INTERSECT query must have the same number of columns.");
  2767. foreach(next_target, current_target)
  2768. {
  2769. Oid itype;
  2770. Oid otype;
  2772. otype = ((TargetEntry *) lfirst(prev_target))->resdom->restype;
  2773. itype = ((TargetEntry *) lfirst(next_target))->resdom->restype;
  2775. /* one or both is a NULL column? then don't convert... */
  2776. if (otype == InvalidOid)
  2777. {
  2778. /* propagate a known type forward, if available */
  2779. if (itype != InvalidOid)
  2780. ((TargetEntry *) lfirst(prev_target))->resdom->restype = itype;
  2781. #ifdef NOT_USED
  2782. else
  2783. {
  2784. ((TargetEntry *) lfirst(prev_target))->resdom->restype = UNKNOWNOID;
  2785. ((TargetEntry *) lfirst(next_target))->resdom->restype = UNKNOWNOID;
  2786. }
  2787. #endif
  2788. }
  2789. else if (itype == InvalidOid)
  2790. {
  2791. }
  2792. /* they don't match in type? then convert... */
  2793. else if (itype != otype)
  2794. {
  2795. Node    *expr;
  2797. expr = ((TargetEntry *) lfirst(next_target))->expr;
  2798. expr = CoerceTargetExpr(NULL, expr, itype, otype);
  2799. if (expr == NULL)
  2800. {
  2801. elog(ERROR, "Unable to transform %s to %s"
  2802.  "ntEach UNION | EXCEPT | INTERSECT clause must have compatible target types",
  2803.  typeidTypeName(itype),
  2804.  typeidTypeName(otype));
  2805. }
  2806. ((TargetEntry *) lfirst(next_target))->expr = expr;
  2807. ((TargetEntry *) lfirst(next_target))->resdom->restype = otype;
  2808. }
  2810. /* both are UNKNOWN? then evaluate as text... */
  2811. else if (itype == UNKNOWNOID)
  2812. {
  2813. ((TargetEntry *) lfirst(next_target))->resdom->restype = TEXTOID;
  2814. ((TargetEntry *) lfirst(prev_target))->resdom->restype = TEXTOID;
  2815. }
  2816. prev_target = lnext(prev_target);
  2817. }
  2818. }
  2820. /***S*I***/
  2821. /* Rewrites UNION INTERSECT and EXCEPT queries to semantiacally equivalent
  2822.  * queries that use IN and NOT IN subselects.
  2823.  *
  2824.  * The operator tree is attached to 'intersectClause' (see rule
  2825.  * 'SelectStmt' in gram.y) of the 'parsetree' given as an
  2826.  * argument. First we remember some clauses (the sortClause, the
  2827.  * unique flag etc.)  Then we translate the operator tree to DNF
  2828.  * (disjunctive normal form) by 'cnfify'. (Note that 'cnfify' produces
  2829.  * CNF but as we exchanged ANDs with ORs in function A_Expr_to_Expr()
  2830.  * earlier we get DNF after exchanging ANDs and ORs again in the
  2831.  * result.) Now we create a new query by evaluating the new operator
  2832.  * tree which is in DNF now. For every AND we create an entry in the
  2833.  * union list and for every OR we create an IN subselect. (NOT IN
  2834.  * subselects are created for OR NOT nodes). The first entry of the
  2835.  * union list is handed back but before that the remembered clauses
  2836.  * (sortClause etc) are attached to the new top Node (Note that the
  2837.  * new top Node can differ from the parsetree given as argument because of
  2838.  * the translation to DNF. That's why we have to remember the sortClause or
  2839.  * unique flag!) */
  2840. static Query *
  2841. Except_Intersect_Rewrite(Query *parsetree)
  2842. {
  2844. SubLink    *n;
  2845. Query    *result,
  2846.    *intersect_node;
  2847. List    *elist,
  2848.    *intersect_list = NIL,
  2849.    *intersect,
  2850.    *intersectClause;
  2851. List    *union_list = NIL,
  2852.    *sortClause;
  2853. List    *left_expr,
  2854.    *right_expr,
  2855.    *resnames = NIL;
  2856. char    *op,
  2857.    *uniqueFlag,
  2858.    *into;
  2859. bool isBinary,
  2860. isPortal,
  2861. isTemp;
  2862. CmdType commandType = CMD_SELECT;
  2863. List    *rtable_insert = NIL;
  2865. List    *prev_target = NIL;
  2867. /*
  2868.  * Remember the Resnames of the given parsetree's targetlist (these
  2869.  * are the resnames of the first Select Statement of the query
  2870.  * formulated by the user and he wants the columns named by these
  2871.  * strings. The transformation to DNF can cause another Select
  2872.  * Statment to be the top one which uses other names for its columns.
  2873.  * Therefore we remeber the original names and attach them to the
  2874.  * targetlist of the new topmost Node at the end of this function
  2875.  */
  2876. foreach(elist, parsetree->targetList)
  2877. {
  2878. TargetEntry *tent = (TargetEntry *) lfirst(elist);
  2880. resnames = lappend(resnames, tent->resdom->resname);
  2881. }
  2883. /*
  2884.  * If the Statement is an INSERT INTO ... (SELECT...) statement using
  2885.  * UNIONs, INTERSECTs or EXCEPTs and the transformation to DNF makes
  2886.  * another Node to the top node we have to transform the new top node
  2887.  * to an INSERT node and the original INSERT node to a SELECT node
  2888.  */
  2889. if (parsetree->commandType == CMD_INSERT)
  2890. {
  2891. parsetree->commandType = CMD_SELECT;
  2892. commandType = CMD_INSERT;
  2893. parsetree->resultRelation = 0;
  2895. /*
  2896.  * The result relation ( = the one to insert into) has to be
  2897.  * attached to the rtable list of the new top node
  2898.  */
  2899. rtable_insert = nth(length(parsetree->rtable) - 1, parsetree->rtable);
  2900. }
  2902. /*
  2903.  * Save some items, to be able to attach them to the resulting top
  2904.  * node at the end of the function
  2905.  */
  2906. sortClause = parsetree->sortClause;
  2907. uniqueFlag = parsetree->uniqueFlag;
  2908. into = parsetree->into;
  2909. isBinary = parsetree->isBinary;
  2910. isPortal = parsetree->isPortal;
  2911. isTemp = parsetree->isTemp;
  2913. /*
  2914.  * The operator tree attached to parsetree->intersectClause is still
  2915.  * 'raw' ( = the leaf nodes are still SelectStmt nodes instead of
  2916.  * Query nodes) So step through the tree and transform the nodes using
  2917.  * parse_analyze().
  2918.  *
  2919.  * The parsetree (given as an argument to Except_Intersect_Rewrite()) has
  2920.  * already been transformed and transforming it again would cause
  2921.  * troubles.  So we give the 'raw' version (of the cooked parsetree)
  2922.  * to the function to prevent an additional transformation. Instead we
  2923.  * hand back the 'cooked' version also given as an argument to
  2924.  * intersect_tree_analyze()
  2925.  */
  2926. intersectClause =
  2927. (List *) intersect_tree_analyze((Node *) parsetree->intersectClause,
  2928.  (Node *) lfirst(parsetree->unionClause),
  2929. (Node *) parsetree);
  2931. /* intersectClause is no longer needed so set it to NIL */
  2932. parsetree->intersectClause = NIL;
  2934. /*
  2935.  * unionClause will be needed later on but the list it delivered is no
  2936.  * longer needed, so set it to NIL
  2937.  */
  2938. parsetree->unionClause = NIL;
  2940. /*
  2941.  * Transform the operator tree to DNF (remember ANDs and ORs have been
  2942.  * exchanged, that's why we get DNF by using cnfify)
  2943.  *
  2944.  * After the call, explicit ANDs are removed and all AND operands are
  2945.  * simply items in the intersectClause list
  2946.  */
  2947. intersectClause = cnfify((Expr *) intersectClause, true);
  2949. /*
  2950.  * For every entry of the intersectClause list we generate one entry
  2951.  * in the union_list
  2952.  */
  2953. foreach(intersect, intersectClause)
  2954. {
  2956. /*
  2957.  * for every OR we create an IN subselect and for every OR NOT we
  2958.  * create a NOT IN subselect, so first extract all the Select
  2959.  * Query nodes from the tree (that contains only OR or OR NOTs any
  2960.  * more because we did a transformation to DNF
  2961.  *
  2962.  * There must be at least one node that is not negated (i.e. just OR
  2963.  * and not OR NOT) and this node will be the first in the list
  2964.  * returned
  2965.  */
  2966. intersect_list = NIL;
  2967. create_intersect_list((Node *) lfirst(intersect), &intersect_list);
  2969. /*
  2970.  * This one will become the Select Query node, all other nodes are
  2971.  * transformed into subselects under this node!
  2972.  */
  2973. intersect_node = (Query *) lfirst(intersect_list);
  2974. intersect_list = lnext(intersect_list);
  2976. /*
  2977.  * Check if all Select Statements use the same number of
  2978.  * attributes and if all corresponding attributes are of the same
  2979.  * type
  2980.  */
  2981. if (prev_target)
  2982. check_targetlists_are_compatible(prev_target, intersect_node->targetList);
  2983. prev_target = intersect_node->targetList;
  2984. /* End of check for corresponding targetlists */
  2986. /*
  2987.  * Transform all nodes remaining into subselects and add them to
  2988.  * the qualifications of the Select Query node
  2989.  */
  2990. while (intersect_list != NIL)
  2991. {
  2993. n = makeNode(SubLink);
  2995. /* Here we got an OR so transform it to an IN subselect */
  2996. if (IsA(lfirst(intersect_list), Query))
  2997. {
  2999. /*
  3000.  * Check if all Select Statements use the same number of
  3001.  * attributes and if all corresponding attributes are of
  3002.  * the same type
  3003.  */
  3004. check_targetlists_are_compatible(prev_target,
  3005.  ((Query *) lfirst(intersect_list))->targetList);
  3006. /* End of check for corresponding targetlists */
  3008. n->subselect = lfirst(intersect_list);
  3009. op = "=";
  3010. n->subLinkType = ANY_SUBLINK;
  3011. n->useor = false;
  3012. }
  3014. /*
  3015.  * Here we got an OR NOT node so transform it to a NOT IN
  3016.  * subselect
  3017.  */
  3018. else
  3019. {
  3021. /*
  3022.  * Check if all Select Statements use the same number of
  3023.  * attributes and if all corresponding attributes are of
  3024.  * the same type
  3025.  */
  3026. check_targetlists_are_compatible(prev_target,
  3027.  ((Query *) lfirst(((Expr *) lfirst(intersect_list))->args))->targetList);
  3028. /* End of check for corresponding targetlists */
  3030. n->subselect = (Node *) lfirst(((Expr *) lfirst(intersect_list))->args);
  3031. op = "<>";
  3032. n->subLinkType = ALL_SUBLINK;
  3033. n->useor = true;
  3034. }
  3036. /*
  3037.  * Prepare the lefthand side of the Sublinks: All the entries
  3038.  * of the targetlist must be (IN) or must not be (NOT IN) the
  3039.  * subselect
  3040.  */
  3041. foreach(elist, intersect_node->targetList)
  3042. {
  3043. Node    *expr = lfirst(elist);
  3044. TargetEntry *tent = (TargetEntry *) expr;
  3046. n->lefthand = lappend(n->lefthand, tent->expr);
  3047. }
  3049. /*
  3050.  * The first arguments of oper also have to be created for the
  3051.  * sublink (they are the same as the lefthand side!)
  3052.  */
  3053. left_expr = n->lefthand;
  3054. right_expr = ((Query *) (n->subselect))->targetList;
  3056. foreach(elist, left_expr)
  3057. {
  3058. Node    *lexpr = lfirst(elist);
  3059. Node    *rexpr = lfirst(right_expr);
  3060. TargetEntry *tent = (TargetEntry *) rexpr;
  3061. Expr    *op_expr;
  3063. op_expr = make_op(op, lexpr, tent->expr);
  3065. n->oper = lappend(n->oper, op_expr);
  3066. right_expr = lnext(right_expr);
  3067. }
  3069. /*
  3070.  * If the Select Query node has aggregates in use add all the
  3071.  * subselects to the HAVING qual else to the WHERE qual
  3072.  */
  3073. if (intersect_node->hasAggs == false)
  3074. AddQual(intersect_node, (Node *) n);
  3075. else
  3076. AddHavingQual(intersect_node, (Node *) n);
  3078. /* Now we got sublinks */
  3079. intersect_node->hasSubLinks = true;
  3080. intersect_list = lnext(intersect_list);
  3081. }
  3082. intersect_node->intersectClause = NIL;
  3083. union_list = lappend(union_list, intersect_node);
  3084. }
  3086. /* The first entry to union_list is our new top node */
  3087. result = (Query *) lfirst(union_list);
  3088. /* attach the rest to unionClause */
  3089. result->unionClause = lnext(union_list);
  3090. /* Attach all the items remembered in the beginning of the function */
  3091. result->sortClause = sortClause;
  3092. result->uniqueFlag = uniqueFlag;
  3093. result->into = into;
  3094. result->isPortal = isPortal;
  3095. result->isBinary = isBinary;
  3096. result->isTemp = isTemp;
  3098. /*
  3099.  * The relation to insert into is attached to the range table of the
  3100.  * new top node
  3101.  */
  3102. if (commandType == CMD_INSERT)
  3103. {
  3104. result->rtable = lappend(result->rtable, rtable_insert);
  3105. result->resultRelation = length(result->rtable);
  3106. result->commandType = commandType;
  3107. }
  3109. /*
  3110.  * The resnames of the originally first SelectStatement are attached
  3111.  * to the new first SelectStatement
  3112.  */
  3113. foreach(elist, result->targetList)
  3114. {
  3115. TargetEntry *tent = (TargetEntry *) lfirst(elist);
  3117. tent->resdom->resname = lfirst(resnames);
  3118. resnames = lnext(resnames);
  3119. }
  3120. return result;
  3121. }
  3123. /* Create a list of nodes that are either Query nodes of NOT Expr
  3124.  * nodes followed by a Query node. The tree given in ptr contains at
  3125.  * least one non negated Query node. This node is attached to the
  3126.  * beginning of the list */
  3128. static void
  3129. create_intersect_list(Node *ptr, List **intersect_list)
  3130. {
  3131. List    *arg;
  3133. if (IsA(ptr, Query))
  3134. {
  3135. /* The non negated node is attached at the beginning (lcons) */
  3136. *intersect_list = lcons(ptr, *intersect_list);
  3137. return;
  3138. }
  3140. if (IsA(ptr, Expr))
  3141. {
  3142. if (((Expr *) ptr)->opType == NOT_EXPR)
  3143. {
  3144. /* negated nodes are appended to the end (lappend) */
  3145. *intersect_list = lappend(*intersect_list, ptr);
  3146. return;
  3147. }
  3148. else
  3149. {
  3150. foreach(arg, ((Expr *) ptr)->args)
  3151. create_intersect_list(lfirst(arg), intersect_list);
  3152. return;
  3153. }
  3154. return;
  3155. }
  3156. }
  3158. /* The nodes given in 'tree' are still 'raw' so 'cook' them using parse_analyze().
  3159.  * The node given in first_select has already been cooked, so don't transform
  3160.  * it again but return a pointer to the previously cooked version given in 'parsetree'
  3161.  * instead. */
  3162. static Node *
  3163. intersect_tree_analyze(Node *tree, Node *first_select, Node *parsetree)
  3164. {
  3165. Node    *result = (Node *) NIL;
  3166. List    *arg;
  3168. if (IsA(tree, SelectStmt))
  3169. {
  3171. /*
  3172.  * If we get to the tree given in first_select return parsetree
  3173.  * instead of performing parse_analyze()
  3174.  */
  3175. if (tree == first_select)
  3176. result = parsetree;
  3177. else
  3178. {
  3179. /* transform the 'raw' nodes to 'cooked' Query nodes */
  3180. List    *qtree = parse_analyze(lcons(tree, NIL), NULL);
  3182. result = (Node *) lfirst(qtree);
  3183. }
  3184. }
  3186. if (IsA(tree, Expr))
  3187. {
  3188. /* Call recursively for every argument of the node */
  3189. foreach(arg, ((Expr *) tree)->args)
  3190. lfirst(arg) = intersect_tree_analyze(lfirst(arg), first_select, parsetree);
  3191. result = tree;
  3192. }
  3193. return result;
  3194. }