rewriteHandler.c 55.4 KB
Newer Older
1 2
/*-------------------------------------------------------------------------
 *
3
 * rewriteHandler.c
4 5 6 7 8
 *
 * Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
9
 *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.65 2000/01/17 02:04:13 tgl Exp $
10 11 12 13 14
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

Bruce Momjian's avatar
Bruce Momjian committed
15
#include "access/heapam.h"
16
#include "catalog/pg_operator.h"
17
#include "catalog/pg_type.h"
Bruce Momjian's avatar
Bruce Momjian committed
18
#include "miscadmin.h"
19
#include "nodes/makefuncs.h"
Bruce Momjian's avatar
Bruce Momjian committed
20 21 22
#include "optimizer/clauses.h"
#include "optimizer/prep.h"
#include "parser/analyze.h"
23
#include "parser/parse_expr.h"
Bruce Momjian's avatar
Bruce Momjian committed
24
#include "parser/parse_relation.h"
25
#include "parser/parse_oper.h"
Bruce Momjian's avatar
Bruce Momjian committed
26 27 28 29 30 31 32
#include "parser/parse_target.h"
#include "parser/parse_type.h"
#include "parser/parsetree.h"
#include "rewrite/locks.h"
#include "rewrite/rewriteManip.h"
#include "utils/acl.h"
#include "utils/lsyscache.h"
33 34


35 36 37 38 39 40 41 42 43 44 45 46 47
extern void CheckSelectForUpdate(Query *rule_action);	/* in analyze.c */


/* macros borrowed from expression_tree_mutator */

#define FLATCOPY(newnode, node, nodetype)  \
	( (newnode) = makeNode(nodetype), \
	  memcpy((newnode), (node), sizeof(nodetype)) )

#define MUTATE(newfield, oldfield, fieldtype, mutator, context)  \
		( (newfield) = (fieldtype) mutator((Node *) (oldfield), (context)) )


48 49 50 51 52 53 54
static RewriteInfo *gatherRewriteMeta(Query *parsetree,
				  Query *rule_action,
				  Node *rule_qual,
				  int rt_index,
				  CmdType event,
				  bool *instead_flag);
static bool rangeTableEntry_used(Node *node, int rt_index, int sublevels_up);
55 56 57 58
static bool attribute_used(Node *node, int rt_index, int attno,
						   int sublevels_up);
static bool modifyAggrefUplevel(Node *node, void *context);
static bool modifyAggrefChangeVarnodes(Node *node, int rt_index, int new_index,
59
									   int sublevels_up, int new_sublevels_up);
60
static Node *modifyAggrefDropQual(Node *node, Node *targetNode);
61
static SubLink *modifyAggrefMakeSublink(Aggref *aggref, Query *parsetree);
62
static Node *modifyAggrefQual(Node *node, Query *parsetree);
63
static bool checkQueryHasAggs(Node *node);
64 65 66
static bool checkQueryHasAggs_walker(Node *node, void *context);
static bool checkQueryHasSubLink(Node *node);
static bool checkQueryHasSubLink_walker(Node *node, void *context);
67
static Query *fireRIRrules(Query *parsetree);
68 69 70 71 72 73
static Query *Except_Intersect_Rewrite(Query *parsetree);
static void check_targetlists_are_compatible(List *prev_target,
											 List *current_target);
static void create_intersect_list(Node *ptr, List **intersect_list);
static Node *intersect_tree_analyze(Node *tree, Node *first_select,
									Node *parsetree);
74 75 76

/*
 * gatherRewriteMeta -
77 78 79
 *	  Gather meta information about parsetree, and rule. Fix rule body
 *	  and qualifier so that they can be mixed with the parsetree and
 *	  maintain semantic validity
80 81
 */
static RewriteInfo *
82 83 84
gatherRewriteMeta(Query *parsetree,
				  Query *rule_action,
				  Node *rule_qual,
85 86
				  int rt_index,
				  CmdType event,
87
				  bool *instead_flag)
88
{
89 90 91
	RewriteInfo *info;
	int			rt_length;
	int			result_reln;
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107

	info = (RewriteInfo *) palloc(sizeof(RewriteInfo));
	info->rt_index = rt_index;
	info->event = event;
	info->instead_flag = *instead_flag;
	info->rule_action = (Query *) copyObject(rule_action);
	info->rule_qual = (Node *) copyObject(rule_qual);
	if (info->rule_action == NULL)
		info->nothing = TRUE;
	else
	{
		info->nothing = FALSE;
		info->action = info->rule_action->commandType;
		info->current_varno = rt_index;
		info->rt = parsetree->rtable;
		rt_length = length(info->rt);
Bruce Momjian's avatar
Bruce Momjian committed
108
		info->rt = nconc(info->rt, copyObject(info->rule_action->rtable));
109 110

		info->new_varno = PRS2_NEW_VARNO + rt_length;
Bruce Momjian's avatar
Bruce Momjian committed
111 112 113
		OffsetVarNodes(info->rule_action->qual, rt_length, 0);
		OffsetVarNodes((Node *) info->rule_action->targetList, rt_length, 0);
		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);
120 121 122 123 124 125 126 127

		/*
		 * bug here about replace CURRENT  -- sort of replace current is
		 * deprecated now so this code shouldn't really need to be so
		 * clutzy but.....
		 */
		if (info->action != CMD_SELECT)
		{						/* i.e update XXXXX */
128
			int			new_result_reln = 0;
129 130 131 132

			result_reln = info->rule_action->resultRelation;
			switch (result_reln)
			{
133 134 135 136 137 138 139
				case PRS2_CURRENT_VARNO:
					new_result_reln = rt_index;
					break;
				case PRS2_NEW_VARNO:	/* XXX */
				default:
					new_result_reln = result_reln + rt_length;
					break;
140 141 142 143 144
			}
			info->rule_action->resultRelation = new_result_reln;
		}
	}
	return info;
145 146 147 148
}


/*
149 150 151
 * rangeTableEntry_used -
 *	we need to process a RTE for RIR rules only if it is
 *	referenced somewhere in var nodes of the query.
152
 */
153 154 155 156 157 158

typedef struct {
	int			rt_index;
	int			sublevels_up;
} rangeTableEntry_used_context;

159
static bool
160 161
rangeTableEntry_used_walker (Node *node,
							 rangeTableEntry_used_context *context)
162
{
163
	if (node == NULL)
164 165
		return false;
	if (IsA(node, Var))
Bruce Momjian's avatar
Bruce Momjian committed
166
	{
167
		Var		   *var = (Var *) node;
168

169 170 171 172
		if (var->varlevelsup == context->sublevels_up &&
			var->varno == context->rt_index)
			return true;
		return false;
173
	}
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
	if (IsA(node, SubLink))
	{
		/*
		 * Standard expression_tree_walker will not recurse into subselect,
		 * but here we must do so.
		 */
		SubLink    *sub = (SubLink *) node;

		if (rangeTableEntry_used_walker((Node *) (sub->lefthand), context))
			return true;
		if (rangeTableEntry_used((Node *) (sub->subselect),
								 context->rt_index,
								 context->sublevels_up + 1))
			return true;
		return false;
	}
	if (IsA(node, Query))
	{
		/* Reach here after recursing down into subselect above... */
		Query	   *qry = (Query *) node;

		if (rangeTableEntry_used_walker((Node *) (qry->targetList), context))
			return true;
		if (rangeTableEntry_used_walker((Node *) (qry->qual), context))
			return true;
		if (rangeTableEntry_used_walker((Node *) (qry->havingQual), context))
			return true;
		return false;
	}
	return expression_tree_walker(node, rangeTableEntry_used_walker,
								  (void *) context);
}

static bool
rangeTableEntry_used(Node *node, int rt_index, int sublevels_up)
{
	rangeTableEntry_used_context context;
211

212 213 214
	context.rt_index = rt_index;
	context.sublevels_up = sublevels_up;
	return rangeTableEntry_used_walker(node, &context);
215
}
216 217


218 219 220 221
/*
 * attribute_used -
 *	Check if a specific attribute number of a RTE is used
 *	somewhere in the query
222
 */
223 224 225 226 227 228 229

typedef struct {
	int			rt_index;
	int			attno;
	int			sublevels_up;
} attribute_used_context;

230
static bool
231 232
attribute_used_walker (Node *node,
					   attribute_used_context *context)
233
{
234
	if (node == NULL)
235 236
		return false;
	if (IsA(node, Var))
Bruce Momjian's avatar
Bruce Momjian committed
237
	{
238
		Var		   *var = (Var *) node;
239

240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
		if (var->varlevelsup == context->sublevels_up &&
			var->varno == context->rt_index &&
			var->varattno == context->attno)
			return true;
		return false;
	}
	if (IsA(node, SubLink))
	{
		/*
		 * Standard expression_tree_walker will not recurse into subselect,
		 * but here we must do so.
		 */
		SubLink    *sub = (SubLink *) node;

		if (attribute_used_walker((Node *) (sub->lefthand), context))
			return true;
		if (attribute_used((Node *) (sub->subselect),
						   context->rt_index,
						   context->attno,
						   context->sublevels_up + 1))
			return true;
		return false;
	}
	if (IsA(node, Query))
	{
		/* Reach here after recursing down into subselect above... */
		Query	   *qry = (Query *) node;

		if (attribute_used_walker((Node *) (qry->targetList), context))
			return true;
		if (attribute_used_walker((Node *) (qry->qual), context))
			return true;
		if (attribute_used_walker((Node *) (qry->havingQual), context))
			return true;
		return false;
275
	}
276 277 278 279 280 281 282 283
	return expression_tree_walker(node, attribute_used_walker,
								  (void *) context);
}

