xfunc.c 40.6 KB
Newer Older
1 2 3
/*-------------------------------------------------------------------------
 *
 * xfunc.c--
4 5 6 7
 *	  Utility routines to handle expensive function optimization.
 *	  Includes xfunc_trypullup(), which attempts early pullup of predicates
 *	  to allow for maximal pruning.
 *
8 9 10 11
 * Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
12
 *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.26 1999/02/12 06:43:32 momjian Exp $
13 14 15
 *
 *-------------------------------------------------------------------------
 */
16
#include <math.h>				/* for MAXFLOAT on most systems */
17

18
#include <values.h>				/* for MAXFLOAT on SunOS */
19 20 21
#include <string.h>

#include "postgres.h"
22 23 24 25 26 27

#include "access/heapam.h"
#include "catalog/pg_language.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "lib/lispsort.h"
28
#include "nodes/nodes.h"
29
#include "nodes/pg_list.h"
30 31
#include "nodes/primnodes.h"
#include "nodes/relation.h"
32 33
#include "optimizer/clauses.h"
#include "optimizer/cost.h"
34
#include "optimizer/internal.h"
35
#include "optimizer/keys.h"
36
#include "optimizer/pathnode.h"
37
#include "optimizer/tlist.h"	/* for get_expr */
38
#include "optimizer/xfunc.h"
39
#include "storage/buf_internals.h"		/* for NBuffers */
40 41
#include "tcop/dest.h"
#include "utils/syscache.h"
42 43 44 45

#define ever ; 1 ;

/* local funcs */
46
static int xfunc_card_unreferenced(Query *queryInfo,
47
						Expr *clause, Relid referenced);
48 49

*/
50 51 52

/*
** xfunc_trypullup --
53
**	  Preliminary pullup of predicates, to allow for maximal pruning.
54 55 56 57
** Given a relation, check each of its paths and see if you can
** pullup clauses from its inner and outer.
*/

58
void
Bruce Momjian's avatar
Bruce Momjian committed
59
xfunc_trypullup(RelOptInfo rel)
60
{
61
	LispValue	y;				/* list ptr */
62
	RestrictInfo	maxcinfo;		/* The RestrictInfo to pull up, as
63
								 * calculated by xfunc_shouldpull() */
64
	NestPath	curpath;		/* current path in list */
65
	int			progress;		/* has progress been made this time
66
								 * through? */
67
	int			clausetype;
68 69 70 71 72 73

	do
	{
		progress = false;		/* no progress yet in this iteration */
		foreach(y, get_pathlist(rel))
		{
74
			curpath = (NestPath) lfirst(y);
75 76 77 78 79 80 81 82

			/*
			 * * for each operand, attempt to pullup predicates until
			 * first * failure.
			 */
			for (ever)
			{
				/* No, the following should NOT be '=='  !! */
83
				if (clausetype = xfunc_shouldpull((Path) get_innerjoinpath(curpath),
84 85 86 87 88 89 90 91 92 93 94 95 96 97
									 curpath, INNER, &maxcinfo))
				{

					xfunc_pullup((Path) get_innerjoinpath(curpath),
								 curpath, maxcinfo, INNER, clausetype);
					progress = true;
				}
				else
					break;
			}
			for (ever)
			{

				/* No, the following should NOT be '=='  !! */
98
				if (clausetype = xfunc_shouldpull((Path) get_outerjoinpath(curpath),
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
									 curpath, OUTER, &maxcinfo))
				{

					xfunc_pullup((Path) get_outerjoinpath(curpath),
								 curpath, maxcinfo, OUTER, clausetype);
					progress = true;
				}
				else
					break;
			}

			/*
			 * * make sure the unpruneable flag bubbles up, i.e. * if
			 * anywhere below us in the path pruneable is false, * then
			 * pruneable should be false here
			 */
			if (get_pruneable(get_parent(curpath)) &&
				(!get_pruneable(get_parent
								((Path) get_innerjoinpath(curpath))) ||
				 !get_pruneable(get_parent((Path)
										   get_outerjoinpath(curpath)))))
			{

				set_pruneable(get_parent(curpath), false);
				progress = true;
			}
		}
	} while (progress);
127 128 129 130 131 132
}

/*
 ** xfunc_shouldpull --
 **    find clause with highest rank, and decide whether to pull it up
 ** from child to parent.  Currently we only pullup secondary join clauses
133
 ** that are in the pathrestrictinfo.  Secondary hash and sort clauses are
134 135 136 137 138
 ** left where they are.
 **    If we find an expensive function but decide *not* to pull it up,
 ** we'd better set the unpruneable flag.  -- JMH, 11/11/92
 **
 ** Returns:  0 if nothing left to pullup
139 140
 **			  XFUNC_LOCPRD if a local predicate is to be pulled up
 **			  XFUNC_JOINPRD if a secondary join predicate is to be pulled up
141
 */
142
int
143
xfunc_shouldpull(Query *queryInfo,
144
				 Path childpath,
145
				 NestPath parentpath,
146
				 int whichchild,
147
				 RestrictInfo * maxcinfopt)		/* Out: pointer to clause
148
												 * to pullup */
149
{
150 151
	LispValue	clauselist,
				tmplist;		/* lists of clauses */
152
	RestrictInfo	maxcinfo;		/* clause to pullup */
153
	LispValue	primjoinclause	/* primary join clause */
154
	= xfunc_primary_join(parentpath);
155 156 157 158 159
	Cost		tmprank,
				maxrank = (-1 * MAXFLOAT);		/* ranks of clauses */
	Cost		joinselec = 0;	/* selectivity of the join predicate */
	Cost		joincost = 0;	/* join cost + primjoinclause cost */
	int			retval = XFUNC_LOCPRD;
160

161
	clauselist = get_loc_restrictinfo(childpath);
162 163 164 165 166

	if (clauselist != LispNil)
	{
		/* find local predicate with maximum rank */
		for (tmplist = clauselist,
167
			 maxcinfo = (RestrictInfo) lfirst(tmplist),
168 169 170 171 172
			 maxrank = xfunc_rank(get_clause(maxcinfo));
			 tmplist != LispNil;
			 tmplist = lnext(tmplist))
		{

173
			if ((tmprank = xfunc_rank(get_clause((RestrictInfo) lfirst(tmplist))))
174 175
				> maxrank)
			{
176
				maxcinfo = (RestrictInfo) lfirst(tmplist);
177 178 179
				maxrank = tmprank;
			}
		}
180
	}
181 182 183 184 185 186

	/*
	 * * If child is a join path, and there are multiple join clauses, *
	 * see if any join clause has even higher rank than the highest *
	 * local predicate
	 */
187 188
	if (is_join(childpath) && xfunc_num_join_clauses((NestPath) childpath) > 1)
		for (tmplist = get_pathrestrictinfo((NestPath) childpath);
189 190 191 192 193
			 tmplist != LispNil;
			 tmplist = lnext(tmplist))
		{

			if (tmplist != LispNil &&
194
				(tmprank = xfunc_rank(get_clause((RestrictInfo) lfirst(tmplist))))
195 196
				> maxrank)
			{
197
				maxcinfo = (RestrictInfo) lfirst(tmplist);
198 199 200 201 202
				maxrank = tmprank;
				retval = XFUNC_JOINPRD;
			}
		}
	if (maxrank == (-1 * MAXFLOAT))		/* no expensive clauses */
203
		return 0;
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226

	/*
	 * * Pullup over join if clause is higher rank than join, or if * join
	 * is nested loop and current path is inner child (note that *
	 * restrictions on the inner of a nested loop don't buy you anything
	 * -- * you still have to scan the entire inner relation each time). *
	 * Note that the cost of a secondary join clause is only what's *
	 * calculated by xfunc_expense(), since the actual joining * (i.e. the
	 * usual path_cost) is paid for by the primary join clause.
	 */
	if (primjoinclause != LispNil)
	{
		joinselec = compute_clause_selec(queryInfo, primjoinclause, LispNil);
		joincost = xfunc_join_expense(parentpath, whichchild);

		if (XfuncMode == XFUNC_PULLALL ||
			(XfuncMode != XFUNC_WAIT &&
			 ((joincost != 0 &&
			   (maxrank = xfunc_rank(get_clause(maxcinfo))) >
			   ((joinselec - 1.0) / joincost))
			  || (joincost == 0 && joinselec < 1)
			  || (!is_join(childpath)
				  && (whichchild == INNER)
227
				  && IsA(parentpath, NestPath)
228 229
				  &&!IsA(parentpath, HashPath)
				  &&!IsA(parentpath, MergePath)))))
230 231 232
		{

			*maxcinfopt = maxcinfo;
233
			return retval;
234 235 236 237 238 239 240 241

		}
		else if (maxrank != -(MAXFLOAT))
		{

			/*
			 * * we've left an expensive restriction below a join.  Since *
			 * we may pullup this restriction in predmig.c, we'd best *
Bruce Momjian's avatar
Bruce Momjian committed
242
			 * set the RelOptInfo of this join to be unpruneable
243 244 245 246
			 */
			set_pruneable(get_parent(parentpath), false);
			/* and fall through */
		}
247
	}
248
	return 0;
249 250 251 252 253
}


