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

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

数据库系统

开发平台：

Unix_Linux

rewriteManip.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * rewriteManip.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/rewriteManip.c,v 1.32 1999/05/26 12:55:48 momjian Exp $
  10.  *
  11.  *-------------------------------------------------------------------------
  12.  */
  13. #include <string.h>
  14. #include "postgres.h"
  15. #include "nodes/pg_list.h"
  16. #include "utils/elog.h"
  17. #include "nodes/nodes.h"
  18. #include "nodes/relation.h"
  19. #include "nodes/primnodes.h"
  20. #include "parser/parsetree.h" /* for getrelid() */
  21. #include "utils/lsyscache.h"
  22. #include "utils/builtins.h"
  23. #include "rewrite/rewriteHandler.h"
  24. #include "rewrite/rewriteManip.h"
  25. #include "rewrite/rewriteSupport.h"
  26. #include "rewrite/locks.h"
  28. #include "nodes/plannodes.h"
  29. #include "optimizer/clauses.h"
  31. static void ResolveNew(RewriteInfo *info, List *targetlist,
  32.    Node **node, int sublevels_up);
  35. /*
  36.  * OffsetVarnodes -
  37.  */
  38. void
  39. OffsetVarNodes(Node *node, int offset, int sublevels_up)
  40. {
  41. if (node == NULL)
  42. return;
  44. switch (nodeTag(node))
  45. {
  46. case T_TargetEntry:
  47. {
  48. TargetEntry *tle = (TargetEntry *) node;
  50. OffsetVarNodes(
  51.    (Node *) (tle->expr),
  52.    offset,
  53.    sublevels_up);
  54. }
  55. break;
  57. case T_Aggref:
  58. {
  59. Aggref    *aggref = (Aggref *) node;
  61. OffsetVarNodes(
  62.    (Node *) (aggref->target),
  63.    offset,
  64.    sublevels_up);
  65. }
  66. break;
  68. case T_GroupClause:
  69. break;
  71. case T_Expr:
  72. {
  73. Expr    *exp = (Expr *) node;
  75. OffsetVarNodes(
  76.    (Node *) (exp->args),
  77.    offset,
  78.    sublevels_up);
  79. }
  80. break;
  82. case T_Iter:
  83. {
  84. Iter    *iter = (Iter *) node;
  86. OffsetVarNodes(
  87.    (Node *) (iter->iterexpr),
  88.    offset,
  89.    sublevels_up);
  90. }
  91. break;
  93. case T_ArrayRef:
  94. {
  95. ArrayRef   *ref = (ArrayRef *) node;
  97. OffsetVarNodes(
  98.    (Node *) (ref->refupperindexpr),
  99.    offset,
  100.    sublevels_up);
  101. OffsetVarNodes(
  102.    (Node *) (ref->reflowerindexpr),
  103.    offset,
  104.    sublevels_up);
  105. OffsetVarNodes(
  106.    (Node *) (ref->refexpr),
  107.    offset,
  108.    sublevels_up);
  109. OffsetVarNodes(
  110.    (Node *) (ref->refassgnexpr),
  111.    offset,
  112.    sublevels_up);
  113. }
  114. break;
  116. case T_Var:
  117. {
  118. Var    *var = (Var *) node;
  120. if (var->varlevelsup == sublevels_up)
  121. {
  122. var->varno += offset;
  123. var->varnoold += offset;
  124. }
  125. }
  126. break;
  128. case T_Param:
  129. break;
  131. case T_Const:
  132. break;
  134. case T_List:
  135. {
  136. List    *l;
  138. foreach(l, (List *) node)
  139. OffsetVarNodes(
  140.    (Node *) lfirst(l),
  141.    offset,
  142.    sublevels_up);
  143. }
  144. break;
  146. case T_SubLink:
  147. {
  148. SubLink    *sub = (SubLink *) node;
  149. List    *tmp_oper,
  150.    *tmp_lefthand;
  152. /*
  153.  * We also have to adapt the variables used in
  154.  * sub->lefthand and sub->oper
  155.  */
  156. OffsetVarNodes(
  157.    (Node *) (sub->lefthand),
  158.    offset,
  159.    sublevels_up);
  161. OffsetVarNodes(
  162.    (Node *) (sub->subselect),
  163.    offset,
  164.    sublevels_up + 1);
  166. /***S*I***/
  168. /*
  169.  * Make sure the first argument of sub->oper points to the
  170.  * same var as sub->lefthand does otherwise we will run
  171.  * into troubles using aggregates (aggno will not be set
  172.  * correctly)
  173.  */
  174. tmp_lefthand = sub->lefthand;
  175. foreach(tmp_oper, sub->oper)
  176. {
  177. lfirst(((Expr *) lfirst(tmp_oper))->args) =
  178. lfirst(tmp_lefthand);
  179. tmp_lefthand = lnext(tmp_lefthand);
  180. }
  181. }
  182. break;
  184. case T_Query:
  185. {
  186. Query    *qry = (Query *) node;
  188. OffsetVarNodes(
  189.    (Node *) (qry->targetList),
  190.    offset,
  191.    sublevels_up);
  193. OffsetVarNodes(
  194.    (Node *) (qry->qual),
  195.    offset,
  196.    sublevels_up);
  198. OffsetVarNodes(
  199.    (Node *) (qry->havingQual),
  200.    offset,
  201.    sublevels_up);
  202. }
  203. break;
  205. case T_CaseExpr:
  206. {
  207. CaseExpr   *exp = (CaseExpr *) node;
  209. OffsetVarNodes(
  210.    (Node *) (exp->args),
  211.    offset,
  212.    sublevels_up);
  214. OffsetVarNodes(
  215.    (Node *) (exp->defresult),
  216.    offset,
  217.    sublevels_up);
  218. }
  219. break;
  221. case T_CaseWhen:
  222. {
  223. CaseWhen   *exp = (CaseWhen *) node;
  225. OffsetVarNodes(
  226.    (Node *) (exp->expr),
  227.    offset,
  228.    sublevels_up);
  230. OffsetVarNodes(
  231.    (Node *) (exp->result),
  232.    offset,
  233.    sublevels_up);
  234. }
  235. break;
  237. default:
  238. elog(NOTICE, "unknown node tag %d in OffsetVarNodes()", nodeTag(node));
  239. elog(NOTICE, "Node is: %s", nodeToString(node));
  240. break;
  243. }
  244. }
  247. /*
  248.  * ChangeVarNodes -
  249.  */
  250. void
  251. ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
  252. {
  253. if (node == NULL)
  254. return;
  256. switch (nodeTag(node))
  257. {
  258. case T_TargetEntry:
  259. {
  260. TargetEntry *tle = (TargetEntry *) node;
  262. ChangeVarNodes(
  263.    (Node *) (tle->expr),
  264.    rt_index,
  265.    new_index,
  266.    sublevels_up);
  267. }
  268. break;
  270. case T_Aggref:
  271. {
  272. Aggref    *aggref = (Aggref *) node;
  274. ChangeVarNodes(
  275.    (Node *) (aggref->target),
  276.    rt_index,
  277.    new_index,
  278.    sublevels_up);
  279. }
  280. break;
  282. case T_GroupClause:
  283. break;
  285. case T_Expr:
  286. {
  287. Expr    *exp = (Expr *) node;
  289. ChangeVarNodes(
  290.    (Node *) (exp->args),
  291.    rt_index,
  292.    new_index,
  293.    sublevels_up);
  294. }
  295. break;
  297. case T_Iter:
  298. {
  299. Iter    *iter = (Iter *) node;
  301. ChangeVarNodes(
  302.    (Node *) (iter->iterexpr),
  303.    rt_index,
  304.    new_index,
  305.    sublevels_up);
  306. }
  307. break;
  309. case T_ArrayRef:
  310. {
  311. ArrayRef   *ref = (ArrayRef *) node;
  313. ChangeVarNodes(
  314.    (Node *) (ref->refupperindexpr),
  315.    rt_index,
  316.    new_index,
  317.    sublevels_up);
  318. ChangeVarNodes(
  319.    (Node *) (ref->reflowerindexpr),
  320.    rt_index,
  321.    new_index,
  322.    sublevels_up);
  323. ChangeVarNodes(
  324.    (Node *) (ref->refexpr),
  325.    rt_index,
  326.    new_index,
  327.    sublevels_up);
  328. ChangeVarNodes(
  329.    (Node *) (ref->refassgnexpr),
  330.    rt_index,
  331.    new_index,
  332.    sublevels_up);
  333. }
  334. break;
  336. case T_Var:
  337. {
  338. Var    *var = (Var *) node;
  340. if (var->varlevelsup == sublevels_up &&
  341. var->varno == rt_index)
  342. {
  343. var->varno = new_index;
  344. var->varnoold = new_index;
  345. }
  346. }
  347. break;
  349. case T_Param:
  350. break;
  352. case T_Const:
  353. break;
  355. case T_List:
  356. {
  357. List    *l;
  359. foreach(l, (List *) node)
  360. ChangeVarNodes(
  361.    (Node *) lfirst(l),
  362.    rt_index,
  363.    new_index,
  364.    sublevels_up);
  365. }
  366. break;
  368. case T_SubLink:
  369. {
  370. SubLink    *sub = (SubLink *) node;
  371. List    *tmp_oper,
  372.    *tmp_lefthand;
  374. ChangeVarNodes(
  375.    (Node *) (sub->lefthand),
  376.    rt_index,
  377.    new_index,
  378.    sublevels_up);
  380. ChangeVarNodes(
  381.    (Node *) (sub->subselect),
  382.    rt_index,
  383.    new_index,
  384.    sublevels_up + 1);
  386. /***S*I***/
  388. /*
  389.  * Make sure the first argument of sub->oper points to the
  390.  * same var as sub->lefthand does otherwise we will run
  391.  * into troubles using aggregates (aggno will not be set
  392.  * correctly)
  393.  */
  394. tmp_lefthand = sub->lefthand;
  395. foreach(tmp_oper, sub->oper)
  396. {
  397. lfirst(((Expr *) lfirst(tmp_oper))->args) =
  398. lfirst(tmp_lefthand);
  399. tmp_lefthand = lnext(tmp_lefthand);
  400. }
  401. }
  402. break;
  404. case T_Query:
  405. {
  406. Query    *qry = (Query *) node;
  408. ChangeVarNodes(
  409.    (Node *) (qry->targetList),
  410.    rt_index,
  411.    new_index,
  412.    sublevels_up);
  414. ChangeVarNodes(
  415.    (Node *) (qry->qual),
  416.    rt_index,
  417.    new_index,
  418.    sublevels_up);
  420. ChangeVarNodes(
  421.    (Node *) (qry->havingQual),
  422.    rt_index,
  423.    new_index,
  424.    sublevels_up);
  425. }
  426. break;
  428. case T_CaseExpr:
  429. {
  430. CaseExpr   *exp = (CaseExpr *) node;
  432. ChangeVarNodes(
  433.    (Node *) (exp->args),
  434.    rt_index,
  435.    new_index,
  436.    sublevels_up);
  438. ChangeVarNodes(
  439.    (Node *) (exp->defresult),
  440.    rt_index,
  441.    new_index,
  442.    sublevels_up);
  443. }
  444. break;
  446. case T_CaseWhen:
  447. {
  448. CaseWhen   *exp = (CaseWhen *) node;
  450. ChangeVarNodes(
  451.    (Node *) (exp->expr),
  452.    rt_index,
  453.    new_index,
  454.    sublevels_up);
  456. ChangeVarNodes(
  457.    (Node *) (exp->result),
  458.    rt_index,
  459.    new_index,
  460.    sublevels_up);
  461. }
  462. break;
  464. default:
  465. elog(NOTICE, "unknown node tag %d in ChangeVarNodes()", nodeTag(node));
  466. elog(NOTICE, "Node is: %s", nodeToString(node));
  467. break;
  470. }
  471. }
  475. void
  476. AddQual(Query *parsetree, Node *qual)
  477. {
  478. Node    *copy,
  479.    *old;
  481. if (qual == NULL)
  482. return;
  484. /***S*I***/
  485. /* INTERSECT want's the original, but we need to copy - Jan */
  486. /* copy = qual; */
  487. copy = copyObject(qual);
  489. old = parsetree->qual;
  490. if (old == NULL)
  491. parsetree->qual = copy;
  492. else
  493. parsetree->qual = (Node *) make_andclause(makeList(parsetree->qual, copy, -1));
  494. }
  496. /* Adds the given havingQual to the one already contained in the parsetree just as
  497.  * AddQual does for the normal 'where' qual */
  498. void
  499. AddHavingQual(Query *parsetree, Node *havingQual)
  500. {
  501. Node    *copy,
  502.    *old;
  504. if (havingQual == NULL)
  505. return;
  507. /***S*I***/
  508. /* INTERSECT want's the original, but we need to copy - Jan */
  509. /* copy = havingQual; */
  510. copy = copyObject(havingQual);
  512. old = parsetree->havingQual;
  513. if (old == NULL)
  514. parsetree->havingQual = copy;
  515. else
  516. parsetree->havingQual = (Node *) make_andclause(makeList(parsetree->havingQual, copy, -1));
  517. }
  519. #ifdef NOT_USED
  520. void
  521. AddNotHavingQual(Query *parsetree, Node *havingQual)
  522. {
  523. Node    *copy;
  525. if (havingQual == NULL)
  526. return;
  528. /***S*I***/
  529. /* INTERSECT want's the original, but we need to copy - Jan */
  530. /* copy = (Node *) make_notclause((Expr *)havingQual); */
  531. copy = (Node *) make_notclause((Expr *) copyObject(havingQual));
  533. AddHavingQual(parsetree, copy);
  534. }
  535. #endif
  537. void
  538. AddNotQual(Query *parsetree, Node *qual)
  539. {
  540. Node    *copy;
  542. if (qual == NULL)
  543. return;
  545. /***S*I***/
  546. /* INTERSECT want's the original, but we need to copy - Jan */
  547. /* copy = (Node *) make_notclause((Expr *)qual); */
  548. copy = (Node *) make_notclause((Expr *) copyObject(qual));
  550. AddQual(parsetree, copy);
  551. }
  554. void
  555. AddGroupClause(Query *parsetree, List *group_by, List *tlist)
  556. {
  557. List    *l;
  558. List    *tl;
  559. GroupClause *groupclause;
  560. TargetEntry *tle;
  561. int new_resno;
  563. new_resno = length(parsetree->targetList);
  565. foreach(l, group_by)
  566. {
  567. groupclause = (GroupClause *) copyObject(lfirst(l));
  568. tle = NULL;
  569. foreach(tl, tlist)
  570. {
  571. if (((TargetEntry *) lfirst(tl))->resdom->resgroupref ==
  572. groupclause->tleGroupref)
  573. {
  574. tle = (TargetEntry *) copyObject(lfirst(tl));
  575. break;
  576. }
  577. }
  578. if (tle == NULL)
  579. elog(ERROR, "AddGroupClause(): GROUP BY entry not found in rules targetlist");
  581. tle->resdom->resno = ++new_resno;
  582. tle->resdom->resjunk = true;
  583. tle->resdom->resgroupref = length(parsetree->groupClause) + 1;
  584. groupclause->tleGroupref = tle->resdom->resgroupref;
  586. parsetree->targetList = lappend(parsetree->targetList, tle);
  587. parsetree->groupClause = lappend(parsetree->groupClause, groupclause);
  588. }
  589. }
  591. static Node *
  592. make_null(Oid type)
  593. {
  594. Const    *c = makeNode(Const);
  596. c->consttype = type;
  597. c->constlen = get_typlen(type);
  598. c->constvalue = PointerGetDatum(NULL);
  599. c->constisnull = true;
  600. c->constbyval = get_typbyval(type);
  601. return (Node *) c;
  602. }
  604. #ifdef NOT_USED
  605. void
  606. FixResdomTypes(List *tlist)
  607. {
  608. List    *i;
  610. foreach(i, tlist)
  611. {
  612. TargetEntry *tle = lfirst(i);
  614. if (nodeTag(tle->expr) == T_Var)
  615. {
  616. Var    *var = (Var *) tle->expr;
  618. tle->resdom->restype = var->vartype;
  619. tle->resdom->restypmod = var->vartypmod;
  620. }
  621. }
  622. }
  624. #endif
  626. static Node *
  627. FindMatchingNew(List *tlist, int attno)
  628. {
  629. List    *i;
  631. foreach(i, tlist)
  632. {
  633. TargetEntry *tle = lfirst(i);
  635. if (tle->resdom->resno == attno)
  636. return tle->expr;
  637. }
  638. return NULL;
  639. }
  641. static Node *
  642. FindMatchingTLEntry(List *tlist, char *e_attname)
  643. {
  644. List    *i;
  646. foreach(i, tlist)
  647. {
  648. TargetEntry *tle = lfirst(i);
  649. char    *resname;
  651. resname = tle->resdom->resname;
  652. if (!strcmp(e_attname, resname))
  653. return tle->expr;
  654. }
  655. return NULL;
  656. }
  658. static void
  659. ResolveNew(RewriteInfo *info, List *targetlist, Node **nodePtr,
  660.    int sublevels_up)
  661. {
  662. Node    *node = *nodePtr;
  664. if (node == NULL)
  665. return;
  667. switch (nodeTag(node))
  668. {
  669. case T_TargetEntry:
  670. ResolveNew(info, targetlist, &((TargetEntry *) node)->expr,
  671.    sublevels_up);
  672. break;
  673. case T_Aggref:
  674. ResolveNew(info, targetlist, &((Aggref *) node)->target,
  675.    sublevels_up);
  676. break;
  677. case T_Expr:
  678. ResolveNew(info, targetlist, (Node **) (&(((Expr *) node)->args)),
  679.    sublevels_up);
  680. break;
  681. case T_Iter:
  682. ResolveNew(info, targetlist, (Node **) (&(((Iter *) node)->iterexpr)),
  683.    sublevels_up);
  684. break;
  685. case T_ArrayRef:
  686. ResolveNew(info, targetlist, (Node **) (&(((ArrayRef *) node)->refupperindexpr)),
  687.    sublevels_up);
  688. ResolveNew(info, targetlist, (Node **) (&(((ArrayRef *) node)->reflowerindexpr)),
  689.    sublevels_up);
  690. ResolveNew(info, targetlist, (Node **) (&(((ArrayRef *) node)->refexpr)),
  691.    sublevels_up);
  692. ResolveNew(info, targetlist, (Node **) (&(((ArrayRef *) node)->refassgnexpr)),
  693.    sublevels_up);
  694. break;
  695. case T_Var:
  696. {
  697. int this_varno = (int) ((Var *) node)->varno;
  698. int this_varlevelsup = (int) ((Var *) node)->varlevelsup;
  699. Node    *n;
  701. if (this_varno == info->new_varno &&
  702. this_varlevelsup == sublevels_up)
  703. {
  704. n = FindMatchingNew(targetlist,
  705. ((Var *) node)->varattno);
  706. if (n == NULL)
  707. {
  708. if (info->event == CMD_UPDATE)
  709. {
  710. *nodePtr = n = copyObject(node);
  711. ((Var *) n)->varno = info->current_varno;
  712. ((Var *) n)->varnoold = info->current_varno;
  713. }
  714. else
  715. *nodePtr = make_null(((Var *) node)->vartype);
  716. }
  717. else
  718. {
  719. *nodePtr = copyObject(n);
  720. ((Var *) *nodePtr)->varlevelsup = this_varlevelsup;
  721. }
  722. }
  723. break;
  724. }
  725. case T_List:
  726. {
  727. List    *l;
  729. foreach(l, (List *) node)
  730. ResolveNew(info, targetlist, (Node **) &(lfirst(l)),
  731.    sublevels_up);
  732. break;
  733. }
  734. case T_SubLink:
  735. {
  736. SubLink    *sublink = (SubLink *) node;
  737. Query    *query = (Query *) sublink->subselect;
  739. ResolveNew(info, targetlist, (Node **) &(query->qual), sublevels_up + 1);
  740. }
  741. break;
  742. case T_GroupClause:
  743. break;
  744. default:
  745. /* ignore the others */
  746. break;
  747. }
  748. }
  750. void
  751. FixNew(RewriteInfo *info, Query *parsetree)
  752. {
  753. ResolveNew(info, parsetree->targetList,
  754.    (Node **) &(info->rule_action->targetList), 0);
  755. ResolveNew(info, parsetree->targetList,
  756.    (Node **) &info->rule_action->qual, 0);
  757. ResolveNew(info, parsetree->targetList,
  758.    (Node **) &(info->rule_action->groupClause), 0);
  759. }
  761. static void
  762. nodeHandleRIRAttributeRule(Node **nodePtr,
  763.    List *rtable,
  764.    List *targetlist,
  765.    int rt_index,
  766.    int attr_num,
  767.    int *modified,
  768.    int *badsql,
  769.    int sublevels_up)
  770. {
  771. Node    *node = *nodePtr;
  773. if (node == NULL)
  774. return;
  775. switch (nodeTag(node))
  776. {
  777. case T_TargetEntry:
  778. {
  779. TargetEntry *tle = (TargetEntry *) node;
  781. nodeHandleRIRAttributeRule(&tle->expr, rtable, targetlist,
  782. rt_index, attr_num, modified, badsql,
  783.    sublevels_up);
  784. }
  785. break;
  786. case T_Aggref:
  787. {
  788. Aggref    *aggref = (Aggref *) node;
  790. nodeHandleRIRAttributeRule(&aggref->target, rtable, targetlist,
  791. rt_index, attr_num, modified, badsql,
  792.    sublevels_up);
  793. }
  794. break;
  795. case T_Expr:
  796. {
  797. Expr    *expr = (Expr *) node;
  799. nodeHandleRIRAttributeRule((Node **) (&(expr->args)), rtable,
  800.    targetlist, rt_index, attr_num,
  801.    modified, badsql,
  802.    sublevels_up);
  803. }
  804. break;
  805. case T_Iter:
  806. {
  807. Iter    *iter = (Iter *) node;
  809. nodeHandleRIRAttributeRule((Node **) (&(iter->iterexpr)), rtable,
  810.    targetlist, rt_index, attr_num,
  811.    modified, badsql,
  812.    sublevels_up);
  813. }
  814. break;
  815. case T_ArrayRef:
  816. {
  817. ArrayRef   *ref = (ArrayRef *) node;
  819. nodeHandleRIRAttributeRule((Node **) (&(ref->refupperindexpr)), rtable,
  820.    targetlist, rt_index, attr_num,
  821.    modified, badsql,
  822.    sublevels_up);
  823. nodeHandleRIRAttributeRule((Node **) (&(ref->reflowerindexpr)), rtable,
  824.    targetlist, rt_index, attr_num,
  825.    modified, badsql,
  826.    sublevels_up);
  827. nodeHandleRIRAttributeRule((Node **) (&(ref->refexpr)), rtable,
  828.    targetlist, rt_index, attr_num,
  829.    modified, badsql,
  830.    sublevels_up);
  831. nodeHandleRIRAttributeRule((Node **) (&(ref->refassgnexpr)), rtable,
  832.    targetlist, rt_index, attr_num,
  833.    modified, badsql,
  834.    sublevels_up);
  835. }
  836. break;
  837. case T_Var:
  838. {
  839. int this_varno = ((Var *) node)->varno;
  840. int this_varattno = ((Var *) node)->varattno;
  841. int this_varlevelsup = ((Var *) node)->varlevelsup;
  843. if (this_varno == rt_index &&
  844. this_varattno == attr_num &&
  845. this_varlevelsup == sublevels_up)
  846. {
  847. if (((Var *) node)->vartype == 32)
  848. { /* HACK */
  849. *nodePtr = make_null(((Var *) node)->vartype);
  850. *modified = TRUE;
  851. *badsql = TRUE;
  852. break;
  853. }
  854. else
  855. {
  856. NameData name_to_look_for;
  858. name_to_look_for.data[0] = '';
  859. namestrcpy(&name_to_look_for,
  860. (char *) get_attname(getrelid(this_varno,
  861.   rtable),
  862.  attr_num));
  863. if (name_to_look_for.data[0])
  864. {
  865. Node    *n;
  867. n = FindMatchingTLEntry(targetlist, (char *) &name_to_look_for);
  868. if (n == NULL)
  869. *nodePtr = make_null(((Var *) node)->vartype);
  870. else
  871. *nodePtr = n;
  872. *modified = TRUE;
  873. }
  874. }
  875. }
  876. }
  877. break;
  878. case T_List:
  879. {
  880. List    *i;
  882. foreach(i, (List *) node)
  883. {
  884. nodeHandleRIRAttributeRule((Node **) (&(lfirst(i))), rtable,
  885.   targetlist, rt_index, attr_num,
  886.  modified, badsql, sublevels_up);
  887. }
  888. }
  889. break;
  890. case T_SubLink:
  891. {
  892. SubLink    *sublink = (SubLink *) node;
  893. Query    *query = (Query *) sublink->subselect;
  895. nodeHandleRIRAttributeRule((Node **) &(query->qual), rtable, targetlist,
  896. rt_index, attr_num, modified, badsql,
  897.    sublevels_up + 1);
  898. }
  899. break;
  900. default:
  901. /* ignore the others */
  902. break;
  903. }
  904. }
  906. /*
  907.  * Handles 'on retrieve to relation.attribute
  908.  * do instead retrieve (attribute = expression) w/qual'
  909.  */
  910. void
  911. HandleRIRAttributeRule(Query *parsetree,
  912.    List *rtable,
  913.    List *targetlist,
  914.    int rt_index,
  915.    int attr_num,
  916.    int *modified,
  917.    int *badsql)
  918. {
  920. nodeHandleRIRAttributeRule((Node **) (&(parsetree->targetList)), rtable,
  921.    targetlist, rt_index, attr_num,
  922.    modified, badsql, 0);
  923. nodeHandleRIRAttributeRule(&parsetree->qual, rtable, targetlist,
  924.    rt_index, attr_num, modified, badsql, 0);
  925. }
  927. #ifdef NOT_USED
  928. static void
  929. nodeHandleViewRule(Node **nodePtr,
  930.    List *rtable,
  931.    List *targetlist,
  932.    int rt_index,
  933.    int *modified,
  934.    int sublevels_up)
  935. {
  936. Node    *node = *nodePtr;
  938. if (node == NULL)
  939. return;
  941. switch (nodeTag(node))
  942. {
  943. case T_TargetEntry:
  944. {
  945. TargetEntry *tle = (TargetEntry *) node;
  947. nodeHandleViewRule(&(tle->expr), rtable, targetlist,
  948.    rt_index, modified, sublevels_up);
  949. }
  950. break;
  951. case T_Aggref:
  952. {
  953. Aggref    *aggref = (Aggref *) node;
  955. nodeHandleViewRule(&(aggref->target), rtable, targetlist,
  956.    rt_index, modified, sublevels_up);
  957. }
  958. break;
  960. /*
  961.  * This has to be done to make queries using groupclauses work
  962.  * on views
  963.  */
  964. case T_GroupClause:
  965. {
  966. GroupClause *group = (GroupClause *) node;
  968. nodeHandleViewRule((Node **) (&(group->entry)), rtable, targetlist,
  969.    rt_index, modified, sublevels_up);
  970. }
  971. break;
  972. case T_Expr:
  973. {
  974. Expr    *expr = (Expr *) node;
  976. nodeHandleViewRule((Node **) (&(expr->args)),
  977.    rtable, targetlist,
  978.    rt_index, modified, sublevels_up);
  979. }
  980. break;
  981. case T_Iter:
  982. {
  983. Iter    *iter = (Iter *) node;
  985. nodeHandleViewRule((Node **) (&(iter->iterexpr)),
  986.    rtable, targetlist,
  987.    rt_index, modified, sublevels_up);
  988. }
  989. break;
  990. case T_ArrayRef:
  991. {
  992. ArrayRef   *ref = (ArrayRef *) node;
  994. nodeHandleViewRule((Node **) (&(ref->refupperindexpr)),
  995.    rtable, targetlist,
  996.    rt_index, modified, sublevels_up);
  997. nodeHandleViewRule((Node **) (&(ref->reflowerindexpr)),
  998.    rtable, targetlist,
  999.    rt_index, modified, sublevels_up);
  1000. nodeHandleViewRule((Node **) (&(ref->refexpr)),
  1001.    rtable, targetlist,
  1002.    rt_index, modified, sublevels_up);
  1003. nodeHandleViewRule((Node **) (&(ref->refassgnexpr)),
  1004.    rtable, targetlist,
  1005.    rt_index, modified, sublevels_up);
  1006. }
  1007. break;
  1008. case T_Var:
  1009. {
  1010. Var    *var = (Var *) node;
  1011. int this_varno = var->varno;
  1012. int this_varlevelsup = var->varlevelsup;
  1013. Node    *n;
  1015. if (this_varno == rt_index &&
  1016. this_varlevelsup == sublevels_up)
  1017. {
  1018. n = FindMatchingTLEntry(targetlist,
  1019.  get_attname(getrelid(this_varno,
  1020.   rtable),
  1021.  var->varattno));
  1022. if (n == NULL)
  1023. *nodePtr = make_null(((Var *) node)->vartype);
  1024. else
  1025. {
  1027. /*
  1028.  * This is a hack: The varlevelsup of the orignal
  1029.  * variable and the new one should be the same.
  1030.  * Normally we adapt the node by changing a
  1031.  * pointer to point to a var contained in
  1032.  * 'targetlist'. In the targetlist all
  1033.  * varlevelsups are 0 so if we want to change it
  1034.  * to the original value we have to copy the node
  1035.  * before! (Maybe this will cause troubles with
  1036.  * some sophisticated queries on views?)
  1037.  */
  1038. if (this_varlevelsup > 0)
  1039. *nodePtr = copyObject(n);
  1040. else
  1041. *nodePtr = n;
  1043. if (nodeTag(nodePtr) == T_Var)
  1044. ((Var *) *nodePtr)->varlevelsup = this_varlevelsup;
  1045. else
  1046. nodeHandleViewRule(&n, rtable, targetlist,
  1047.    rt_index, modified, sublevels_up);
  1048. }
  1049. *modified = TRUE;
  1050. }
  1051. break;
  1052. }
  1053. case T_List:
  1054. {
  1055. List    *l;
  1057. foreach(l, (List *) node)
  1058. {
  1059. nodeHandleViewRule((Node **) (&(lfirst(l))),
  1060.    rtable, targetlist,
  1061.    rt_index, modified, sublevels_up);
  1062. }
  1063. }
  1064. break;
  1065. case T_SubLink:
  1066. {
  1067. SubLink    *sublink = (SubLink *) node;
  1068. Query    *query = (Query *) sublink->subselect;
  1069. List    *tmp_lefthand,
  1070.    *tmp_oper;
  1073. nodeHandleViewRule((Node **) &(query->qual), rtable, targetlist,
  1074.    rt_index, modified, sublevels_up + 1);
  1076. /***S*H*D***/
  1077. nodeHandleViewRule((Node **) &(query->havingQual), rtable, targetlist,
  1078.    rt_index, modified, sublevels_up + 1);
  1079. nodeHandleViewRule((Node **) &(query->targetList), rtable, targetlist,
  1080.    rt_index, modified, sublevels_up + 1);
  1083. /*
  1084.  * We also have to adapt the variables used in
  1085.  * sublink->lefthand and sublink->oper
  1086.  */
  1087. nodeHandleViewRule((Node **) &(sublink->lefthand), rtable,
  1088.    targetlist, rt_index, modified, sublevels_up);
  1090. /*
  1091.  * Make sure the first argument of sublink->oper points to
  1092.  * the same var as sublink->lefthand does otherwise we
  1093.  * will run into troubles using aggregates (aggno will not
  1094.  * be set correctly
  1095.  */
  1096. pfree(lfirst(((Expr *) lfirst(sublink->oper))->args));
  1097. lfirst(((Expr *) lfirst(sublink->oper))->args) =
  1098. lfirst(sublink->lefthand);
  1101. /***S*I***/
  1102. /* INTERSECT want's this - Jan */
  1104. /*
  1105.  * tmp_lefthand = sublink->lefthand; foreach(tmp_oper,
  1106.  * sublink->oper) { lfirst(((Expr *)
  1107.  * lfirst(tmp_oper))->args) = lfirst(tmp_lefthand);
  1108.  * tmp_lefthand = lnext(tmp_lefthand); }
  1109.  */
  1110. }
  1111. break;
  1112. default:
  1113. /* ignore the others */
  1114. break;
  1115. }
  1116. }
  1118. void
  1119. HandleViewRule(Query *parsetree,
  1120.    List *rtable,
  1121.    List *targetlist,
  1122.    int rt_index,
  1123.    int *modified)
  1124. {
  1125. nodeHandleViewRule(&parsetree->qual, rtable, targetlist, rt_index,
  1126.    modified, 0);
  1127. nodeHandleViewRule((Node **) (&(parsetree->targetList)), rtable, targetlist,
  1128.    rt_index, modified, 0);
  1130. /*
  1131.  * The variables in the havingQual and groupClause also have to be
  1132.  * adapted
  1133.  */
  1134. nodeHandleViewRule(&parsetree->havingQual, rtable, targetlist, rt_index,
  1135.    modified, 0);
  1136. nodeHandleViewRule((Node **) (&(parsetree->groupClause)), rtable, targetlist, rt_index,
  1137.    modified, 0);
  1138. }
  1140. #endif