static bool
attribute_used(Node *node, int rt_index, int attno, int sublevels_up)
{
	attribute_used_context context;
284

285 286 287 288
	context.rt_index = rt_index;
	context.attno = attno;
	context.sublevels_up = sublevels_up;
	return attribute_used_walker(node, &context);
289
}
290

291

292
/*
Bruce Momjian's avatar
Bruce Momjian committed
293
 * modifyAggrefUplevel -
294
 *	In the newly created sublink for an aggregate column used in
295
 *	the qualification, we must increment the varlevelsup in all the
296
 *	var nodes.
297 298 299 300
 *
 * NOTE: although this has the form of a walker, we cheat and modify the
 * Var nodes in-place.  The given expression tree should have been copied
 * earlier to ensure that no unwanted side-effects occur!
301
 */
302 303
static bool
modifyAggrefUplevel(Node *node, void *context)
304 305
{
	if (node == NULL)
306 307
		return false;
	if (IsA(node, Var))
Bruce Momjian's avatar
Bruce Momjian committed
308
	{
309
		Var		   *var = (Var *) node;
310

311 312 313 314 315 316 317 318 319 320
		var->varlevelsup++;
		return false;
	}
	if (IsA(node, SubLink))
	{
		/*
		 * Standard expression_tree_walker will not recurse into subselect,
		 * but here we must do so.
		 */
		SubLink    *sub = (SubLink *) node;
321

322 323 324 325 326
		if (modifyAggrefUplevel((Node *) (sub->lefthand), context))
			return true;
		if (modifyAggrefUplevel((Node *) (sub->subselect), context))
			return true;
		return false;
327
	}
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
	if (IsA(node, Query))
	{
		/* Reach here after recursing down into subselect above... */
		Query	   *qry = (Query *) node;

		if (modifyAggrefUplevel((Node *) (qry->targetList), context))
			return true;
		if (modifyAggrefUplevel((Node *) (qry->qual), context))
			return true;
		if (modifyAggrefUplevel((Node *) (qry->havingQual), context))
			return true;
		return false;
	}
	return expression_tree_walker(node, modifyAggrefUplevel,
								  (void *) context);
343 344 345 346
}


/*
Bruce Momjian's avatar
Bruce Momjian committed
347
 * modifyAggrefChangeVarnodes -
348
 *	Change the var nodes in a sublink created for an aggregate column
349 350 351 352 353
 *	used in the qualification to point to the correct local RTE.
 *
 * NOTE: although this has the form of a walker, we cheat and modify the
 * Var nodes in-place.  The given expression tree should have been copied
 * earlier to ensure that no unwanted side-effects occur!
354 355
 */

356 357 358 359
typedef struct {
	int			rt_index;
	int			new_index;
	int			sublevels_up;
360
	int			new_sublevels_up;
361
} modifyAggrefChangeVarnodes_context;
362

363 364 365 366 367 368 369
static bool
modifyAggrefChangeVarnodes_walker(Node *node,
								  modifyAggrefChangeVarnodes_context *context)
{
	if (node == NULL)
		return false;
	if (IsA(node, Var))
Bruce Momjian's avatar
Bruce Momjian committed
370
	{
371
		Var		   *var = (Var *) node;
372

373 374 375 376 377
		if (var->varlevelsup == context->sublevels_up &&
			var->varno == context->rt_index)
		{
			var->varno = context->new_index;
			var->varnoold = context->new_index;
378
			var->varlevelsup = context->new_sublevels_up;
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
		}
		return false;
	}
	if (IsA(node, SubLink))
	{
		/*
		 * Standard expression_tree_walker will not recurse into subselect,
		 * but here we must do so.
		 */
		SubLink    *sub = (SubLink *) node;

		if (modifyAggrefChangeVarnodes_walker((Node *) (sub->lefthand),
											  context))
			return true;
		if (modifyAggrefChangeVarnodes((Node *) (sub->subselect),
									   context->rt_index,
									   context->new_index,
396 397
									   context->sublevels_up + 1,
									   context->new_sublevels_up + 1))
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
			return true;
		return false;
	}
	if (IsA(node, Query))
	{
		/* Reach here after recursing down into subselect above... */
		Query	   *qry = (Query *) node;

		if (modifyAggrefChangeVarnodes_walker((Node *) (qry->targetList),
											  context))
			return true;
		if (modifyAggrefChangeVarnodes_walker((Node *) (qry->qual),
											  context))
			return true;
		if (modifyAggrefChangeVarnodes_walker((Node *) (qry->havingQual),
											  context))
			return true;
		return false;
	}
	return expression_tree_walker(node, modifyAggrefChangeVarnodes_walker,
								  (void *) context);
}
420

421 422
static bool
modifyAggrefChangeVarnodes(Node *node, int rt_index, int new_index,
423
						   int sublevels_up, int new_sublevels_up)
424 425
{
	modifyAggrefChangeVarnodes_context context;
426

427 428 429
	context.rt_index = rt_index;
	context.new_index = new_index;
	context.sublevels_up = sublevels_up;
430
	context.new_sublevels_up = new_sublevels_up;
431
	return modifyAggrefChangeVarnodes_walker(node, &context);
432 433 434 435
}


/*
Bruce Momjian's avatar
Bruce Momjian committed
436
 * modifyAggrefDropQual -
437 438
 *	remove the pure aggref clause from a qualification
 *
439 440 441 442 443 444 445
 * targetNode is an Aggref node somewhere within the given expression tree.
 * Find the boolean operator that's presumably somewhere above it, and replace
 * that whole operator expression with a constant TRUE.  (This is NOT really
 * quite the right thing, but it handles simple cases.  This whole set of
 * Aggref-in-qual routines needs to be thrown away when we can do subselects
 * in FROM.)
 *
446 447 448 449 450 451
 * The return tree is a modified copy of the given tree; the given tree
 * is not altered.
 *
 * Note: we don't recurse into subselects looking for targetNode; that's
 * not necessary in the current usage, since in fact targetNode will be
 * within the same select level as the given toplevel node.
452
 */
453 454
static Node *
modifyAggrefDropQual(Node *node, Node *targetNode)
455 456
{
	if (node == NULL)
457 458
		return NULL;
	if (node == targetNode)
459 460 461 462 463
	{
		/* Oops, it's not inside an Expr we can rearrange... */
		elog(ERROR, "Cannot handle aggregate function inserted at this place in WHERE clause");
	}
	if (IsA(node, Expr))
Bruce Momjian's avatar
Bruce Momjian committed
464
	{
465
		Expr	   *expr = (Expr *) node;
466
		List	   *i;
467

468 469 470 471 472 473 474 475 476 477 478 479 480
		foreach(i, expr->args)
		{
			if (((Node *) lfirst(i)) == targetNode)
			{
				/* Found the parent expression containing the Aggref */
				if (expr->typeOid != BOOLOID)
					elog(ERROR,
						 "aggregate function in qual must be argument of boolean operator");
				return (Node *) makeConst(BOOLOID, 1, (Datum) true,
										  false, true, false, false);
			}
		}
		/* else this isn't the expr we want, keep going */
481
	}
482 483
	return expression_tree_mutator(node, modifyAggrefDropQual,
								   (void *) targetNode);
484 485 486
}

/*
Bruce Momjian's avatar
Bruce Momjian committed
487
 * modifyAggrefMakeSublink -
488 489 490 491
 *	Create a sublink node for a qualification expression that
 *	uses an aggregate column of a view
 */
static SubLink *
492
modifyAggrefMakeSublink(Aggref *aggref, Query *parsetree)
493
{
494
	/* target and rte point to old structures: */
Bruce Momjian's avatar
Bruce Momjian committed
495
	Var		   *target;
496 497 498 499
	RangeTblEntry *rte;
	/* these point to newly-created structures: */
	Query	   *subquery;
	SubLink    *sublink;
Bruce Momjian's avatar
Bruce Momjian committed
500 501
	TargetEntry *tle;
	Resdom	   *resdom;
502

Bruce Momjian's avatar
Bruce Momjian committed
503
	target = (Var *) (aggref->target);
504 505
	if (! IsA(target, Var))
		elog(ERROR, "rewrite: aggregates of views only allowed on simple variables for now");
506
	rte = rt_fetch(target->varno, parsetree->rtable);
507

Bruce Momjian's avatar
Bruce Momjian committed
508 509
	resdom = makeNode(Resdom);
	resdom->resno = 1;
510
	resdom->restype = aggref->aggtype;
511 512
	resdom->restypmod = -1;
	resdom->resname = pstrdup("<noname>");
Bruce Momjian's avatar
Bruce Momjian committed
513
	resdom->reskey = 0;
514
	resdom->reskeyop = 0;
Bruce Momjian's avatar
Bruce Momjian committed
515
	resdom->resjunk = false;
516

517
	tle = makeNode(TargetEntry);
Bruce Momjian's avatar
Bruce Momjian committed
518
	tle->resdom = resdom;
519 520 521
	tle->expr = copyObject(aggref);	/* make a modifiable copy! */

	subquery = makeNode(Query);
522 523

	sublink = makeNode(SubLink);
Bruce Momjian's avatar
Bruce Momjian committed
524
	sublink->subLinkType = EXPR_SUBLINK;
525
	sublink->useor = false;
526 527
	sublink->lefthand = NIL;
	sublink->oper = NIL;
Bruce Momjian's avatar
Bruce Momjian committed
528 529 530 531 532 533 534 535 536
	sublink->subselect = (Node *) subquery;

	subquery->commandType = CMD_SELECT;
	subquery->utilityStmt = NULL;
	subquery->resultRelation = 0;
	subquery->into = NULL;
	subquery->isPortal = FALSE;
	subquery->isBinary = FALSE;
	subquery->isTemp = FALSE;
537 538 539
	subquery->unionall = FALSE;
	subquery->uniqueFlag = NULL;
	subquery->sortClause = NULL;
540
	subquery->rtable = lcons(copyObject(rte), NIL);
541 542
	subquery->targetList = lcons(tle, NIL);
	subquery->qual = modifyAggrefDropQual((Node *) parsetree->qual,
543
										  (Node *) aggref);
544 545 546 547 548 549
	/*
	 * If there are still aggs in the subselect's qual, give up.
	 * Recursing would be a bad idea --- we'd likely produce an
	 * infinite recursion.  This whole technique is a crock, really...
	 */
	if (checkQueryHasAggs(subquery->qual))
550
		elog(ERROR, "Cannot handle multiple aggregate functions in WHERE clause");
551 552 553
	subquery->groupClause = NIL;
	subquery->havingQual = NULL;
	subquery->hasAggs = TRUE;
554
	subquery->hasSubLinks = checkQueryHasSubLink(subquery->qual);
555
	subquery->unionClause = NULL;
556

557
	/* Increment all varlevelsup fields in the new subquery */
558
	modifyAggrefUplevel((Node *) subquery, NULL);
559 560 561

	/* Replace references to the target table with correct varno.
	 * Note +1 here to account for effects of previous line!
562 563
	 */
	modifyAggrefChangeVarnodes((Node *) subquery, target->varno,
564
							   1, target->varlevelsup+1, 0);
565

566 567
	return sublink;
}
568 569