/*
 ** xfunc_pullup --
254
 **    move clause from child pathnode to parent pathnode.	 This operation
255
 ** makes the child pathnode produce a larger relation than it used to.
Bruce Momjian's avatar
Bruce Momjian committed
256 257
 ** This means that we must construct a new RelOptInfo just for the childpath,
 ** although this RelOptInfo will not be added to the list of Rels to be joined up
258 259 260
 ** in the query; it's merely a parent for the new childpath.
 **    We also have to fix up the path costs of the child and parent.
 **
261
 ** Now returns a pointer to the new pulled-up RestrictInfo. -- JMH, 11/18/92
262
 */
263
RestrictInfo
264
xfunc_pullup(Query *queryInfo,
265
			 Path childpath,
266
			 NestPath parentpath,
267
			 RestrictInfo cinfo,	/* clause to pull up */
268 269
			 int whichchild,	/* whether child is INNER or OUTER of join */
			 int clausetype)	/* whether clause to pull is join or local */
270
{
271
	Path		newkid;
272
	RelOptInfo	newrel;
273 274
	Cost		pulled_selec;
	Cost		cost;
275
	RestrictInfo	newinfo;
276 277 278 279 280

	/* remove clause from childpath */
	newkid = (Path) copyObject((Node) childpath);
	if (clausetype == XFUNC_LOCPRD)
	{
281
		set_locrestrictinfo(newkid,
282
						  xfunc_LispRemove((LispValue) cinfo,
283
									  (List) get_loc_restrictinfo(newkid)));
284 285 286
	}
	else
	{
287
		set_pathrestrictinfo
288
			((NestPath) newkid,
289
			 xfunc_LispRemove((LispValue) cinfo,
290
						  (List) get_pathrestrictinfo((NestPath) newkid)));
291 292 293
	}

	/*
294 295
	 * * give the new child path its own RelOptInfo node that reflects the *
	 * lack of the pulled-up predicate
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
	 */
	pulled_selec = compute_clause_selec(queryInfo,
										get_clause(cinfo), LispNil);
	xfunc_copyrel(get_parent(newkid), &newrel);
	set_parent(newkid, newrel);
	set_pathlist(newrel, lcons(newkid, NIL));
	set_unorderedpath(newrel, (PathPtr) newkid);
	set_cheapestpath(newrel, (PathPtr) newkid);
	set_size(newrel,
		(Count) ((Cost) get_size(get_parent(childpath)) / pulled_selec));

	/*
	 * * fix up path cost of newkid.  To do this we subtract away all the *
	 * xfunc_costs of childpath, then recompute the xfunc_costs of newkid
	 */
	cost = get_path_cost(newkid) - xfunc_get_path_cost(childpath);
	Assert(cost >= 0);
	set_path_cost(newkid, cost);
	cost = get_path_cost(newkid) + xfunc_get_path_cost(newkid);
	set_path_cost(newkid, cost);

	/*
	 * * We copy the cinfo, since it may appear in other plans, and we're
	 * going * to munge it.  -- JMH, 7/22/92
	 */
321
	newinfo = (RestrictInfo) copyObject((Node) cinfo);
322 323 324 325 326 327 328 329

	/*
	 * * Fix all vars in the clause * to point to the right varno and
	 * varattno in parentpath
	 */
	xfunc_fixvars(get_clause(newinfo), newrel, whichchild);

	/* add clause to parentpath, and fix up its cost. */
330
	set_locrestrictinfo(parentpath,
331
					  lispCons((LispValue) newinfo,
332
							 (LispValue) get_loc_restrictinfo(parentpath)));
333 334 335 336 337 338 339 340 341 342 343 344 345
	/* put new childpath into the path tree */
	if (whichchild == INNER)
		set_innerjoinpath(parentpath, (pathPtr) newkid);
	else
		set_outerjoinpath(parentpath, (pathPtr) newkid);

	/*
	 * * recompute parentpath cost from scratch -- the cost * of the join
	 * method has changed
	 */
	cost = xfunc_total_path_cost(parentpath);
	set_path_cost(parentpath, cost);

346
	return newinfo;
347 348 349
}

/*
350
 ** calculate (selectivity-1)/cost.
351
 */
352
Cost
353
xfunc_rank(Query *queryInfo, LispValue clause)
354
{
355 356
	Cost		selec = compute_clause_selec(queryInfo, clause, LispNil);
	Cost		cost = xfunc_expense(queryInfo, clause);
357 358 359

	if (cost == 0)
		if (selec > 1)
360
			return MAXFLOAT;
361
		else
362 363
			return -(MAXFLOAT);
	return (selec - 1) / cost;
364 365 366 367 368 369 370
}

/*
 ** Find the "global" expense of a clause; i.e. the local expense divided
 ** by the cardinalities of all the base relations of the query that are *not*
 ** referenced in the clause.
 */
371
Cost
372
xfunc_expense(Query *queryInfo, clause)
373
LispValue	clause;
374
{
375
	Cost		cost = xfunc_local_expense(clause);
376 377

	if (cost)
378
	{
379
		Count		card = xfunc_card_unreferenced(queryInfo, clause, LispNil);
380 381 382

		if (card)
			cost /= card;
383
	}
384

385
	return cost;
386 387 388 389 390 391
}

/*
 ** xfunc_join_expense --
 **    Find global expense of a join clause
 */
392
Cost
393
xfunc_join_expense(Query *queryInfo, NestPath path, int whichchild)
394
{
395
	LispValue	primjoinclause = xfunc_primary_join(path);
396 397 398 399

	/*
	 * * the second argument to xfunc_card_unreferenced reflects all the *
	 * relations involved in the join clause, i.e. all the relids in the
Bruce Momjian's avatar
Bruce Momjian committed
400
	 * RelOptInfo * of the join clause
401
	 */
402 403
	Count		card = 0;
	Cost		cost = xfunc_expense_per_tuple(path, whichchild);
404 405 406 407 408 409 410 411 412 413

	card = xfunc_card_unreferenced(queryInfo,
								   primjoinclause,
								   get_relids(get_parent(path)));
	if (primjoinclause)
		cost += xfunc_local_expense(primjoinclause);

	if (card)
		cost /= card;

414
	return cost;
415 416 417 418 419 420
}

/*
 ** Recursively find the per-tuple expense of a clause.  See
 ** xfunc_func_expense for more discussion.
 */
421 422
Cost
xfunc_local_expense(LispValue clause)
423
{
424 425
	Cost		cost = 0;		/* running expense */
	LispValue	tmpclause;
426 427

	/* First handle the base case */
428
	if (IsA(clause, Const) ||IsA(clause, Var) ||IsA(clause, Param))
429
		return 0;
430 431 432
	/* now other stuff */
	else if (IsA(clause, Iter))
		/* Too low. Should multiply by the expected number of iterations. */
433
		return xfunc_local_expense(get_iterexpr((Iter) clause));
434
	else if (IsA(clause, ArrayRef))
435
		return xfunc_local_expense(get_refexpr((ArrayRef) clause));
436 437 438 439 440 441 442
	else if (fast_is_clause(clause))
		return (xfunc_func_expense((LispValue) get_op(clause),
								   (LispValue) get_opargs(clause)));
	else if (fast_is_funcclause(clause))
		return (xfunc_func_expense((LispValue) get_function(clause),
								   (LispValue) get_funcargs(clause)));
	else if (fast_not_clause(clause))
443
		return xfunc_local_expense(lsecond(clause));
444
	else if (fast_or_clause(clause) || fast_and_clause(clause))
445 446 447 448 449
	{
		/* find cost of evaluating each disjunct */
		for (tmpclause = lnext(clause); tmpclause != LispNil;
			 tmpclause = lnext(tmpclause))
			cost += xfunc_local_expense(lfirst(tmpclause));
450
		return cost;
451 452 453
	}
	else
	{
454
		elog(ERROR, "Clause node of undetermined type");
455
		return -1;
456
	}
457 458 459 460 461 462
}

/*
 ** xfunc_func_expense --
 **    given a Func or Oper and its args, find its expense.
 ** Note: in Stonebraker's SIGMOD '91 paper, he uses a more complicated metric
463
 ** than the one here.	We can ignore the expected number of tuples for
464 465 466 467 468 469 470 471 472
 ** our calculations; we just need the per-tuple expense.  But he also
 ** proposes components to take into account the costs of accessing disk and
 ** archive.  We didn't adopt that scheme here; eventually the vacuum
 ** cleaner should be able to tell us what percentage of bytes to find on
 ** which storage level, and that should be multiplied in appropriately
 ** in the cost function below.  Right now we don't model the cost of
 ** accessing secondary or tertiary storage, since we don't have sufficient
 ** stats to do it right.
 */
473 474
Cost
xfunc_func_expense(LispValue node, LispValue args)
475
{
476 477
	HeapTuple	tupl;			/* the pg_proc tuple for each function */
	Form_pg_proc proc;			/* a data structure to hold the pg_proc
478
								 * tuple */
479
	int			width = 0;		/* byte width of the field referenced by
480
								 * each clause */
481 482 483 484
	RegProcedure funcid;		/* ID of function associate with node */
	Cost		cost = 0;		/* running expense */
	LispValue	tmpclause;
	LispValue	operand;		/* one operand of an operator */
485 486 487 488 489

	if (IsA(node, Oper))
	{
		/* don't trust the opid in the Oper node.  Use the opno. */
		if (!(funcid = get_opcode(get_opno((Oper) node))))
490
			elog(ERROR, "Oper's function is undefined");
491
	}
492 493 494 495
	else
		funcid = get_funcid((Func) node);

	/* look up tuple in cache */
496
	tupl = SearchSysCacheTuple(PROOID,
497 498
							   ObjectIdGetDatum(funcid),
							   0, 0, 0);
499
	if (!HeapTupleIsValid(tupl))
500
		elog(ERROR, "Cache lookup failed for procedure %d", funcid);
501 502
	proc = (Form_pg_proc) GETSTRUCT(tupl);

503
	/*
504 505
	 * * if it's a Postquel function, its cost is stored in the *
	 * associated plan.
506
	 */
507 508
	if (proc->prolang == SQLlanguageId)
	{
509 510
		LispValue	tmpplan;
		List		planlist;
511

512
		if (IsA(node, Oper) ||get_func_planlist((Func) node) == LispNil)
513
		{
514 515 516 517
			Oid		   *argOidVect;		/* vector of argtypes */
			char	   *pq_src; /* text of PQ function */
			int			nargs;	/* num args to PQ function */
			QueryTreeList *queryTree_list;		/* dummy variable */
518 519 520 521 522 523 524 525 526

			/*
			 * * plan the function, storing it in the Func node for later *
			 * use by the executor.
			 */
			pq_src = (char *) textout(&(proc->prosrc));
			nargs = proc->pronargs;
			if (nargs > 0)
				argOidVect = proc->proargtypes;
527
			planlist = (List) pg_parse_and_plan(pq_src, argOidVect, nargs,
528
										   &parseTree_list, None, FALSE);
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
			if (IsA(node, Func))
				set_func_planlist((Func) node, planlist);

		}
		else
		{						/* plan has been cached inside the Func
								 * node already */
			planlist = get_func_planlist((Func) node);
		}

		/*
		 * * Return the sum of the costs of the plans (the PQ function *
		 * may have many queries in its body).
		 */
		foreach(tmpplan, planlist)
			cost += get_cost((Plan) lfirst(tmpplan));
545
		return cost;
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
	}
	else
	{							/* it's a C function */

		/*
		 * *  find the cost of evaluating the function's arguments *  and
		 * the width of the operands
		 */
		for (tmpclause = args; tmpclause != LispNil;
			 tmpclause = lnext(tmpclause))
		{

			if ((operand = lfirst(tmpclause)) != LispNil)
			{
				cost += xfunc_local_expense(operand);
				width += xfunc_width(operand);
			}
		}

		/*
		 * * when stats become available, add in cost of accessing
		 * secondary * and tertiary storage here.
		 */
		return (cost +
				(Cost) proc->propercall_cpu +
		(Cost) proc->properbyte_cpu * (Cost) proc->probyte_pct / 100.00 *
				(Cost) width

		/*
		 * Pct_of_obj_in_mem DISK_COST * proc->probyte_pct/100.00 * width
		 * Pct_of_obj_on_disk + ARCH_COST * proc->probyte_pct/100.00 *
		 * width Pct_of_obj_on_arch
		 */
			);
580 581 582
	}
}