570 571 572 573 574 575 576 577 578 579 580 581 582 583
/*
 * modifyAggrefQual -
 *	Search for qualification expressions that contain aggregate
 *	functions and substitute them by sublinks. These expressions
 *	originally come from qualifications that use aggregate columns
 *	of a view.
 *
 *	The return value is a modified copy of the given expression tree.
 */
static Node *
modifyAggrefQual(Node *node, Query *parsetree)
{
	if (node == NULL)
		return NULL;
584 585
	if (IsA(node, Aggref))
	{
586 587 588 589
		SubLink    *sub = modifyAggrefMakeSublink((Aggref *) node, parsetree);

		parsetree->hasSubLinks = true;
		return (Node *) sub;
590
	}
591 592 593 594
	/*
	 * Otherwise, fall through and copy the expr normally.
	 *
	 * We do NOT recurse into subselects in this routine.  It's sufficient
595 596 597 598
	 * to get rid of aggregates that are in the qual expression proper.
	 */
	return expression_tree_mutator(node, modifyAggrefQual,
								   (void *) parsetree);
599 600 601
}


602 603 604 605 606 607 608 609
/*
 * checkQueryHasAggs -
 *	Queries marked hasAggs might not have them any longer after
 *	rewriting. Check it.
 */
static bool
checkQueryHasAggs(Node *node)
{
610
	return checkQueryHasAggs_walker(node, NULL);
611 612
}

613 614 615 616 617 618 619 620 621
static bool
checkQueryHasAggs_walker(Node *node, void *context)
{
	if (node == NULL)
		return false;
	if (IsA(node, Aggref))
		return true;			/* abort the tree traversal and return true */
	return expression_tree_walker(node, checkQueryHasAggs_walker, context);
}
622

623 624
/*
 * checkQueryHasSubLink -
625
 *	Queries marked hasSubLinks might not have them any longer after
626 627 628 629 630
 *	rewriting. Check it.
 */
static bool
checkQueryHasSubLink(Node *node)
{
631 632
	return checkQueryHasSubLink_walker(node, NULL);
}
633

634 635 636 637 638 639 640 641
static bool
checkQueryHasSubLink_walker(Node *node, void *context)
{
	if (node == NULL)
		return false;
	if (IsA(node, SubLink))
		return true;			/* abort the tree traversal and return true */
	return expression_tree_walker(node, checkQueryHasSubLink_walker, context);
642 643 644
}


645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
static Node *
FindMatchingTLEntry(List *tlist, char *e_attname)
{
	List	   *i;

	foreach(i, tlist)
	{
		TargetEntry *tle = lfirst(i);
		char	   *resname;

		resname = tle->resdom->resname;
		if (!strcmp(e_attname, resname))
			return (tle->expr);
	}
	return NULL;
}


static Node *
make_null(Oid type)
{
	Const	   *c = makeNode(Const);

	c->consttype = type;
	c->constlen = get_typlen(type);
	c->constvalue = PointerGetDatum(NULL);
	c->constisnull = true;
	c->constbyval = get_typbyval(type);
	return (Node *) c;
}


677 678 679 680 681 682 683 684 685 686 687
/*
 * apply_RIR_adjust_sublevel -
 *	Set the varlevelsup field of all Var nodes in the given expression tree
 *	to sublevels_up.  We do NOT recurse into subselects.
 *
 * NOTE: although this has the form of a walker, we cheat and modify the
 * Var nodes in-place.  The given expression tree should have been copied
 * earlier to ensure that no unwanted side-effects occur!
 */
static bool
apply_RIR_adjust_sublevel_walker(Node *node, int *sublevels_up)
Bruce Momjian's avatar
Bruce Momjian committed
688 689
{
	if (node == NULL)
690 691
		return false;
	if (IsA(node, Var))
Bruce Momjian's avatar
Bruce Momjian committed
692
	{
693
		Var		   *var = (Var *) node;
Bruce Momjian's avatar
Bruce Momjian committed
694

695 696
		var->varlevelsup = *sublevels_up;
		return false;
Bruce Momjian's avatar
Bruce Momjian committed
697
	}
698 699
	return expression_tree_walker(node, apply_RIR_adjust_sublevel_walker,
								  (void *) sublevels_up);
Bruce Momjian's avatar
Bruce Momjian committed
700 701
}

702
static void
703
apply_RIR_adjust_sublevel(Node *node, int sublevels_up)
704
{
705 706
	apply_RIR_adjust_sublevel_walker(node, &sublevels_up);
}
707 708


709 710 711 712
/*
 * apply_RIR_view
 *	Replace Vars matching a given RT index with copies of TL expressions.
 */
713

714 715 716 717 718 719 720
typedef struct {
	int				rt_index;
	int				sublevels_up;
	RangeTblEntry  *rte;
	List		   *tlist;
	int			   *modified;
} apply_RIR_view_context;
721

722 723 724 725 726 727 728 729 730
static Node *
apply_RIR_view_mutator(Node *node,
					   apply_RIR_view_context *context)
{
	if (node == NULL)
		return NULL;
	if (IsA(node, Var))
	{
		Var		   *var = (Var *) node;
731

732 733 734 735
		if (var->varlevelsup == context->sublevels_up &&
			var->varno == context->rt_index)
		{
			Node	   *expr;
736

737 738 739 740
			if (var->varattno < 0)
				elog(ERROR, "system column %s not available - %s is a view",
					 get_attname(context->rte->relid, var->varattno),
					 context->rte->relname);
741

742 743 744 745
			expr = FindMatchingTLEntry(context->tlist,
									   get_attname(context->rte->relid,
												   var->varattno));
			if (expr == NULL)
746
			{
747 748
				/* XXX shouldn't this be an error condition? */
				return make_null(var->vartype);
749 750
			}

751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
			expr = copyObject(expr);
			if (var->varlevelsup > 0)
				apply_RIR_adjust_sublevel(expr, var->varlevelsup);
			*(context->modified) = true;
			return (Node *) expr;
		}
		/* otherwise fall through to copy the var normally */
	}
	/*
	 * Since expression_tree_mutator won't touch subselects, we have to
	 * handle them specially.
	 */
	if (IsA(node, SubLink))
	{
		SubLink   *sublink = (SubLink *) node;
		SubLink   *newnode;

		FLATCOPY(newnode, sublink, SubLink);
		MUTATE(newnode->lefthand, sublink->lefthand, List *,
			   apply_RIR_view_mutator, context);
		context->sublevels_up++;
		MUTATE(newnode->subselect, sublink->subselect, Node *,
			   apply_RIR_view_mutator, context);
		context->sublevels_up--;
		return (Node *) newnode;
	}
	if (IsA(node, Query))
	{
		Query  *query = (Query *) node;
		Query  *newnode;

		FLATCOPY(newnode, query, Query);
		MUTATE(newnode->targetList, query->targetList, List *,
			   apply_RIR_view_mutator, context);
		MUTATE(newnode->qual, query->qual, Node *,
			   apply_RIR_view_mutator, context);
		MUTATE(newnode->havingQual, query->havingQual, Node *,
			   apply_RIR_view_mutator, context);
		return (Node *) newnode;
	}
	return expression_tree_mutator(node, apply_RIR_view_mutator,
								   (void *) context);
}
794

795 796 797 798 799
static Node *
apply_RIR_view(Node *node, int rt_index, RangeTblEntry *rte, List *tlist,
			   int *modified, int sublevels_up)
{
	apply_RIR_view_context	context;
800

801 802 803 804 805
	context.rt_index = rt_index;
	context.sublevels_up = sublevels_up;
	context.rte = rte;
	context.tlist = tlist;
	context.modified = modified;
806

807
	return apply_RIR_view_mutator(node, &context);
808 809 810
}