583
/*
584 585 586 587
 ** xfunc_width --
 **    recursively find the width of a expression
 */

588 589
int
xfunc_width(LispValue clause)
590
{
591 592
	Relation	rd;				/* Relation Descriptor */
	HeapTuple	tupl;			/* structure to hold a cached tuple */
593
	Form_pg_type type;			/* structure to hold a type tuple */
594
	int			retval = 0;
595 596 597 598 599 600

	if (IsA(clause, Const))
	{
		/* base case: width is the width of this constant */
		retval = get_constlen((Const) clause);
		goto exit;
601
	}
602 603 604 605 606
	else if (IsA(clause, ArrayRef))
	{
		/* base case: width is width of the refelem within the array */
		retval = get_refelemlength((ArrayRef) clause);
		goto exit;
607
	}
608 609 610 611
	else if (IsA(clause, Var))
	{
		/* base case: width is width of this attribute */
		tupl = SearchSysCacheTuple(TYPOID,
612
							 ObjectIdGetDatum(get_vartype((Var) clause)),
613 614
								   0, 0, 0);
		if (!HeapTupleIsValid(tupl))
615
			elog(ERROR, "Cache lookup failed for type %d",
616
				 get_vartype((Var) clause));
617
		type = (Form_pg_type) GETSTRUCT(tupl);
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
		if (get_varattno((Var) clause) == 0)
		{
			/* clause is a tuple.  Get its width */
			rd = heap_open(type->typrelid);
			retval = xfunc_tuple_width(rd);
			heap_close(rd);
		}
		else
		{
			/* attribute is a base type */
			retval = type->typlen;
		}
		goto exit;
	}
	else if (IsA(clause, Param))
	{
634
		if (typeidTypeRelid(get_paramtype((Param) clause)))
635 636
		{
			/* Param node returns a tuple.	Find its width */
637
			rd = heap_open(typeidTypeRelid(get_paramtype((Param) clause)));
638 639 640 641 642 643 644
			retval = xfunc_tuple_width(rd);
			heap_close(rd);
		}
		else if (get_param_tlist((Param) clause) != LispNil)
		{
			/* Param node projects a complex type */
			Assert(length(get_param_tlist((Param) clause)) == 1);		/* sanity */
645
			retval = xfunc_width((LispValue)
646 647 648 649 650
					  get_expr(lfirst(get_param_tlist((Param) clause))));
		}
		else
		{
			/* Param node returns a base type */
651
			retval = typeLen(typeidType(get_paramtype((Param) clause)));
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 677
		}
		goto exit;
	}
	else if (IsA(clause, Iter))
	{

		/*
		 * * An Iter returns a setof things, so return the width of a
		 * single * thing. * Note:	THIS MAY NOT WORK RIGHT WHEN AGGS GET
		 * FIXED, * SINCE AGG FUNCTIONS CHEW ON THE WHOLE SETOF THINGS!!!! *
		 * This whole Iter business is bogus, anyway.
		 */
		retval = xfunc_width(get_iterexpr((Iter) clause));
		goto exit;
	}
	else if (fast_is_clause(clause))
	{

		/*
		 * * get function associated with this Oper, and treat this as * a
		 * Func
		 */
		tupl = SearchSysCacheTuple(OPROID,
					   ObjectIdGetDatum(get_opno((Oper) get_op(clause))),
								   0, 0, 0);
		if (!HeapTupleIsValid(tupl))
678
			elog(ERROR, "Cache lookup failed for procedure %d",
679 680
				 get_opno((Oper) get_op(clause)));
		return (xfunc_func_width
681 682
		((RegProcedure) (((Form_pg_operator) (GETSTRUCT(tupl)))->oprcode),
		 (LispValue) get_opargs(clause)));
683 684 685
	}
	else if (fast_is_funcclause(clause))
	{
686
		Func		func = (Func) get_function(clause);
687 688 689 690 691 692 693 694 695

		if (get_func_tlist(func) != LispNil)
		{

			/*
			 * this function has a projection on it.  Get the length of
			 * the projected attribute
			 */
			Assert(length(get_func_tlist(func)) == 1);	/* sanity */
696
			retval = xfunc_width((LispValue)
697 698 699 700 701 702 703 704 705 706 707
							get_expr(lfirst(get_func_tlist(func))));
			goto exit;
		}
		else
		{
			return (xfunc_func_width((RegProcedure) get_funcid(func),
									 (LispValue) get_funcargs(clause)));
		}
	}
	else
	{
708
		elog(ERROR, "Clause node of undetermined type");
709
		return -1;
710
	}
711 712 713 714

exit:
	if (retval == -1)
		retval = VARLEN_DEFAULT;
715
	return retval;
716 717 718 719
}

/*
 ** xfunc_card_unreferenced:
720 721
 **   find all relations not referenced in clause, and multiply their
 ** cardinalities.	Ignore relation of cardinality 0.
722 723 724
 ** User may pass in referenced list, if they know it (useful
 ** for joins).
 */
725
static Count
726
xfunc_card_unreferenced(Query *queryInfo,
727
						LispValue clause, Relid referenced)
728
{
729 730 731
	Relid		unreferenced,
				allrelids = LispNil;
	LispValue	temp;
732 733

	/* find all relids of base relations referenced in query */
734
	foreach(temp, queryInfo->base_rel_list)
735
	{
Bruce Momjian's avatar
Bruce Momjian committed
736
		Assert(lnext(get_relids((RelOptInfo) lfirst(temp))) == LispNil);
737
		allrelids = lappend(allrelids,
738
						  lfirst(get_relids((RelOptInfo) lfirst(temp))));
739
	}
740 741 742 743 744 745

	/* find all relids referenced in query but not in clause */
	if (!referenced)
		referenced = xfunc_find_references(clause);
	unreferenced = set_difference(allrelids, referenced);

746
	return xfunc_card_product(unreferenced);
747 748 749
}

/*
750
 ** xfunc_card_product
751 752
 **   multiple together cardinalities of a list relations.
 */
753
Count
754
xfunc_card_product(Query *queryInfo, Relid relids)
755
{
756 757
	LispValue	cinfonode;
	LispValue	temp;
758
	RelOptInfo	currel;
759 760
	Cost		tuples;
	Count		retval = 0;
761 762 763 764 765 766 767 768 769

	foreach(temp, relids)
	{
		currel = get_rel(lfirst(temp));
		tuples = get_tuples(currel);

		if (tuples)
		{						/* not of cardinality 0 */
			/* factor in the selectivity of all zero-cost clauses */
770
			foreach(cinfonode, get_restrictinfo(currel))
771
			{
772
				if (!xfunc_expense(queryInfo, get_clause((RestrictInfo) lfirst(cinfonode))))
773
					tuples *= compute_clause_selec(queryInfo,
774
							  get_clause((RestrictInfo) lfirst(cinfonode)),
775 776 777 778 779 780 781 782
											 LispNil);
			}

			if (retval == 0)
				retval = tuples;
			else
				retval *= tuples;
		}
783
	}
784 785
	if (retval == 0)
		retval = 1;				/* saves caller from dividing by zero */
786
	return retval;
787 788 789 790 791 792 793
}


/*
 ** xfunc_find_references:
 **   Traverse a clause and find all relids referenced in the clause.
 */
794 795
List
xfunc_find_references(LispValue clause)
796
{
797 798
	List		retval = (List) LispNil;
	LispValue	tmpclause;
799 800 801

	/* Base cases */
	if (IsA(clause, Var))
802
		return lispCons(lfirst(get_varid((Var) clause)), LispNil);
803
	else if (IsA(clause, Const) ||IsA(clause, Param))
804
		return (List) LispNil;
805 806 807 808 809 810 811 812

	/* recursion */
	else if (IsA(clause, Iter))

		/*
		 * Too low. Should multiply by the expected number of iterations.
		 * maybe
		 */
813
		return xfunc_find_references(get_iterexpr((Iter) clause));
814
	else if (IsA(clause, ArrayRef))
815
		return xfunc_find_references(get_refexpr((ArrayRef) clause));
816 817 818 819 820 821
	else if (fast_is_clause(clause))
	{
		/* string together result of all operands of Oper */
		for (tmpclause = (LispValue) get_opargs(clause); tmpclause != LispNil;
			 tmpclause = lnext(tmpclause))
			retval = nconc(retval, xfunc_find_references(lfirst(tmpclause)));
822
		return retval;
823 824 825 826 827 828 829 830
	}
	else if (fast_is_funcclause(clause))
	{
		/* string together result of all args of Func */
		for (tmpclause = (LispValue) get_funcargs(clause);
			 tmpclause != LispNil;
			 tmpclause = lnext(tmpclause))
			retval = nconc(retval, xfunc_find_references(lfirst(tmpclause)));
831
		return retval;
832 833
	}
	else if (fast_not_clause(clause))
834
		return xfunc_find_references(lsecond(clause));
835
	else if (fast_or_clause(clause) || fast_and_clause(clause))
836 837 838 839 840
	{
		/* string together result of all operands of OR */
		for (tmpclause = lnext(clause); tmpclause != LispNil;
			 tmpclause = lnext(tmpclause))
			retval = nconc(retval, xfunc_find_references(lfirst(tmpclause)));
841
		return retval;
842 843 844
	}
	else
	{
845
		elog(ERROR, "Clause node of undetermined type");
846
		return (List) LispNil;
847
	}
848 849 850 851 852 853 854 855
}

/*
 ** xfunc_primary_join:
 **   Find the primary join clause: for Hash and Merge Joins, this is the
 ** min rank Hash or Merge clause, while for Nested Loop it's the
 ** min rank pathclause
 */
856
LispValue
857
xfunc_primary_join(NestPath pathnode)
858
{
859 860
	LispValue	joinclauselist = get_pathrestrictinfo(pathnode);
	RestrictInfo	mincinfo;
861 862 863 864
	LispValue	tmplist;
	LispValue	minclause = LispNil;
	Cost		minrank,
				tmprank;
865 866

	if (IsA(pathnode, MergePath))
867
	{
868 869 870 871 872 873 874 875 876 877 878
		for (tmplist = get_path_mergeclauses((MergePath) pathnode),
			 minclause = lfirst(tmplist),
			 minrank = xfunc_rank(minclause);
			 tmplist != LispNil;
			 tmplist = lnext(tmplist))
			if ((tmprank = xfunc_rank(lfirst(tmplist)))
				< minrank)
			{
				minrank = tmprank;
				minclause = lfirst(tmplist);
			}
879
		return minclause;
880
	}
881
	else if (IsA(pathnode, HashPath))
882
	{
883 884 885 886 887 888 889 890 891 892 893
		for (tmplist = get_path_hashclauses((HashPath) pathnode),
			 minclause = lfirst(tmplist),
			 minrank = xfunc_rank(minclause);
			 tmplist != LispNil;
			 tmplist = lnext(tmplist))
			if ((tmprank = xfunc_rank(lfirst(tmplist)))
				< minrank)
			{
				minrank = tmprank;
				minclause = lfirst(tmplist);
			}
894
		return minclause;
895
	}
896 897 898

	/* if we drop through, it's nested loop join */
	if (joinclauselist == LispNil)
899
		return LispNil;
900

901 902
	for (tmplist = joinclauselist, mincinfo = (RestrictInfo) lfirst(joinclauselist),
		 minrank = xfunc_rank(get_clause((RestrictInfo) lfirst(tmplist)));
903 904
		 tmplist != LispNil;
		 tmplist = lnext(tmplist))
905
		if ((tmprank = xfunc_rank(get_clause((RestrictInfo) lfirst(tmplist))))
906 907 908
			< minrank)
		{
			minrank = tmprank;
909
			mincinfo = (RestrictInfo) lfirst(tmplist);
910
		}
911
	return (LispValue) get_clause(mincinfo);
912 913 914 915 916 917
}

/*
 ** xfunc_get_path_cost
 **   get the expensive function costs of the path
 */
918
Cost
919
xfunc_get_path_cost(Query *queryInfo, Path pathnode)
920
{
921 922 923
	Cost		cost = 0;
	LispValue	tmplist;
	Cost		selec = 1.0;
924 925 926 927 928 929 930 931 932

	/*
	 * * first add in the expensive local function costs. * We ensure that
	 * the clauses are sorted by rank, so that we * know (via
	 * selectivities) the number of tuples that will be checked * by each
	 * function.  If we're not doing any optimization of expensive *
	 * functions, we don't sort.
	 */
	if (XfuncMode != XFUNC_OFF)
933
		set_locrestrictinfo(pathnode, lisp_qsort(get_loc_restrictinfo(pathnode),
934
											   xfunc_cinfo_compare));
935
	for (tmplist = get_loc_restrictinfo(pathnode), selec = 1.0;
936 937
		 tmplist != LispNil;
		 tmplist = lnext(tmplist))
938
	{
939
		cost += (Cost) (xfunc_local_expense(get_clause((RestrictInfo) lfirst(tmplist)))
940 941
					  * (Cost) get_tuples(get_parent(pathnode)) * selec);
		selec *= compute_clause_selec(queryInfo,
942
								get_clause((RestrictInfo) lfirst(tmplist)),
943
									  LispNil);
944
	}
945 946 947 948 949

	/*
	 * * Now add in any node-specific expensive function costs. * Again,
	 * we must ensure that the clauses are sorted by rank.
	 */
950
	if (IsA(pathnode, NestPath))
951
	{
952
		if (XfuncMode != XFUNC_OFF)
953 954
			set_pathrestrictinfo((NestPath) pathnode, lisp_qsort
							   (get_pathrestrictinfo((NestPath) pathnode),
955
								xfunc_cinfo_compare));
956
		for (tmplist = get_pathrestrictinfo((NestPath) pathnode), selec = 1.0;
957 958
			 tmplist != LispNil;
			 tmplist = lnext(tmplist))
959
		{
960
			cost += (Cost) (xfunc_local_expense(get_clause((RestrictInfo) lfirst(tmplist)))
961 962
					  * (Cost) get_tuples(get_parent(pathnode)) * selec);
			selec *= compute_clause_selec(queryInfo,
963
								get_clause((RestrictInfo) lfirst(tmplist)),
964
										  LispNil);
965 966
		}
	}
967
	if (IsA(pathnode, HashPath))
968
	{
969 970 971 972 973 974 975 976
		if (XfuncMode != XFUNC_OFF)
			set_path_hashclauses
				((HashPath) pathnode,
				 lisp_qsort(get_path_hashclauses((HashPath) pathnode),
							xfunc_clause_compare));
		for (tmplist = get_path_hashclauses((HashPath) pathnode), selec = 1.0;
			 tmplist != LispNil;
			 tmplist = lnext(tmplist))
977
		{
978 979 980 981
			cost += (Cost) (xfunc_local_expense(lfirst(tmplist))
					  * (Cost) get_tuples(get_parent(pathnode)) * selec);
			selec *= compute_clause_selec(queryInfo,
										  lfirst(tmplist), LispNil);
982 983
		}
	}
984
	if (IsA(pathnode, MergePath))
985
	{
986 987 988 989 990 991 992 993
		if (XfuncMode != XFUNC_OFF)
			set_path_mergeclauses
				((MergePath) pathnode,
				 lisp_qsort(get_path_mergeclauses((MergePath) pathnode),
							xfunc_clause_compare));
		for (tmplist = get_path_mergeclauses((MergePath) pathnode), selec = 1.0;
			 tmplist != LispNil;
			 tmplist = lnext(tmplist))
994
		{
995 996 997 998
			cost += (Cost) (xfunc_local_expense(lfirst(tmplist))
					  * (Cost) get_tuples(get_parent(pathnode)) * selec);
			selec *= compute_clause_selec(queryInfo,
										  lfirst(tmplist), LispNil);
999 1000
		}
	}
1001
	Assert(cost >= 0);
1002
	return cost;
1003 1004 1005
}