811
static Query *
812 813 814 815 816
ApplyRetrieveRule(Query *parsetree,
				  RewriteRule *rule,
				  int rt_index,
				  int relation_level,
				  Relation relation,
817
				  bool relWasInJoinSet,
818 819 820 821 822
				  int *modified)
{
	Query	   *rule_action = NULL;
	Node	   *rule_qual;
	List	   *rtable,
823
			   *addedrtable,
824
			   *l;
825 826
	int			nothing,
				rt_length;
827
	int			badsql = false;
828 829 830 831 832 833 834 835

	rule_qual = rule->qual;
	if (rule->actions)
	{
		if (length(rule->actions) > 1)	/* ??? because we don't handle
										 * rules with more than one
										 * action? -ay */

836
			return parsetree;
837 838 839 840 841 842 843
		rule_action = copyObject(lfirst(rule->actions));
		nothing = FALSE;
	}
	else
		nothing = TRUE;

	rtable = copyObject(parsetree->rtable);
844
	rt_length = length(rtable);	/* original length, not counting rule */
845

846 847 848 849 850 851 852 853 854 855 856 857
	addedrtable = copyObject(rule_action->rtable);

	/* If the original rel wasn't in the join set, none of its spawn is.
	 * If it was, then leave the spawn's flags as they are.
	 */
	if (! relWasInJoinSet)
	{
		foreach(l, addedrtable)
		{
			RangeTblEntry *rte = lfirst(l);
			rte->inJoinSet = false;
		}
858 859
	}

860
	rtable = nconc(rtable, addedrtable);
861 862
	parsetree->rtable = rtable;

863
	/* FOR UPDATE of view... */
Bruce Momjian's avatar
Bruce Momjian committed
864
	foreach(l, parsetree->rowMark)
865
	{
Bruce Momjian's avatar
Bruce Momjian committed
866
		if (((RowMark *) lfirst(l))->rti == rt_index)
867 868
			break;
	}
Bruce Momjian's avatar
Bruce Momjian committed
869
	if (l != NULL)				/* oh, hell -:) */
870
	{
Bruce Momjian's avatar
Bruce Momjian committed
871
		RowMark    *newrm;
872 873 874
		Index		rti = 1;
		List	   *l2;

875
		CheckSelectForUpdate(rule_action);
Bruce Momjian's avatar
Bruce Momjian committed
876 877 878 879 880 881

		/*
		 * We believe that rt_index is VIEW - nothing should be marked for
		 * VIEW, but ACL check must be done. As for real tables of VIEW -
		 * their rows must be marked, but we have to skip ACL check for
		 * them.
882
		 */
Bruce Momjian's avatar
Bruce Momjian committed
883
		((RowMark *) lfirst(l))->info &= ~ROW_MARK_FOR_UPDATE;
884

Bruce Momjian's avatar
Bruce Momjian committed
885
		foreach(l2, rule_action->rtable)
886
		{
Bruce Momjian's avatar
Bruce Momjian committed
887

888
			/*
Bruce Momjian's avatar
Bruce Momjian committed
889 890
			 * RTable of VIEW has two entries of VIEW itself - we use
			 * relid to skip them.
891
			 */
Bruce Momjian's avatar
Bruce Momjian committed
892
			if (relation->rd_id != ((RangeTblEntry *) lfirst(l2))->relid)
893 894 895 896 897 898 899 900 901 902 903
			{
				newrm = makeNode(RowMark);
				newrm->rti = rti + rt_length;
				newrm->info = ROW_MARK_FOR_UPDATE;
				lnext(l) = lcons(newrm, lnext(l));
				l = lnext(l);
			}
			rti++;
		}
	}

904
	rule_action->rtable = rtable;
Bruce Momjian's avatar
Bruce Momjian committed
905
	OffsetVarNodes((Node *) rule_qual, rt_length, 0);
Bruce Momjian's avatar
Bruce Momjian committed
906
	OffsetVarNodes((Node *) rule_action, rt_length, 0);
907

Bruce Momjian's avatar
Bruce Momjian committed
908
	ChangeVarNodes((Node *) rule_qual,
909
				   PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
Bruce Momjian's avatar
Bruce Momjian committed
910
	ChangeVarNodes((Node *) rule_action,
911 912 913 914
				   PRS2_CURRENT_VARNO + rt_length, rt_index, 0);

	if (relation_level)
	{
915
		RangeTblEntry  *rte = rt_fetch(rt_index, rtable);
916 917 918 919 920 921 922 923 924

		parsetree = (Query *) apply_RIR_view((Node *) parsetree,
											 rt_index, rte,
											 rule_action->targetList,
											 modified, 0);
		rule_action = (Query *) apply_RIR_view((Node *) rule_action,
											   rt_index, rte,
											   rule_action->targetList,
											   modified, 0);
925 926 927
	}
	else
	{
Bruce Momjian's avatar
Bruce Momjian committed
928 929 930 931 932 933 934 935 936 937 938
		HandleRIRAttributeRule(parsetree, rtable, rule_action->targetList,
							   rt_index, rule->attrno, modified, &badsql);
	}
	if (*modified && !badsql)
	{
		AddQual(parsetree, rule_action->qual);
		AddGroupClause(parsetree, rule_action->groupClause,
					   rule_action->targetList);
		AddHavingQual(parsetree, rule_action->havingQual);
		parsetree->hasAggs = (rule_action->hasAggs || parsetree->hasAggs);
		parsetree->hasSubLinks = (rule_action->hasSubLinks || parsetree->hasSubLinks);
939
	}
940 941

	return parsetree;
942 943 944
}


945 946 947 948 949 950 951 952 953 954
/*
 * fireRIRonSubselect -
 *	Apply fireRIRrules() to each subselect found in the given tree.
 *
 * NOTE: although this has the form of a walker, we cheat and modify the
 * SubLink nodes in-place.  It is caller's responsibility to ensure that
 * no unwanted side-effects occur!
 */
static bool
fireRIRonSubselect(Node *node, void *context)
955 956
{
	if (node == NULL)
957 958
		return false;
	if (IsA(node, SubLink))
Bruce Momjian's avatar
Bruce Momjian committed
959
	{
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989
		/*
		 * Standard expression_tree_walker will not recurse into subselect,
		 * but here we must do so.
		 */
		SubLink    *sub = (SubLink *) node;
		Query	   *qry;

		/* Process lefthand args */
		if (fireRIRonSubselect((Node *) (sub->lefthand), context))
			return true;
		/* Do what we came for */
		qry = fireRIRrules((Query *) (sub->subselect));
		sub->subselect = (Node *) qry;
		/* Must recurse to handle any sub-subselects! */
		if (fireRIRonSubselect((Node *) qry, context))
			return true;
		return false;
	}
	if (IsA(node, Query))
	{
		/* Reach here after recursing down into subselect above... */
		Query	   *qry = (Query *) node;

		if (fireRIRonSubselect((Node *) (qry->targetList), context))
			return true;
		if (fireRIRonSubselect((Node *) (qry->qual), context))
			return true;
		if (fireRIRonSubselect((Node *) (qry->havingQual), context))
			return true;
		return false;
990
	}
991 992
	return expression_tree_walker(node, fireRIRonSubselect,
								  (void *) context);
993 994 995 996 997 998 999 1000 1001 1002
}


/*
 * fireRIRrules -
 *	Apply all RIR rules on each rangetable entry in a query
 */
static Query *
fireRIRrules(Query *parsetree)
{
Bruce Momjian's avatar
Bruce Momjian committed
1003 1004
	int			rt_index;
	RangeTblEntry *rte;
1005
	Relation	rel;
Bruce Momjian's avatar
Bruce Momjian committed
1006 1007 1008 1009
	List	   *locks;
	RuleLock   *rules;
	RewriteRule *rule;
	RewriteRule RIRonly;
1010
	bool		relWasInJoinSet;
1011
	int			modified = false;
Bruce Momjian's avatar
Bruce Momjian committed
1012 1013
	int			i;
	List	   *l;
1014

1015 1016 1017
	/* don't try to convert this into a foreach loop, because
	 * rtable list can get changed each time through...
	 */
1018
	rt_index = 0;
Bruce Momjian's avatar
Bruce Momjian committed
1019 1020
	while (rt_index < length(parsetree->rtable))
	{
1021 1022
		++rt_index;

1023
		rte = rt_fetch(rt_index, parsetree->rtable);
1024

1025 1026 1027 1028 1029 1030 1031 1032
		/*
		 * If the table is not one named in the original FROM clause
		 * then it must be referenced in the query, or we ignore it.
		 * This prevents infinite expansion loop due to new rtable
		 * entries inserted by expansion of a rule.
		 */
		if (! rte->inFromCl && rt_index != parsetree->resultRelation &&
			! rangeTableEntry_used((Node *) parsetree, rt_index, 0))
1033
		{
1034 1035
			/* Make sure the planner ignores it too... */
			rte->inJoinSet = false;
1036
			continue;
1037
		}
Bruce Momjian's avatar
Bruce Momjian committed
1038

1039
		rel = heap_openr(rte->relname, AccessShareLock);
1040 1041
		rules = rel->rd_rules;
		if (rules == NULL)
Bruce Momjian's avatar
Bruce Momjian committed
1042
		{
1043
			heap_close(rel, AccessShareLock);
1044 1045 1046
			continue;
		}

1047
		relWasInJoinSet = rte->inJoinSet; /* save before possibly clearing */
1048 1049 1050 1051

		/*
		 * Collect the RIR rules that we must apply
		 */
1052
		locks = NIL;
Bruce Momjian's avatar
Bruce Momjian committed
1053 1054
		for (i = 0; i < rules->numLocks; i++)
		{
1055 1056 1057
			rule = rules->rules[i];
			if (rule->event != CMD_SELECT)
				continue;
Bruce Momjian's avatar
Bruce Momjian committed
1058

1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
			if (rule->attrno > 0)
			{
				/* per-attr rule; do we need it? */
				if (! attribute_used((Node *) parsetree,
									 rt_index,
									 rule->attrno, 0))
					continue;
			}
			else
			{
				/* Rel-wide ON SELECT DO INSTEAD means this is a view.
				 * Remove the view from the planner's join target set,
				 * or we'll get no rows out because view itself is empty!
				 */
				if (rule->isInstead)
					rte->inJoinSet = false;
			}
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087

			locks = lappend(locks, rule);
		}

		/*
		 * Check permissions
		 */
		checkLockPerms(locks, parsetree, rt_index);

		/*
		 * Now apply them
		 */
Bruce Momjian's avatar
Bruce Momjian committed
1088 1089
		foreach(l, locks)
		{
1090 1091
			rule = lfirst(l);

Bruce Momjian's avatar
Bruce Momjian committed
1092 1093 1094 1095
			RIRonly.event = rule->event;
			RIRonly.attrno = rule->attrno;
			RIRonly.qual = rule->qual;
			RIRonly.actions = rule->actions;
1096

1097 1098 1099 1100 1101
			parsetree = ApplyRetrieveRule(parsetree,
										  &RIRonly,
										  rt_index,
										  RIRonly.attrno == -1,
										  rel,
1102
										  relWasInJoinSet,
1103
										  &modified);
1104 1105
		}

1106
		heap_close(rel, AccessShareLock);
1107 1108
	}

1109 1110
	if (parsetree->hasSubLinks)
		fireRIRonSubselect((Node *) parsetree, NULL);
1111

1112 1113
	if (parsetree->hasAggs)
		parsetree->qual = modifyAggrefQual(parsetree->qual, parsetree);
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140

	return parsetree;
}


/*
 * idea is to fire regular rules first, then qualified instead
 * rules and unqualified instead rules last. Any lemming is counted for.
 */
static List *
orderRules(List *locks)
{
	List	   *regular = NIL;
	List	   *instead_rules = NIL;
	List	   *instead_qualified = NIL;
	List	   *i;

	foreach(i, locks)
	{
		RewriteRule *rule_lock = (RewriteRule *) lfirst(i);

		if (rule_lock->isInstead)
		{
			if (rule_lock->qual == NULL)
				instead_rules = lappend(instead_rules, rule_lock);
			else
				instead_qualified = lappend(instead_qualified, rule_lock);
1141
		}
1142 1143
		else
			regular = lappend(regular, rule_lock);
1144
	}
1145 1146
	regular = nconc(regular, instead_qualified);
	return nconc(regular, instead_rules);
1147 1148
}

1149 1150


1151
static Query *
1152 1153 1154
CopyAndAddQual(Query *parsetree,
			   List *actions,
			   Node *rule_qual,
1155 1156
			   int rt_index,
			   CmdType event)
1157
{
1158 1159 1160
	Query	   *new_tree = (Query *) copyObject(parsetree);
	Node	   *new_qual = NULL;
	Query	   *rule_action = NULL;
1161 1162 1163 1164 1165 1166 1167

	if (actions)
		rule_action = lfirst(actions);
	if (rule_qual != NULL)
		new_qual = (Node *) copyObject(rule_qual);
	if (rule_action != NULL)
	{
1168 1169
		List	   *rtable;
		int			rt_length;
1170 1171 1172

		rtable = new_tree->rtable;
		rt_length = length(rtable);
Bruce Momjian's avatar
Bruce Momjian committed
1173
		rtable = nconc(rtable, copyObject(rule_action->rtable));
1174
		new_tree->rtable = rtable;
Bruce Momjian's avatar
Bruce Momjian committed
1175
		OffsetVarNodes(new_qual, rt_length, 0);
1176
		ChangeVarNodes(new_qual, PRS2_CURRENT_VARNO + rt_length, rt_index, 0);
1177 1178 1179 1180 1181
	}
	/* XXX -- where current doesn't work for instead nothing.... yet */
	AddNotQual(new_tree, new_qual);

	return new_tree;
1182 1183 1184
}


1185

1186
/*
1187
 *	fireRules -
1188 1189 1190 1191 1192
 *	   Iterate through rule locks applying rules.
 *	   All rules create their own parsetrees. Instead rules
 *	   with rule qualification save the original parsetree
 *	   and add their negated qualification to it. Real instead
 *	   rules finally throw away the original parsetree.
1193
 *
1194
 *	   remember: reality is for dead birds -- glass
1195 1196
 *
 */
1197
static List *
1198
fireRules(Query *parsetree,
1199 1200
		  int rt_index,
		  CmdType event,
1201 1202 1203
		  bool *instead_flag,
		  List *locks,
		  List **qual_products)
1204
{
1205 1206 1207
	RewriteInfo *info;
	List	   *results = NIL;
	List	   *i;
1208 1209 1210

	/* choose rule to fire from list of rules */
	if (locks == NIL)
1211
		return NIL;
1212

1213
	locks = orderRules(locks);	/* real instead rules last */
1214 1215
	foreach(i, locks)
	{
1216 1217 1218 1219 1220
		RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
		Node	   *qual,
				   *event_qual;
		List	   *actions;
		List	   *r;
1221

1222
		/*
1223 1224 1225 1226 1227 1228
		 * Instead rules change the resultRelation of the query. So the
		 * permission checks on the initial resultRelation would never be
		 * done (this is normally done in the executor deep down). So we
		 * must do it here. The result relations resulting from earlier
		 * rewrites are already checked against the rules eventrelation
		 * owner (during matchLocks) and have the skipAcl flag set.
1229
		 */
1230 1231 1232 1233
		if (rule_lock->isInstead &&
			parsetree->commandType != CMD_SELECT)
		{
			RangeTblEntry *rte;
1234 1235 1236
			int32		acl_rc;
			int32		reqperm;

1237 1238
			switch (parsetree->commandType)
			{
1239 1240 1241 1242 1243 1244 1245
				case CMD_INSERT:
					reqperm = ACL_AP;
					break;
				default:
					reqperm = ACL_WR;
					break;
			}
1246

1247
			rte = rt_fetch(parsetree->resultRelation, parsetree->rtable);
1248 1249
			if (!rte->skipAcl)
			{
1250
				acl_rc = pg_aclcheck(rte->relname,
1251 1252 1253
									 GetPgUserName(), reqperm);
				if (acl_rc != ACLCHECK_OK)
				{
1254
					elog(ERROR, "%s: %s",
1255 1256
						 rte->relname,
						 aclcheck_error_strings[acl_rc]);
1257 1258 1259 1260
				}
			}
		}

1261 1262 1263 1264
		/* multiple rule action time */
		*instead_flag = rule_lock->isInstead;
		event_qual = rule_lock->qual;
		actions = rule_lock->actions;
1265 1266 1267 1268
		if (event_qual != NULL && *instead_flag)
		{
			Query	   *qual_product;
			RewriteInfo qual_info;
1269 1270 1271 1272 1273

			/* ----------
			 * If there are instead rules with qualifications,
			 * the original query is still performed. But all
			 * the negated rule qualifications of the instead
1274
			 * rules are added so it does its actions only
1275 1276 1277 1278 1279 1280 1281
			 * in cases where the rule quals of all instead
			 * rules are false. Think of it as the default
			 * action in a case. We save this in *qual_products
			 * so deepRewriteQuery() can add it to the query
			 * list after we mangled it up enough.
			 * ----------
			 */
1282
			if (*qual_products == NIL)
1283
				qual_product = parsetree;
1284 1285
			else
				qual_product = (Query *) nth(0, *qual_products);
1286

1287 1288 1289 1290 1291 1292 1293 1294 1295
			qual_info.event = qual_product->commandType;
			qual_info.new_varno = length(qual_product->rtable) + 2;
			qual_product = CopyAndAddQual(qual_product,
										  actions,
										  event_qual,
										  rt_index,
										  event);

			qual_info.rule_action = qual_product;
1296 1297 1298 1299 1300 1301 1302

			if (event == CMD_INSERT || event == CMD_UPDATE)
				FixNew(&qual_info, qual_product);

			*qual_products = lappend(NIL, qual_product);
		}

1303 1304
		foreach(r, actions)
		{
1305 1306
			Query	   *rule_action = lfirst(r);
			Node	   *rule_qual = copyObject(event_qual);
1307

1308 1309 1310
			if (rule_action->commandType == CMD_NOTHING)
				continue;

Bruce Momjian's avatar
Bruce Momjian committed
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
			/*--------------------------------------------------
			 * We copy the qualifications of the parsetree
			 * to the action and vice versa. So force
			 * hasSubLinks if one of them has it.
			 *
			 * As of 6.4 only parsetree qualifications can
			 * have sublinks. If this changes, we must make
			 * this a node lookup at the end of rewriting.
			 *
			 * Jan
			 *--------------------------------------------------
			 */
			if (parsetree->hasSubLinks && !rule_action->hasSubLinks)
			{
				rule_action = copyObject(rule_action);
				rule_action->hasSubLinks = TRUE;
			}
			if (!parsetree->hasSubLinks && rule_action->hasSubLinks)
				parsetree->hasSubLinks = TRUE;

1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
			/*--------------------------------------------------
			 * Step 1:
			 *	  Rewrite current.attribute or current to tuple variable
			 *	  this appears to be done in parser?
			 *--------------------------------------------------
			 */
			info = gatherRewriteMeta(parsetree, rule_action, rule_qual,
									 rt_index, event, instead_flag);

			/* handle escapable cases, or those handled by other code */
			if (info->nothing)
			{
				if (*instead_flag)
					return NIL;
				else
					continue;
			}

			if (info->action == info->event &&
				info->event == CMD_SELECT)
				continue;

			/*
1354
			 * Event Qualification forces copying of parsetree and
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378
			 * splitting into two queries one w/rule_qual, one w/NOT
			 * rule_qual. Also add user query qual onto rule action
			 */
			qual = parsetree->qual;
			AddQual(info->rule_action, qual);

			if (info->rule_qual != NULL)
				AddQual(info->rule_action, info->rule_qual);

			/*--------------------------------------------------
			 * Step 2:
			 *	  Rewrite new.attribute w/ right hand side of target-list
			 *	  entry for appropriate field name in insert/update
			 *--------------------------------------------------
			 */
			if ((info->event == CMD_INSERT) || (info->event == CMD_UPDATE))
				FixNew(info, parsetree);

			/*--------------------------------------------------
			 * Step 3:
			 *	  rewriting due to retrieve rules
			 *--------------------------------------------------
			 */
			info->rule_action->rtable = info->rt;
Bruce Momjian's avatar
Bruce Momjian committed
1379

1380
			/*
Bruce Momjian's avatar
Bruce Momjian committed
1381 1382 1383
			 * ProcessRetrieveQuery(info->rule_action, info->rt,
			 * &orig_instead_flag, TRUE);
			 */
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394

			/*--------------------------------------------------
			 * Step 4
			 *	  Simplify? hey, no algorithm for simplification... let
			 *	  the planner do it.
			 *--------------------------------------------------
			 */
			results = lappend(results, info->rule_action);

			pfree(info);
		}
1395 1396 1397 1398 1399 1400

		/* ----------
		 * If this was an unqualified instead rule,
		 * throw away an eventually saved 'default' parsetree
		 * ----------
		 */
1401
		if (event_qual == NULL && *instead_flag)
1402
			*qual_products = NIL;
1403 1404
	}
	return results;
1405 1406
}

1407 1408


1409
static List *
1410
RewriteQuery(Query *parsetree, bool *instead_flag, List **qual_products)
1411
{
1412
	CmdType		event;
Bruce Momjian's avatar
Bruce Momjian committed
1413 1414 1415
	List	   *product_queries = NIL;
	int			result_relation = 0;
	RangeTblEntry *rt_entry;
1416
	Relation	rt_entry_relation = NULL;
Bruce Momjian's avatar
Bruce Momjian committed
1417
	RuleLock   *rt_entry_locks = NULL;
1418

1419 1420 1421 1422
	Assert(parsetree != NULL);

	event = parsetree->commandType;

1423
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1424 1425
	 * SELECT rules are handled later when we have all the queries that
	 * should get executed
1426 1427 1428 1429 1430 1431 1432
	 */
	if (event == CMD_SELECT)
		return NIL;

	/*
	 * Utilities aren't rewritten at all - why is this here?
	 */
1433 1434
	if (event == CMD_UTILITY)
		return NIL;
1435

1436
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1437
	 * the statement is an update, insert or delete - fire rules on it.
1438
	 */
1439
	result_relation = parsetree->resultRelation;
1440
	rt_entry = rt_fetch(result_relation, parsetree->rtable);
1441
	rt_entry_relation = heap_openr(rt_entry->relname, AccessShareLock);
1442
	rt_entry_locks = rt_entry_relation->rd_rules;
1443
	heap_close(rt_entry_relation, AccessShareLock);
1444

1445
	if (rt_entry_locks != NULL)
1446
	{
1447
		List	   *locks = matchLocks(event, rt_entry_locks, result_relation, parsetree);
1448

1449
		product_queries = fireRules(parsetree,
Bruce Momjian's avatar
Bruce Momjian committed
1450 1451 1452 1453 1454
									result_relation,
									event,
									instead_flag,
									locks,
									qual_products);
1455
	}
1456

1457
	return product_queries;
1458 1459
}

1460

1461 1462 1463 1464 1465
/*
 * to avoid infinite recursion, we restrict the number of times a query
 * can be rewritten. Detecting cycles is left for the reader as an excercise.
 */
#ifndef REWRITE_INVOKE_MAX
1466
#define REWRITE_INVOKE_MAX		10
1467 1468
#endif

1469
static int	numQueryRewriteInvoked = 0;
1470 1471 1472

/*
 * deepRewriteQuery -
1473
 *	  rewrites the query and apply the rules again on the queries rewritten
1474
 */
1475
static List *
1476
deepRewriteQuery(Query *parsetree)
1477
{
1478 1479 1480 1481 1482
	List	   *n;
	List	   *rewritten = NIL;
	List	   *result = NIL;
	bool		instead;
	List	   *qual_products = NIL;
1483

1484 1485


1486 1487
	if (++numQueryRewriteInvoked > REWRITE_INVOKE_MAX)
	{
1488
		elog(ERROR, "query rewritten %d times, may contain cycles",
1489 1490 1491 1492 1493
			 numQueryRewriteInvoked - 1);
	}

	instead = FALSE;
	result = RewriteQuery(parsetree, &instead, &qual_products);
1494

1495 1496
	foreach(n, result)
	{
1497 1498
		Query	   *pt = lfirst(n);
		List	   *newstuff = NIL;
1499 1500 1501 1502 1503

		newstuff = deepRewriteQuery(pt);
		if (newstuff != NIL)
			rewritten = nconc(rewritten, newstuff);
	}
1504 1505 1506 1507 1508 1509

	/* ----------
	 * qual_products are the original query with the negated
	 * rule qualification of an instead rule
	 * ----------
	 */
1510 1511 1512
	if (qual_products != NIL)
		rewritten = nconc(rewritten, qual_products);

1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
	/* ----------
	 * The original query is appended last if not instead
	 * because update and delete rule actions might not do
	 * anything if they are invoked after the update or
	 * delete is performed. The command counter increment
	 * between the query execution makes the deleted (and
	 * maybe the updated) tuples disappear so the scans
	 * for them in the rule actions cannot find them.
	 * ----------
	 */
	if (!instead)
		rewritten = lappend(rewritten, parsetree);

1526 1527
	return rewritten;
}
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546


/*
 * QueryOneRewrite -
 *	  rewrite one query
 */
static List *
QueryRewriteOne(Query *parsetree)
{
	numQueryRewriteInvoked = 0;

	/*
	 * take a deep breath and apply all the rewrite rules - ay
	 */
	return deepRewriteQuery(parsetree);
}


/*
1547
 * BasicQueryRewrite -
1548 1549 1550
 *	  rewrite one query via query rewrite system, possibly returning 0
 *	  or many queries
 */
1551 1552
static List *
BasicQueryRewrite(Query *parsetree)
1553
{
Bruce Momjian's avatar
Bruce Momjian committed
1554 1555 1556 1557
	List	   *querylist;
	List	   *results = NIL;
	List	   *l;
	Query	   *query;
1558 1559 1560 1561 1562 1563 1564 1565 1566

	/*
	 * Step 1
	 *
	 * Apply all non-SELECT rules possibly getting 0 or many queries
	 */
	querylist = QueryRewriteOne(parsetree);

	/*
1567
	 * Step 2
1568 1569 1570
	 *
	 * Apply all the RIR rules on each query
	 */
Bruce Momjian's avatar
Bruce Momjian committed
1571 1572 1573 1574
	foreach(l, querylist)
	{
		query = fireRIRrules((Query *) lfirst(l));

1575
		/*
Bruce Momjian's avatar
Bruce Momjian committed
1576
		 * If the query was marked having aggregates, check if this is
1577 1578
		 * still true after rewriting.  Ditto for sublinks.  Note there
		 * should be no aggs in the qual at this point.
1579 1580
		 */
		if (query->hasAggs)
1581 1582 1583 1584 1585 1586 1587
		{
			query->hasAggs =
				checkQueryHasAggs((Node *) (query->targetList)) ||
				checkQueryHasAggs((Node *) (query->havingQual));
			if (checkQueryHasAggs((Node *) (query->qual)))
				elog(ERROR, "BasicQueryRewrite: failed to remove aggs from qual");
		}
1588
		if (query->hasSubLinks)
1589 1590 1591 1592
			query->hasSubLinks =
				checkQueryHasSubLink((Node *) (query->targetList)) ||
				checkQueryHasSubLink((Node *) (query->qual)) ||
				checkQueryHasSubLink((Node *) (query->havingQual));
1593
		results = lappend(results, query);
1594
	}
1595

1596 1597
	return results;
}
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608

/*
 * QueryRewrite -
 *	  Primary entry point to the query rewriter.
 *	  Rewrite one query via query rewrite system, possibly returning 0
 *	  or many queries.
 *
 * NOTE: The code in QueryRewrite was formerly in pg_parse_and_plan(), and was
 * moved here so that it would be invoked during EXPLAIN.  The division of
 * labor between this routine and BasicQueryRewrite is not obviously correct
 * ... at least not to me ... tgl 5/99.
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1609
 */
1610 1611 1612 1613 1614 1615
List *
QueryRewrite(Query *parsetree)
{
	List	   *rewritten,
			   *rewritten_item;

Bruce Momjian's avatar
Bruce Momjian committed
1616 1617 1618 1619
	/*
	 * Rewrite Union, Intersect and Except Queries to normal Union Queries
	 * using IN and NOT IN subselects
	 */
1620 1621 1622 1623 1624 1625 1626 1627 1628
	if (parsetree->intersectClause)
		parsetree = Except_Intersect_Rewrite(parsetree);

	/* Rewrite basic queries (retrieve, append, delete, replace) */
	rewritten = BasicQueryRewrite(parsetree);

	/*
	 * Rewrite the UNIONS.
	 */
Bruce Momjian's avatar
Bruce Momjian committed
1629
	foreach(rewritten_item, rewritten)
1630 1631 1632 1633 1634
	{
		Query	   *qry = (Query *) lfirst(rewritten_item);
		List	   *union_result = NIL;
		List	   *union_item;

Bruce Momjian's avatar
Bruce Momjian committed
1635
		foreach(union_item, qry->unionClause)
1636 1637
		{
			union_result = nconc(union_result,
Bruce Momjian's avatar
Bruce Momjian committed
1638
						BasicQueryRewrite((Query *) lfirst(union_item)));
1639 1640 1641 1642 1643 1644 1645 1646 1647 1648
		}
		qry->unionClause = union_result;
	}

	return rewritten;
}

/* This function takes two targetlists as arguments and checks if the
 * targetlists are compatible (i.e. both select for the same number of
 * attributes and the types are compatible */
1649
static void
Bruce Momjian's avatar
Bruce Momjian committed
1650
check_targetlists_are_compatible(List *prev_target, List *current_target)
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1651
{
Bruce Momjian's avatar
Bruce Momjian committed
1652 1653 1654 1655
	List	   *tl,
			   *next_target;
	int			prev_len = 0,
				next_len = 0;
1656

Bruce Momjian's avatar
Bruce Momjian committed
1657 1658
	foreach(tl, prev_target)
		if (!((TargetEntry *) lfirst(tl))->resdom->resjunk)
1659 1660
		prev_len++;

Bruce Momjian's avatar
Bruce Momjian committed
1661 1662
	foreach(next_target, current_target)
		if (!((TargetEntry *) lfirst(next_target))->resdom->resjunk)
1663
		next_len++;
Bruce Momjian's avatar
Bruce Momjian committed
1664 1665 1666 1667 1668

	if (prev_len != next_len)
		elog(ERROR, "Each UNION | EXCEPT | INTERSECT query must have the same number of columns.");

	foreach(next_target, current_target)
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1669
	{
Bruce Momjian's avatar
Bruce Momjian committed
1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681
		Oid			itype;
		Oid			otype;

		otype = ((TargetEntry *) lfirst(prev_target))->resdom->restype;
		itype = ((TargetEntry *) lfirst(next_target))->resdom->restype;

		/* one or both is a NULL column? then don't convert... */
		if (otype == InvalidOid)
		{
			/* propagate a known type forward, if available */
			if (itype != InvalidOid)
				((TargetEntry *) lfirst(prev_target))->resdom->restype = itype;
1682
#ifdef NOT_USED
Bruce Momjian's avatar
Bruce Momjian committed
1683 1684 1685 1686 1687
			else
			{
				((TargetEntry *) lfirst(prev_target))->resdom->restype = UNKNOWNOID;
				((TargetEntry *) lfirst(next_target))->resdom->restype = UNKNOWNOID;
			}
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1688
#endif
Bruce Momjian's avatar
Bruce Momjian committed
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
		}
		else if (itype == InvalidOid)
		{
		}
		/* they don't match in type? then convert... */
		else if (itype != otype)
		{
			Node	   *expr;

			expr = ((TargetEntry *) lfirst(next_target))->expr;
1699
			expr = CoerceTargetExpr(NULL, expr, itype, otype, -1);
Bruce Momjian's avatar
Bruce Momjian committed
1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
			if (expr == NULL)
			{
				elog(ERROR, "Unable to transform %s to %s"
					 "\n\tEach UNION | EXCEPT | INTERSECT clause must have compatible target types",
					 typeidTypeName(itype),
					 typeidTypeName(otype));
			}
			((TargetEntry *) lfirst(next_target))->expr = expr;
			((TargetEntry *) lfirst(next_target))->resdom->restype = otype;
		}

		/* both are UNKNOWN? then evaluate as text... */
		else if (itype == UNKNOWNOID)
		{
			((TargetEntry *) lfirst(next_target))->resdom->restype = TEXTOID;
			((TargetEntry *) lfirst(prev_target))->resdom->restype = TEXTOID;
		}
		prev_target = lnext(prev_target);
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1718 1719 1720 1721
	}
}

/* Rewrites UNION INTERSECT and EXCEPT queries to semantiacally equivalent
Bruce Momjian's avatar
Bruce Momjian committed
1722 1723
 * queries that use IN and NOT IN subselects.
 *
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
 * The operator tree is attached to 'intersectClause' (see rule
 * 'SelectStmt' in gram.y) of the 'parsetree' given as an
 * argument. First we remember some clauses (the sortClause, the
 * unique flag etc.)  Then we translate the operator tree to DNF
 * (disjunctive normal form) by 'cnfify'. (Note that 'cnfify' produces
 * CNF but as we exchanged ANDs with ORs in function A_Expr_to_Expr()
 * earlier we get DNF after exchanging ANDs and ORs again in the
 * result.) Now we create a new query by evaluating the new operator
 * tree which is in DNF now. For every AND we create an entry in the
 * union list and for every OR we create an IN subselect. (NOT IN
 * subselects are created for OR NOT nodes). The first entry of the
 * union list is handed back but before that the remembered clauses
Bruce Momjian's avatar
Bruce Momjian committed
1736
 * (sortClause etc) are attached to the new top Node (Note that the
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1737 1738 1739
 * new top Node can differ from the parsetree given as argument because of
 * the translation to DNF. That's why we have to remember the sortClause or
 * unique flag!) */
1740
static Query *
Bruce Momjian's avatar
Bruce Momjian committed
1741
Except_Intersect_Rewrite(Query *parsetree)
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1742
{
Bruce Momjian's avatar
Bruce Momjian committed
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761

	SubLink    *n;
	Query	   *result,
			   *intersect_node;
	List	   *elist,
			   *intersect_list = NIL,
			   *intersect,
			   *intersectClause;
	List	   *union_list = NIL,
			   *sortClause;
	List	   *left_expr,
			   *right_expr,
			   *resnames = NIL;
	char	   *op,
			   *uniqueFlag,
			   *into;
	bool		isBinary,
				isPortal,
				isTemp;
1762 1763
	Node	   *limitOffset,
			   *limitCount;
Bruce Momjian's avatar
Bruce Momjian committed
1764
	CmdType		commandType = CMD_SELECT;
1765
	RangeTblEntry *rtable_insert = NULL;
Bruce Momjian's avatar
Bruce Momjian committed
1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
	List	   *prev_target = NIL;

	/*
	 * Remember the Resnames of the given parsetree's targetlist (these
	 * are the resnames of the first Select Statement of the query
	 * formulated by the user and he wants the columns named by these
	 * strings. The transformation to DNF can cause another Select
	 * Statment to be the top one which uses other names for its columns.
	 * Therefore we remeber the original names and attach them to the
	 * targetlist of the new topmost Node at the end of this function
	 */
	foreach(elist, parsetree->targetList)
	{
		TargetEntry *tent = (TargetEntry *) lfirst(elist);

		resnames = lappend(resnames, tent->resdom->resname);
	}

	/*
	 * If the Statement is an INSERT INTO ... (SELECT...) statement using
	 * UNIONs, INTERSECTs or EXCEPTs and the transformation to DNF makes
	 * another Node to the top node we have to transform the new top node
	 * to an INSERT node and the original INSERT node to a SELECT node
	 */
	if (parsetree->commandType == CMD_INSERT)
	{
		/*
		 * The result relation ( = the one to insert into) has to be
		 * attached to the rtable list of the new top node
		 */
1796 1797 1798 1799 1800
		rtable_insert = rt_fetch(parsetree->resultRelation, parsetree->rtable);

		parsetree->commandType = CMD_SELECT;
		commandType = CMD_INSERT;
		parsetree->resultRelation = 0;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1801
	}
Bruce Momjian's avatar
Bruce Momjian committed
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812

	/*
	 * Save some items, to be able to attach them to the resulting top
	 * node at the end of the function
	 */
	sortClause = parsetree->sortClause;
	uniqueFlag = parsetree->uniqueFlag;
	into = parsetree->into;
	isBinary = parsetree->isBinary;
	isPortal = parsetree->isPortal;
	isTemp = parsetree->isTemp;
1813 1814
	limitOffset = parsetree->limitOffset;
	limitCount = parsetree->limitCount;
Bruce Momjian's avatar
Bruce Momjian committed
1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869

	/*
	 * The operator tree attached to parsetree->intersectClause is still
	 * 'raw' ( = the leaf nodes are still SelectStmt nodes instead of
	 * Query nodes) So step through the tree and transform the nodes using
	 * parse_analyze().
	 *
	 * The parsetree (given as an argument to Except_Intersect_Rewrite()) has
	 * already been transformed and transforming it again would cause
	 * troubles.  So we give the 'raw' version (of the cooked parsetree)
	 * to the function to prevent an additional transformation. Instead we
	 * hand back the 'cooked' version also given as an argument to
	 * intersect_tree_analyze()
	 */
	intersectClause =
		(List *) intersect_tree_analyze((Node *) parsetree->intersectClause,
								 (Node *) lfirst(parsetree->unionClause),
										(Node *) parsetree);

	/* intersectClause is no longer needed so set it to NIL */
	parsetree->intersectClause = NIL;

	/*
	 * unionClause will be needed later on but the list it delivered is no
	 * longer needed, so set it to NIL
	 */
	parsetree->unionClause = NIL;

	/*
	 * Transform the operator tree to DNF (remember ANDs and ORs have been
	 * exchanged, that's why we get DNF by using cnfify)
	 *
	 * After the call, explicit ANDs are removed and all AND operands are
	 * simply items in the intersectClause list
	 */
	intersectClause = cnfify((Expr *) intersectClause, true);

	/*
	 * For every entry of the intersectClause list we generate one entry
	 * in the union_list
	 */
	foreach(intersect, intersectClause)
	{

		/*
		 * for every OR we create an IN subselect and for every OR NOT we
		 * create a NOT IN subselect, so first extract all the Select
		 * Query nodes from the tree (that contains only OR or OR NOTs any
		 * more because we did a transformation to DNF
		 *
		 * There must be at least one node that is not negated (i.e. just OR
		 * and not OR NOT) and this node will be the first in the list
		 * returned
		 */
		intersect_list = NIL;
1870
		create_intersect_list((Node *) lfirst(intersect), &intersect_list);
Bruce Momjian's avatar
Bruce Momjian committed
1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943

		/*
		 * This one will become the Select Query node, all other nodes are
		 * transformed into subselects under this node!
		 */
		intersect_node = (Query *) lfirst(intersect_list);
		intersect_list = lnext(intersect_list);

		/*
		 * Check if all Select Statements use the same number of
		 * attributes and if all corresponding attributes are of the same
		 * type
		 */
		if (prev_target)
			check_targetlists_are_compatible(prev_target, intersect_node->targetList);
		prev_target = intersect_node->targetList;
		/* End of check for corresponding targetlists */

		/*
		 * Transform all nodes remaining into subselects and add them to
		 * the qualifications of the Select Query node
		 */
		while (intersect_list != NIL)
		{

			n = makeNode(SubLink);

			/* Here we got an OR so transform it to an IN subselect */
			if (IsA(lfirst(intersect_list), Query))
			{

				/*
				 * Check if all Select Statements use the same number of
				 * attributes and if all corresponding attributes are of
				 * the same type
				 */
				check_targetlists_are_compatible(prev_target,
						 ((Query *) lfirst(intersect_list))->targetList);
				/* End of check for corresponding targetlists */

				n->subselect = lfirst(intersect_list);
				op = "=";
				n->subLinkType = ANY_SUBLINK;
				n->useor = false;
			}

			/*
			 * Here we got an OR NOT node so transform it to a NOT IN
			 * subselect
			 */
			else
			{

				/*
				 * Check if all Select Statements use the same number of
				 * attributes and if all corresponding attributes are of
				 * the same type
				 */
				check_targetlists_are_compatible(prev_target,
												 ((Query *) lfirst(((Expr *) lfirst(intersect_list))->args))->targetList);
				/* End of check for corresponding targetlists */

				n->subselect = (Node *) lfirst(((Expr *) lfirst(intersect_list))->args);
				op = "<>";
				n->subLinkType = ALL_SUBLINK;
				n->useor = true;
			}

			/*
			 * Prepare the lefthand side of the Sublinks: All the entries
			 * of the targetlist must be (IN) or must not be (NOT IN) the
			 * subselect
			 */
1944
			n->lefthand = NIL;
Bruce Momjian's avatar
Bruce Momjian committed
1945 1946
			foreach(elist, intersect_node->targetList)
			{
1947
				TargetEntry *tent = (TargetEntry *) lfirst(elist);
Bruce Momjian's avatar
Bruce Momjian committed
1948 1949 1950 1951 1952

				n->lefthand = lappend(n->lefthand, tent->expr);
			}

			/*
1953 1954
			 * Also prepare the list of Opers that must be used for the
			 * comparisons (they depend on the specific datatypes involved!)
Bruce Momjian's avatar
Bruce Momjian committed
1955 1956 1957
			 */
			left_expr = n->lefthand;
			right_expr = ((Query *) (n->subselect))->targetList;
1958
			n->oper = NIL;
Bruce Momjian's avatar
Bruce Momjian committed
1959 1960 1961 1962

			foreach(elist, left_expr)
			{
				Node	   *lexpr = lfirst(elist);
1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981
				TargetEntry *tent = (TargetEntry *) lfirst(right_expr);
				Operator	optup;
				Form_pg_operator opform;
				Oper	   *newop;

				optup = oper(op,
							 exprType(lexpr),
							 exprType(tent->expr),
							 FALSE);
				opform = (Form_pg_operator) GETSTRUCT(optup);

				if (opform->oprresult != BOOLOID)
					elog(ERROR, "parser: '%s' must return 'bool' to be used with quantified predicate subquery", op);

				newop = makeOper(oprid(optup),/* opno */
								 InvalidOid, /* opid */
								 opform->oprresult,
								 0,
								 NULL);
Bruce Momjian's avatar
Bruce Momjian committed
1982

1983
				n->oper = lappend(n->oper, newop);
Bruce Momjian's avatar
Bruce Momjian committed
1984 1985 1986 1987 1988 1989 1990 1991

				right_expr = lnext(right_expr);
			}

			/*
			 * If the Select Query node has aggregates in use add all the
			 * subselects to the HAVING qual else to the WHERE qual
			 */
1992
			if (intersect_node->hasAggs)
Bruce Momjian's avatar
Bruce Momjian committed
1993
				AddHavingQual(intersect_node, (Node *) n);
1994 1995
			else
				AddQual(intersect_node, (Node *) n);
Bruce Momjian's avatar
Bruce Momjian committed
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015

			/* Now we got sublinks */
			intersect_node->hasSubLinks = true;
			intersect_list = lnext(intersect_list);
		}
		intersect_node->intersectClause = NIL;
		union_list = lappend(union_list, intersect_node);
	}

	/* The first entry to union_list is our new top node */
	result = (Query *) lfirst(union_list);
	/* attach the rest to unionClause */
	result->unionClause = lnext(union_list);
	/* Attach all the items remembered in the beginning of the function */
	result->sortClause = sortClause;
	result->uniqueFlag = uniqueFlag;
	result->into = into;
	result->isPortal = isPortal;
	result->isBinary = isBinary;
	result->isTemp = isTemp;
2016 2017
	result->limitOffset = limitOffset;
	result->limitCount = limitCount;
Bruce Momjian's avatar
Bruce Momjian committed
2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040

	/*
	 * The relation to insert into is attached to the range table of the
	 * new top node
	 */
	if (commandType == CMD_INSERT)
	{
		result->rtable = lappend(result->rtable, rtable_insert);
		result->resultRelation = length(result->rtable);
		result->commandType = commandType;
	}

	/*
	 * The resnames of the originally first SelectStatement are attached
	 * to the new first SelectStatement
	 */
	foreach(elist, result->targetList)
	{
		TargetEntry *tent = (TargetEntry *) lfirst(elist);

		tent->resdom->resname = lfirst(resnames);
		resnames = lnext(resnames);
	}
2041

Bruce Momjian's avatar
Bruce Momjian committed
2042
	return result;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2043 2044 2045 2046 2047 2048 2049
}

/* Create a list of nodes that are either Query nodes of NOT Expr
 * nodes followed by a Query node. The tree given in ptr contains at
 * least one non negated Query node. This node is attached to the
 * beginning of the list */

2050 2051
static void
create_intersect_list(Node *ptr, List **intersect_list)
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2052
{
Bruce Momjian's avatar
Bruce Momjian committed
2053 2054 2055
	List	   *arg;

	if (IsA(ptr, Query))
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2056
	{
Bruce Momjian's avatar
Bruce Momjian committed
2057 2058 2059
		/* The non negated node is attached at the beginning (lcons) */
		*intersect_list = lcons(ptr, *intersect_list);
		return;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2060
	}
Bruce Momjian's avatar
Bruce Momjian committed
2061 2062

	if (IsA(ptr, Expr))
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2063
	{
Bruce Momjian's avatar
Bruce Momjian committed
2064 2065 2066 2067 2068 2069 2070 2071 2072
		if (((Expr *) ptr)->opType == NOT_EXPR)
		{
			/* negated nodes are appended to the end (lappend) */
			*intersect_list = lappend(*intersect_list, ptr);
			return;
		}
		else
		{
			foreach(arg, ((Expr *) ptr)->args)
2073
				create_intersect_list(lfirst(arg), intersect_list);
Bruce Momjian's avatar
Bruce Momjian committed
2074 2075 2076
			return;
		}
		return;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2077 2078 2079 2080 2081
	}
}

/* The nodes given in 'tree' are still 'raw' so 'cook' them using parse_analyze().
 * The node given in first_select has already been cooked, so don't transform
Bruce Momjian's avatar
Bruce Momjian committed
2082
 * it again but return a pointer to the previously cooked version given in 'parsetree'
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2083
 * instead. */
2084
static Node *
Bruce Momjian's avatar
Bruce Momjian committed
2085
intersect_tree_analyze(Node *tree, Node *first_select, Node *parsetree)
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2086
{
Bruce Momjian's avatar
Bruce Momjian committed
2087 2088
	Node	   *result = (Node *) NIL;
	List	   *arg;
2089 2090

	if (IsA(tree, SelectStmt))
Bruce Momjian's avatar
Bruce Momjian committed
2091 2092 2093 2094 2095 2096
	{

		/*
		 * If we get to the tree given in first_select return parsetree
		 * instead of performing parse_analyze()
		 */
2097 2098 2099
		if (tree == first_select)
			result = parsetree;
		else
Bruce Momjian's avatar
Bruce Momjian committed
2100 2101 2102 2103
		{
			/* transform the 'raw' nodes to 'cooked' Query nodes */
			List	   *qtree = parse_analyze(lcons(tree, NIL), NULL);

2104 2105
			result = (Node *) lfirst(qtree);
		}
Bruce Momjian's avatar
Bruce Momjian committed
2106
	}
2107

Bruce Momjian's avatar
Bruce Momjian committed
2108
	if (IsA(tree, Expr))
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2109
	{
Bruce Momjian's avatar
Bruce Momjian committed
2110 2111 2112 2113
		/* Call recursively for every argument of the node */
		foreach(arg, ((Expr *) tree)->args)
			lfirst(arg) = intersect_tree_analyze(lfirst(arg), first_select, parsetree);
		result = tree;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2114
	}
Bruce Momjian's avatar
Bruce Momjian committed
2115
	return result;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
2116
}