/*
1006
 ** Recalculate the cost of a path node.  This includes the basic cost of the
1007 1008
 ** node, as well as the cost of its expensive functions.
 ** We need to do this to the parent after pulling a clause from a child into a
1009
 ** parent.  Thus we should only be calling this function on NestPaths.
1010
 */
1011
Cost
1012
xfunc_total_path_cost(NestPath pathnode)
1013
{
1014
	Cost		cost = xfunc_get_path_cost((Path) pathnode);
1015

1016
	Assert(IsA(pathnode, NestPath));
1017
	if (IsA(pathnode, MergePath))
1018
	{
1019
		MergePath	mrgnode = (MergePath) pathnode;
1020

1021
		cost += cost_mergejoin(get_path_cost((Path) get_outerjoinpath(mrgnode)),
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
						get_path_cost((Path) get_innerjoinpath(mrgnode)),
							   get_outersortkeys(mrgnode),
							   get_innersortkeys(mrgnode),
						   get_tuples(get_parent((Path) get_outerjoinpath
												 (mrgnode))),
						   get_tuples(get_parent((Path) get_innerjoinpath
												 (mrgnode))),
							get_width(get_parent((Path) get_outerjoinpath
												 (mrgnode))),
							get_width(get_parent((Path) get_innerjoinpath
												 (mrgnode))));
		Assert(cost >= 0);
1034
		return cost;
1035
	}
1036
	else if (IsA(pathnode, HashPath))
1037
	{
1038
		HashPath hashnode = (HashPath) pathnode;
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052

		cost += cost_hashjoin(get_path_cost((Path) get_outerjoinpath(hashnode)),
					   get_path_cost((Path) get_innerjoinpath(hashnode)),
							  get_outerhashkeys(hashnode),
							  get_innerhashkeys(hashnode),
						   get_tuples(get_parent((Path) get_outerjoinpath
												 (hashnode))),
						   get_tuples(get_parent((Path) get_innerjoinpath
												 (hashnode))),
							get_width(get_parent((Path) get_outerjoinpath
												 (hashnode))),
							get_width(get_parent((Path) get_innerjoinpath
												 (hashnode))));
		Assert(cost >= 0);
1053
		return cost;
1054
	}
1055 1056
	else
/* Nested Loop Join */
1057
	{
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
		cost += cost_nestloop(get_path_cost((Path) get_outerjoinpath(pathnode)),
					   get_path_cost((Path) get_innerjoinpath(pathnode)),
						   get_tuples(get_parent((Path) get_outerjoinpath
												 (pathnode))),
						   get_tuples(get_parent((Path) get_innerjoinpath
												 (pathnode))),
							get_pages(get_parent((Path) get_outerjoinpath
												 (pathnode))),
							IsA(get_innerjoinpath(pathnode), IndexPath));
		Assert(cost >= 0);
1068
		return cost;
1069 1070 1071 1072 1073 1074 1075 1076
	}
}


/*
 ** xfunc_expense_per_tuple --
 **    return the expense of the join *per-tuple* of the input relation.
 ** The cost model here is that a join costs
1077
 **		k*card(outer)*card(inner) + l*card(outer) + m*card(inner) + n
1078 1079 1080 1081 1082 1083 1084
 **
 ** We treat the l and m terms by considering them to be like restrictions
 ** constrained to be right under the join.  Thus the cost per inner and
 ** cost per outer of the join is different, reflecting these virtual nodes.
 **
 ** The cost per tuple of outer is k + l/referenced(inner).  Cost per tuple
 ** of inner is k + m/referenced(outer).
1085
 ** The constants k, l, m and n depend on the join method.	Measures here are
1086 1087 1088
 ** based on the costs in costsize.c, with fudging for HashJoin and Sorts to
 ** make it fit our model (the 'q' in HashJoin results in a
 ** card(outer)/card(inner) term, and sorting results in a log term.
1089

1090
 */
1091
Cost
1092
xfunc_expense_per_tuple(NestPath joinnode, int whichchild)
1093
{
1094 1095
	RelOptInfo	outerrel = get_parent((Path) get_outerjoinpath(joinnode));
	RelOptInfo	innerrel = get_parent((Path) get_innerjoinpath(joinnode));
1096 1097
	Count		outerwidth = get_width(outerrel);
	Count		outers_per_page = ceil(BLCKSZ / (outerwidth + sizeof(HeapTupleData)));
1098 1099

	if (IsA(joinnode, HashPath))
1100
	{
1101
		if (whichchild == INNER)
1102
			return (1 + _CPU_PAGE_WEIGHT_) * outers_per_page / NBuffers;
1103 1104 1105 1106
		else
			return (((1 + _CPU_PAGE_WEIGHT_) * outers_per_page / NBuffers)
					+ _CPU_PAGE_WEIGHT_
					/ xfunc_card_product(get_relids(innerrel)));
1107
	}
1108
	else if (IsA(joinnode, MergePath))
1109
	{
1110 1111 1112 1113 1114 1115 1116
		/* assumes sort exists, and costs one (I/O + CPU) per tuple */
		if (whichchild == INNER)
			return ((2 * _CPU_PAGE_WEIGHT_ + 1)
					/ xfunc_card_product(get_relids(outerrel)));
		else
			return ((2 * _CPU_PAGE_WEIGHT_ + 1)
					/ xfunc_card_product(get_relids(innerrel)));
1117
	}
1118 1119
	else
/* nestloop */
1120
	{
1121
		Assert(IsA(joinnode, NestPath));
1122
		return _CPU_PAGE_WEIGHT_;
1123 1124 1125 1126 1127
	}
}

/*
 ** xfunc_fixvars --
1128
 ** After pulling up a clause, we must walk its expression tree, fixing Var
1129
 ** nodes to point to the correct varno (either INNER or OUTER, depending
1130
 ** on which child the clause was pulled from), and the right varattno in the
1131
 ** target list of the child's former relation.  If the target list of the
Bruce Momjian's avatar
Bruce Momjian committed
1132
 ** child RelOptInfo does not contain the attribute we need, we add it.
1133
 */
1134 1135
void
xfunc_fixvars(LispValue clause, /* clause being pulled up */
1136
			  RelOptInfo rel,	/* rel it's being pulled from */
1137
			  int varno)		/* whether rel is INNER or OUTER of join */
1138
{
1139 1140
	LispValue	tmpclause;		/* temporary variable */
	TargetEntry *tle;			/* tlist member corresponding to var */
1141 1142


1143
	if (IsA(clause, Const) ||IsA(clause, Param))
1144 1145
		return;
	else if (IsA(clause, Var))
1146
	{
1147 1148 1149
		/* here's the meat */
		tle = tlistentry_member((Var) clause, get_targetlist(rel));
		if (tle == LispNil)
1150
		{
1151 1152 1153 1154 1155 1156 1157 1158

			/*
			 * * The attribute we need is not in the target list, * so we
			 * have to add it. *
			 *
			 */
			add_tl_element(rel, (Var) clause);
			tle = tlistentry_member((Var) clause, get_targetlist(rel));
1159
		}
1160 1161
		set_varno(((Var) clause), varno);
		set_varattno(((Var) clause), get_resno(get_resdom(get_entry(tle))));
1162
	}
1163 1164 1165
	else if (IsA(clause, Iter))
		xfunc_fixvars(get_iterexpr((Iter) clause), rel, varno);
	else if (fast_is_clause(clause))
1166
	{
1167 1168
		xfunc_fixvars(lfirst(lnext(clause)), rel, varno);
		xfunc_fixvars(lfirst(lnext(lnext(clause))), rel, varno);
1169
	}
1170 1171 1172 1173 1174 1175
	else if (fast_is_funcclause(clause))
		for (tmpclause = lnext(clause); tmpclause != LispNil;
			 tmpclause = lnext(tmpclause))
			xfunc_fixvars(lfirst(tmpclause), rel, varno);
	else if (fast_not_clause(clause))
		xfunc_fixvars(lsecond(clause), rel, varno);
1176
	else if (fast_or_clause(clause) || fast_and_clause(clause))
1177 1178 1179 1180
		for (tmpclause = lnext(clause); tmpclause != LispNil;
			 tmpclause = lnext(tmpclause))
			xfunc_fixvars(lfirst(tmpclause), rel, varno);
	else
1181
		elog(ERROR, "Clause node of undetermined type");
1182 1183 1184 1185
}


/*
1186 1187
 ** Comparison function for lisp_qsort() on a list of RestrictInfo's.
 ** arg1 and arg2 should really be of type (RestrictInfo *).
1188
 */
1189 1190
int
xfunc_cinfo_compare(void *arg1, void *arg2)
1191
{
1192 1193
	RestrictInfo	info1 = *(RestrictInfo *) arg1;
	RestrictInfo	info2 = *(RestrictInfo *) arg2;
1194

1195 1196
	LispValue	clause1 = (LispValue) get_clause(info1),
				clause2 = (LispValue) get_clause(info2);
1197

1198
	return xfunc_clause_compare((void *) &clause1, (void *) &clause2);
1199 1200 1201
}

/*
1202
 ** xfunc_clause_compare: comparison function for lisp_qsort() that compares two
1203 1204 1205
 ** clauses based on expense/(1 - selectivity)
 ** arg1 and arg2 are really pointers to clauses.
 */
1206 1207
int
xfunc_clause_compare(void *arg1, void *arg2)
1208
{
1209 1210 1211 1212
	LispValue	clause1 = *(LispValue *) arg1;
	LispValue	clause2 = *(LispValue *) arg2;
	Cost		rank1,			/* total xfunc rank of clause1 */
				rank2;			/* total xfunc rank of clause2 */
1213 1214 1215 1216 1217

	rank1 = xfunc_rank(clause1);
	rank2 = xfunc_rank(clause2);

	if (rank1 < rank2)
1218
		return -1;
1219
	else if (rank1 == rank2)
1220
		return 0;
1221
	else
1222
		return 1;
1223 1224 1225 1226 1227 1228 1229 1230
}

/*
 ** xfunc_disjunct_sort --
 **   given a list of clauses, for each clause sort the disjuncts by cost
 **   (this assumes the predicates have been converted to Conjunctive NF)
 **   Modifies the clause list!
 */
1231 1232
void
xfunc_disjunct_sort(LispValue clause_list)
1233
{
1234
	LispValue	temp;
1235 1236 1237

	foreach(temp, clause_list)
		if (or_clause(lfirst(temp)))
1238
		lnext(lfirst(temp)) = lisp_qsort(lnext(lfirst(temp)), xfunc_disjunct_compare);
1239 1240 1241 1242
}


/*
1243
 ** xfunc_disjunct_compare: comparison function for qsort() that compares two
1244 1245 1246
 ** disjuncts based on cost/selec.
 ** arg1 and arg2 are really pointers to disjuncts
 */
1247
int
1248
xfunc_disjunct_compare(Query *queryInfo, void *arg1, void *arg2)
1249
{
1250 1251 1252 1253 1254 1255 1256 1257
	LispValue	disjunct1 = *(LispValue *) arg1;
	LispValue	disjunct2 = *(LispValue *) arg2;
	Cost		cost1,			/* total cost of disjunct1 */
				cost2,			/* total cost of disjunct2 */
				selec1,
				selec2;
	Cost		rank1,
				rank2;
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280

	cost1 = xfunc_expense(queryInfo, disjunct1);
	cost2 = xfunc_expense(queryInfo, disjunct2);
	selec1 = compute_clause_selec(queryInfo,
								  disjunct1, LispNil);
	selec2 = compute_clause_selec(queryInfo,
								  disjunct2, LispNil);

	if (selec1 == 0)
		rank1 = MAXFLOAT;
	else if (cost1 == 0)
		rank1 = 0;
	else
		rank1 = cost1 / selec1;

	if (selec2 == 0)
		rank2 = MAXFLOAT;
	else if (cost2 == 0)
		rank2 = 0;
	else
		rank2 = cost2 / selec2;

	if (rank1 < rank2)
1281
		return -1;
1282
	else if (rank1 == rank2)
1283
		return 0;
1284
	else
1285
		return 1;
1286 1287 1288 1289 1290 1291 1292
}

/* ------------------------ UTILITY FUNCTIONS ------------------------------- */
/*
 ** xfunc_func_width --
 **    Given a function OID and operands, find the width of the return value.
 */
1293 1294
int
xfunc_func_width(RegProcedure funcid, LispValue args)
1295
{
1296 1297 1298
	Relation	rd;				/* Relation Descriptor */
	HeapTuple	tupl;			/* structure to hold a cached tuple */
	Form_pg_proc proc;			/* structure to hold the pg_proc tuple */
1299
	Form_pg_type type;			/* structure to hold the pg_type tuple */
1300 1301
	LispValue	tmpclause;
	int			retval;
1302 1303 1304

	/* lookup function and find its return type */
	Assert(RegProcedureIsValid(funcid));
1305
	tupl = SearchSysCacheTuple(PROOID,
1306 1307
							   ObjectIdGetDatum(funcid),
							   0, 0, 0);
1308
	if (!HeapTupleIsValid(tupl))
1309
		elog(ERROR, "Cache lookup failed for procedure %d", funcid);
1310 1311 1312
	proc = (Form_pg_proc) GETSTRUCT(tupl);

	/* if function returns a tuple, get the width of that */
1313
	if (typeidTypeRelid(proc->prorettype))
1314
	{
1315
		rd = heap_open(typeidTypeRelid(proc->prorettype));
1316 1317 1318
		retval = xfunc_tuple_width(rd);
		heap_close(rd);
		goto exit;
1319
	}
1320 1321
	else
/* function returns a base type */
1322
	{
1323 1324 1325 1326
		tupl = SearchSysCacheTuple(TYPOID,
								   ObjectIdGetDatum(proc->prorettype),
								   0, 0, 0);
		if (!HeapTupleIsValid(tupl))
1327
			elog(ERROR, "Cache lookup failed for type %d", proc->prorettype);
1328
		type = (Form_pg_type) GETSTRUCT(tupl);
1329 1330
		/* if the type length is known, return that */
		if (type->typlen != -1)
1331
		{
1332 1333
			retval = type->typlen;
			goto exit;
1334
		}
1335 1336
		else
/* estimate the return size */
1337
		{
1338 1339 1340 1341 1342 1343 1344
			/* find width of the function's arguments */
			for (tmpclause = args; tmpclause != LispNil;
				 tmpclause = lnext(tmpclause))
				retval += xfunc_width(lfirst(tmpclause));
			/* multiply by outin_ratio */
			retval = (int) (proc->prooutin_ratio / 100.0 * retval);
			goto exit;
1345 1346
		}
	}
1347
exit:
1348
	return retval;
1349 1350 1351 1352
}

/*
 ** xfunc_tuple_width --
1353
 **		Return the sum of the lengths of all the attributes of a given relation
1354
 */
1355 1356
int
xfunc_tuple_width(Relation rd)
1357
{
1358 1359
	int			i;
	int			retval = 0;
1360
	TupleDesc	tdesc = RelationGetDescr(rd);
1361 1362

	for (i = 0; i < tdesc->natts; i++)
1363
	{
1364 1365 1366 1367
		if (tdesc->attrs[i]->attlen != -1)
			retval += tdesc->attrs[i]->attlen;
		else
			retval += VARLEN_DEFAULT;
1368
	}
1369

1370
	return retval;
1371 1372 1373 1374 1375 1376
}

/*
 ** xfunc_num_join_clauses --
 **   Find the number of join clauses associated with this join path
 */
1377
int
1378
xfunc_num_join_clauses(NestPath path)
1379
{
1380
	int			num = length(get_pathrestrictinfo(path));
1381 1382

	if (IsA(path, MergePath))
1383
		return num + length(get_path_mergeclauses((MergePath) path));
1384
	else if (IsA(path, HashPath))
1385
		return num + length(get_path_hashclauses((HashPath) path));
1386
	else
1387
		return num;
1388 1389 1390 1391 1392 1393
}

/*
 ** xfunc_LispRemove --
 **   Just like LispRemove, but it whines if the item to be removed ain't there
 */
1394 1395
LispValue
xfunc_LispRemove(LispValue foo, List bar)
1396
{
1397 1398 1399
	LispValue	temp = LispNil;
	LispValue	result = LispNil;
	int			sanity = false;
1400 1401 1402 1403 1404 1405 1406 1407

	for (temp = bar; !null(temp); temp = lnext(temp))
		if (!equal((Node) (foo), (Node) (lfirst(temp))))
			result = lappend(result, lfirst(temp));
		else
			sanity = true;		/* found a matching item to remove! */

	if (!sanity)
1408
		elog(ERROR, "xfunc_LispRemove: didn't find a match!");
1409

1410
	return result;
1411 1412 1413
}

#define Node_Copy(a, b, c, d) \
1414 1415 1416 1417 1418 1419
do { \
	if (NodeCopy((Node)((a)->d), (Node*)&((b)->d), c) != true) \
	{ \
		return false; \
	} \
} while(0)
1420 1421 1422 1423 1424

/*
 ** xfunc_copyrel --
 **   Just like _copyRel, but doesn't copy the paths
 */
1425
bool
Bruce Momjian's avatar
Bruce Momjian committed
1426
xfunc_copyrel(RelOptInfo from, RelOptInfo *to)
1427
{
1428
	RelOptInfo	newnode;
1429

1430
	Pointer		(*alloc) () = palloc;
1431 1432 1433 1434 1435 1436 1437

	/* COPY_CHECKARGS() */
	if (to == NULL)
		return false;

	/* COPY_CHECKNULL() */
	if (from == NULL)
1438
	{
1439 1440 1441 1442 1443
		(*to) = NULL;
		return true;
	}

	/* COPY_NEW(c) */
Bruce Momjian's avatar
Bruce Momjian committed
1444
	newnode = (RelOptInfo) (*alloc) (classSize(RelOptInfo));
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
	if (newnode == NULL)
		return false;

	/* ----------------
	 *	copy node superclass fields
	 * ----------------
	 */
	CopyNodeFields((Node) from, (Node) newnode, alloc);

	/* ----------------
	 *	copy remainder of node
	 * ----------------
	 */
	Node_Copy(from, newnode, alloc, relids);

	newnode->indexed = from->indexed;
	newnode->pages = from->pages;
	newnode->tuples = from->tuples;
	newnode->size = from->size;
	newnode->width = from->width;

	Node_Copy(from, newnode, alloc, targetlist);

	/*
	 * No!!!!	 Node_Copy(from, newnode, alloc, pathlist);
	 * Node_Copy(from, newnode, alloc, unorderedpath); Node_Copy(from,
	 * newnode, alloc, cheapestpath);
	 */
#if 0							/* can't use Node_copy now. 2/95 -ay */
	Node_Copy(from, newnode, alloc, classlist);
	Node_Copy(from, newnode, alloc, indexkeys);
	Node_Copy(from, newnode, alloc, ordering);
1477
#endif
1478
	Node_Copy(from, newnode, alloc, restrictinfo);
1479 1480 1481 1482 1483 1484
	Node_Copy(from, newnode, alloc, joininfo);
	Node_Copy(from, newnode, alloc, innerjoin);
	Node_Copy(from, newnode, alloc, superrels);

	(*to) = newnode;
	return true;
1485
}