indxpath.c 38.3 KB
Newer Older
1 2 3
/*-------------------------------------------------------------------------
 *
 * indxpath.c--
4 5
 *	  Routines to determine which indices are usable for scanning a
 *	  given relation
6 7 8 9 10
 *
 * Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
Bruce Momjian's avatar
Bruce Momjian committed
11
 *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.39 1999/02/08 04:29:08 momjian Exp $
12 13 14 15
 *
 *-------------------------------------------------------------------------
 */
#include <math.h>
Bruce Momjian's avatar
Bruce Momjian committed
16

17
#include "postgres.h"
Bruce Momjian's avatar
Bruce Momjian committed
18

19 20 21
#include "access/attnum.h"
#include "access/heapam.h"
#include "access/nbtree.h"
Bruce Momjian's avatar
Bruce Momjian committed
22 23
#include "catalog/catname.h"
#include "catalog/pg_amop.h"
24
#include "catalog/pg_type.h"
Bruce Momjian's avatar
Bruce Momjian committed
25 26
#include "executor/executor.h"
#include "fmgr.h"
27 28
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
Bruce Momjian's avatar
Bruce Momjian committed
29 30
#include "nodes/pg_list.h"
#include "nodes/relation.h"
31
#include "optimizer/clauses.h"
32
#include "optimizer/restrictinfo.h"
33
#include "optimizer/cost.h"
Bruce Momjian's avatar
Bruce Momjian committed
34 35 36 37 38
#include "optimizer/internal.h"
#include "optimizer/keys.h"
#include "optimizer/ordering.h"
#include "optimizer/paths.h"
#include "optimizer/plancat.h"
39 40
#include "optimizer/pathnode.h"
#include "optimizer/xfunc.h"
41
#include "parser/parsetree.h"	/* for getrelid() */
42 43
#include "parser/parse_expr.h"	/* for exprType() */
#include "parser/parse_oper.h"	/* for oprid() and oper() */
44
#include "parser/parse_coerce.h"/* for IS_BINARY_COMPATIBLE() */
Bruce Momjian's avatar
Bruce Momjian committed
45
#include "utils/lsyscache.h"
46 47


48
static void match_index_orclauses(RelOptInfo * rel, RelOptInfo * index, int indexkey,
49
					  int xclass, List *restrictinfo_list);
50 51 52
static bool match_index_to_operand(int indexkey, Expr *operand,
					   RelOptInfo * rel, RelOptInfo * index);
static List *match_index_orclause(RelOptInfo * rel, RelOptInfo * index, int indexkey,
53
			 int xclass, List *or_clauses, List *other_matching_indices);
54
static List *group_clauses_by_indexkey(RelOptInfo * rel, RelOptInfo * index,
55
					int *indexkeys, Oid *classes, List *restrictinfo_list);
56
static List *group_clauses_by_ikey_for_joins(RelOptInfo * rel, RelOptInfo * index,
57
								int *indexkeys, Oid *classes, List *join_cinfo_list, List *restr_cinfo_list);
58
static RestrictInfo *match_clause_to_indexkey(RelOptInfo * rel, RelOptInfo * index, int indexkey,
Bruce Momjian's avatar
Bruce Momjian committed
59
						 int xclass, RestrictInfo * restrictInfo, bool join);
60
static bool pred_test(List *predicate_list, List *restrictinfo_list,
61
		  List *joininfo_list);
62
static bool one_pred_test(Expr *predicate, List *restrictinfo_list);
63 64 65
static bool one_pred_clause_expr_test(Expr *predicate, Node *clause);
static bool one_pred_clause_test(Expr *predicate, Node *clause);
static bool clause_pred_clause_test(Expr *predicate, Node *clause);
66
static List *indexable_joinclauses(RelOptInfo * rel, RelOptInfo * index,
67
					  List *joininfo_list, List *restrictinfo_list);
68 69 70
static List *index_innerjoin(Query *root, RelOptInfo * rel,
				List *clausegroup_list, RelOptInfo * index);
static List *create_index_paths(Query *root, RelOptInfo * rel, RelOptInfo * index,
71 72
				   List *clausegroup_list, bool join);
static List *add_index_paths(List *indexpaths, List *new_indexpaths);
73
static bool function_index_operand(Expr *funcOpnd, RelOptInfo * rel, RelOptInfo * index);
74 75


76
/* find_index_paths()
77 78 79 80 81 82 83 84 85 86 87 88 89
 *	  Finds all possible index paths by determining which indices in the
 *	  list 'indices' are usable.
 *
 *	  To be usable, an index must match against either a set of
 *	  restriction clauses or join clauses.
 *
 *	  Note that the current implementation requires that there exist
 *	  matching clauses for every key in the index (i.e., no partial
 *	  matches are allowed).
 *
 *	  If an index can't be used with restriction clauses, but its keys
 *	  match those of the result sort order (according to information stored
 *	  within 'sortkeys'), then the index is also considered.
90 91 92
 *
 * 'rel' is the relation entry to which these index paths correspond
 * 'indices' is a list of possible index paths
93
 * 'restrictinfo-list' is a list of restriction restrictinfo nodes for 'rel'
94 95
 * 'joininfo-list' is a list of joininfo nodes for 'rel'
 * 'sortkeys' is a node describing the result sort order (from
96 97
 *		(find_sortkeys))
 *
98
 * Returns a list of index nodes.
99
 *
100
 */
101
List *
102
find_index_paths(Query *root,
103
				 RelOptInfo * rel,
104
				 List *indices,
105
				 List *restrictinfo_list,
106
				 List *joininfo_list)
107
{
108 109
	List	   *scanclausegroups = NIL;
	List	   *scanpaths = NIL;
110
	RelOptInfo *index = (RelOptInfo *) NULL;
111 112 113
	List	   *joinclausegroups = NIL;
	List	   *joinpaths = NIL;
	List	   *retval = NIL;
114
	List	   *ilist;
115

116
	foreach(ilist, indices)
117
	{
118
		index = (RelOptInfo *) lfirst(ilist);
119

120 121 122 123
		/*
		 * If this is a partial index, return if it fails the predicate
		 * test
		 */
124
		if (index->indpred != NIL)
125
			if (!pred_test(index->indpred, restrictinfo_list, joininfo_list))
126
				continue;
127

128 129
		/*
		 * 1. Try matching the index against subclauses of an 'or' clause.
130
		 * The fields of the restrictinfo nodes are marked with lists of the
131
		 * matching indices.  No path are actually created.  We currently
132 133 134
		 * only look to match the first key.  We don't find multi-key
		 * index cases where an AND matches the first key, and the OR
		 * matches the second key.
135
		 */
136
		match_index_orclauses(rel,
137 138 139
							  index,
							  index->indexkeys[0],
							  index->classlist[0],
140
							  restrictinfo_list);
141

142
		/*
143 144 145
		 * 2. If the keys of this index match any of the available
		 * restriction clauses, then create pathnodes corresponding to
		 * each group of usable clauses.
146 147 148 149 150
		 */
		scanclausegroups = group_clauses_by_indexkey(rel,
													 index,
													 index->indexkeys,
													 index->classlist,
151
													 restrictinfo_list);
152

153 154 155 156 157 158 159
		scanpaths = NIL;
		if (scanclausegroups != NIL)
			scanpaths = create_index_paths(root,
										   rel,
										   index,
										   scanclausegroups,
										   false);
160

161 162
		/*
		 * 3. If this index can be used with any join clause, then create
163 164 165 166
		 * pathnodes for each group of usable clauses.	An index can be
		 * used with a join clause if its ordering is useful for a
		 * mergejoin, or if the index can possibly be used for scanning
		 * the inner relation of a nestloop join.
167
		 */
168
		joinclausegroups = indexable_joinclauses(rel, index, joininfo_list, restrictinfo_list);
169
		joinpaths = NIL;
170

171 172 173 174
		if (joinclausegroups != NIL)
		{
			List	   *new_join_paths = create_index_paths(root, rel,
															index,
175
														joinclausegroups,
176 177
															true);
			List	   *innerjoin_paths = index_innerjoin(root, rel, joinclausegroups, index);
178

179 180 181
			rel->innerjoin = nconc(rel->innerjoin, innerjoin_paths);
			joinpaths = new_join_paths;
		}
182

183 184 185 186 187 188 189
		/*
		 * Some sanity checks to make sure that the indexpath is valid.
		 */
		if (joinpaths != NULL)
			retval = add_index_paths(joinpaths, retval);
		if (scanpaths != NULL)
			retval = add_index_paths(scanpaths, retval);
190
	}
191

192
	return retval;
193 194 195 196 197

}


/****************************************************************************
198
 *		----  ROUTINES TO MATCH 'OR' CLAUSES  ----
199 200 201
 ****************************************************************************/


202
/*
203
 * match-index-orclauses--
204 205 206 207 208
 *	  Attempt to match an index against subclauses within 'or' clauses.
 *	  If the index does match, then the clause is marked with information
 *	  about the index.
 *
 *	  Essentially, this adds 'index' to the list of indices in the
209
 *	  RestrictInfo field of each of the clauses which it matches.
210
 *
211 212 213 214
 * 'rel' is the node of the relation on which the index is defined.
 * 'index' is the index node.
 * 'indexkey' is the (single) key of the index
 * 'class' is the class of the operator corresponding to 'indexkey'.
215
 * 'restrictinfo-list' is the list of available restriction clauses.
216
 *
217
 * Returns nothing.
218
 *
219 220
 */
static void
221 222
match_index_orclauses(RelOptInfo * rel,
					  RelOptInfo * index,
223 224
					  int indexkey,
					  int xclass,
225
					  List *restrictinfo_list)
226
{
227
	RestrictInfo *restrictinfo = (RestrictInfo *) NULL;
228
	List	   *i = NIL;
229

230
	foreach(i, restrictinfo_list)
231
	{
232 233
		restrictinfo = (RestrictInfo *) lfirst(i);
		if (valid_or_clause(restrictinfo))
234 235 236 237 238 239 240
		{

			/*
			 * Mark the 'or' clause with a list of indices which match
			 * each of its subclauses.	The list is generated by adding
			 * 'index' to the existing list where appropriate.
			 */
241
			restrictinfo->indexids = match_index_orclause(rel, index, indexkey,
242
									 xclass,
243 244
									 restrictinfo->clause->args,
									 restrictinfo->indexids);
245
		}
246 247 248
	}
}

249
/* match_index_to_operand()
250 251 252
 *	  Generalize test for a match between an existing index's key
 *	  and the operand on the rhs of a restriction clause.  Now check
 *	  for functional indices as well.
253
 */
254
static bool
255
match_index_to_operand(int indexkey,
256
					   Expr *operand,
257 258
					   RelOptInfo * rel,
					   RelOptInfo * index)
259
{
260
	bool		result;
261 262 263 264 265

	/*
	 * Normal index.
	 */
	if (index->indproc == InvalidOid)
266 267 268 269
	{
		result = match_indexkey_operand(indexkey, (Var *) operand, rel);
		return result;
	}
270 271 272 273

	/*
	 * functional index check
	 */
274 275
	result = function_index_operand(operand, rel, index);
	return result;
276 277
}

278
/*
279
 * match-index-orclause--
280 281 282 283 284 285
 *	  Attempts to match an index against the subclauses of an 'or' clause.
 *
 *	  A match means that:
 *	  (1) the operator within the subclause can be used with one
 *				of the index's operator classes, and
 *	  (2) there is a usable key that matches the variable within a
286
 *				searchable clause.
287
 *
288 289
 * 'or-clauses' are the remaining subclauses within the 'or' clause
 * 'other-matching-indices' is the list of information on other indices
290 291 292 293
 *		that have already been matched to subclauses within this
 *		particular 'or' clause (i.e., a list previously generated by
 *		this routine)
 *
294 295 296 297 298
 * Returns a list of the form ((a b c) (d e f) nil (g h) ...) where
 * a,b,c are nodes of indices that match the first subclause in
 * 'or-clauses', d,e,f match the second subclause, no indices
 * match the third, g,h match the fourth, etc.
 */
299
static List *
300 301
match_index_orclause(RelOptInfo * rel,
					 RelOptInfo * index,
302 303
					 int indexkey,
					 int xclass,
304 305
					 List *or_clauses,
					 List *other_matching_indices)
306
{
307
	Node	   *clause = NULL;
Bruce Momjian's avatar
Bruce Momjian committed
308
	List	   *matching_indices = other_matching_indices;
309 310
	List	   *index_list = NIL;
	List	   *clist;
311

Bruce Momjian's avatar
Bruce Momjian committed
312 313 314 315 316 317
	/* first time through, we create index list */
	if (!other_matching_indices)
	{
		foreach(clist, or_clauses)
			matching_indices = lcons(NIL, matching_indices);
	}
318 319
	else
		matching_indices = other_matching_indices;
Bruce Momjian's avatar
Bruce Momjian committed
320 321

	index_list = matching_indices;
322

323
	foreach(clist, or_clauses)
324
	{
325
		clause = lfirst(clist);
326

327 328 329
		if (is_opclause(clause) &&
			op_class(((Oper *) ((Expr *) clause)->oper)->opno,
					 xclass, index->relam) &&
330
			((match_index_to_operand(indexkey,
331 332 333
									 (Expr *) get_leftop((Expr *) clause),
									 rel,
									 index) &&
334 335
			  IsA(get_rightop((Expr *) clause), Const)) ||
			 (match_index_to_operand(indexkey,
Bruce Momjian's avatar
Bruce Momjian committed
336
								   (Expr *) get_rightop((Expr *) clause),
337 338 339
									 rel,
									 index) &&
			  IsA(get_leftop((Expr *) clause), Const))))
Bruce Momjian's avatar
Bruce Momjian committed
340
			lfirst(matching_indices) = lcons(index, lfirst(matching_indices));
341

Bruce Momjian's avatar
Bruce Momjian committed
342
		matching_indices = lnext(matching_indices);
343
	}
344
	return index_list;
345

346 347 348
}

/****************************************************************************
349
 *				----  ROUTINES TO CHECK RESTRICTIONS  ----
350 351 352 353 354 355 356 357 358 359 360 361 362
 ****************************************************************************/


/*
 * DoneMatchingIndexKeys() - MACRO
 *
 * Determine whether we should continue matching index keys in a clause.
 * Depends on if there are more to match or if this is a functional index.
 * In the latter case we stop after the first match since the there can
 * be only key (i.e. the function's return value) and the attributes in
 * keys list represent the arguments to the function.  -mer 3 Oct. 1991
 */
#define DoneMatchingIndexKeys(indexkeys, index) \
363 364
		(indexkeys[0] == 0 || \
		 (index->indproc != InvalidOid))
365

366
/*
367
 * group-clauses-by-indexkey--
368 369 370
 *	  Determines whether there are clauses which will match each and every
 *	  one of the remaining keys of an index.
 *
371 372 373 374
 * 'rel' is the node of the relation corresponding to the index.
 * 'indexkeys' are the remaining index keys to be matched.
 * 'classes' are the classes of the index operators on those keys.
 * 'clauses' is either:
375 376 377 378 379 380 381
 *		(1) the list of available restriction clauses on a single
 *				relation, or
 *		(2) a list of join clauses between 'rel' and a fixed set of
 *				relations,
 *		depending on the value of 'join'.
 *
 *		NOTE: it works now for restriction clauses only. - vadim 03/18/97
382
 *
383 384
 * Returns all possible groups of clauses that will match (given that
 * one or more clauses can match any of the remaining keys).
385
 * E.g., if you have clauses A, B, and C, ((A B) (A C)) might be
386
 * returned for an index with 2 keys.
387
 *
388
 */
389
static List *
390 391
group_clauses_by_indexkey(RelOptInfo * rel,
						  RelOptInfo * index,
392
						  int *indexkeys,
393
						  Oid *classes,
394
						  List *restrictinfo_list)
395
{
396
	List	   *curCinfo = NIL;
397
	RestrictInfo *matched_clause = (RestrictInfo *) NULL;
398 399 400
	List	   *clausegroup = NIL;
	int			curIndxKey;
	Oid			curClass;
401

402
	if (restrictinfo_list == NIL || indexkeys[0] == 0)
403
		return NIL;
404

405
	do
406
	{
407
		List	   *tempgroup = NIL;
408 409 410 411

		curIndxKey = indexkeys[0];
		curClass = classes[0];

412
		foreach(curCinfo, restrictinfo_list)
413
		{
414
			RestrictInfo *temp = (RestrictInfo *) lfirst(curCinfo);
415 416 417 418 419 420 421 422 423

			matched_clause = match_clause_to_indexkey(rel,
													  index,
													  curIndxKey,
													  curClass,
													  temp,
													  false);
			if (!matched_clause)
				continue;
424

425 426 427 428
			tempgroup = lappend(tempgroup, matched_clause);
		}
		if (tempgroup == NIL)
			break;
429

430 431 432 433 434
		clausegroup = nconc(clausegroup, tempgroup);

		indexkeys++;
		classes++;

435
	} while (!DoneMatchingIndexKeys(indexkeys, index));
436

437 438 439
	/* clausegroup holds all matched clauses ordered by indexkeys */

	if (clausegroup != NIL)
440
		return lcons(clausegroup, NIL);
441
	return NIL;
442 443
}

444
/*
445
 * group-clauses-by-ikey-for-joins--
446 447 448 449
 *	  special edition of group-clauses-by-indexkey - will
 *	  match join & restriction clauses. See comment in indexable_joinclauses.
 *		- vadim 03/18/97
 *
450
 */
451
static List *
452 453
group_clauses_by_ikey_for_joins(RelOptInfo * rel,
								RelOptInfo * index,
454
								int *indexkeys,
455 456 457
								Oid *classes,
								List *join_cinfo_list,
								List *restr_cinfo_list)
458
{
459
	List	   *curCinfo = NIL;
460
	RestrictInfo *matched_clause = (RestrictInfo *) NULL;
461 462 463 464
	List	   *clausegroup = NIL;
	int			curIndxKey;
	Oid			curClass;
	bool		jfound = false;
465

466
	if (join_cinfo_list == NIL || indexkeys[0] == 0)
467 468
		return NIL;

469
	do
470
	{
471
		List	   *tempgroup = NIL;
472 473 474 475 476 477

		curIndxKey = indexkeys[0];
		curClass = classes[0];

		foreach(curCinfo, join_cinfo_list)
		{
478
			RestrictInfo *temp = (RestrictInfo *) lfirst(curCinfo);
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493

			matched_clause = match_clause_to_indexkey(rel,
													  index,
													  curIndxKey,
													  curClass,
													  temp,
													  true);
			if (!matched_clause)
				continue;

			tempgroup = lappend(tempgroup, matched_clause);
			jfound = true;
		}
		foreach(curCinfo, restr_cinfo_list)
		{
494
			RestrictInfo *temp = (RestrictInfo *) lfirst(curCinfo);
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513

			matched_clause = match_clause_to_indexkey(rel,
													  index,
													  curIndxKey,
													  curClass,
													  temp,
													  false);
			if (!matched_clause)
				continue;

			tempgroup = lappend(tempgroup, matched_clause);
		}
		if (tempgroup == NIL)
			break;

		clausegroup = nconc(clausegroup, tempgroup);

		indexkeys++;
		classes++;
514

515
	} while (!DoneMatchingIndexKeys(indexkeys, index));
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530

	/* clausegroup holds all matched clauses ordered by indexkeys */

	if (clausegroup != NIL)
	{

		/*
		 * if no one join clause was matched then there ain't clauses for
		 * joins at all.
		 */
		if (!jfound)
		{
			freeList(clausegroup);
			return NIL;
		}
531
		return lcons(clausegroup, NIL);
532
	}
533
	return NIL;
534 535
}

536 537 538 539 540 541 542
/*
 * IndexScanableClause ()  MACRO
 *
 * Generalize condition on which we match a clause with an index.
 * Now we can match with functional indices.
 */
#define IndexScanableOperand(opnd, indkeys, rel, index) \
543 544 545
	((index->indproc == InvalidOid) ? \
		match_indexkey_operand(indkeys, opnd, rel) : \
		function_index_operand((Expr*)opnd,rel,index))
546

547 548
/*
 * There was
549
 *		equal_indexkey_var(indkeys,opnd) : \
550
 * above, and now
551
 *		match_indexkey_operand(indkeys, opnd, rel) : \
552 553 554
 * - vadim 01/22/97
 */

555
/* match_clause_to_indexkey()
556 557 558 559 560 561 562 563 564 565 566
 *	  Finds the first of a relation's available restriction clauses that
 *	  matches a key of an index.
 *
 *	  To match, the clause must:
 *	  (1) be in the form (op var const) if the clause is a single-
 *				relation clause, and
 *	  (2) contain an operator which is in the same class as the index
 *				operator for this key.
 *
 *	  If the clause being matched is a join clause, then 'join' is t.
 *
567
 * Returns a single restrictinfo node corresponding to the matching
568 569 570
 * clause.
 *
 * NOTE:  returns nil if clause is an or_clause.
571
 *
572
 */
573
static RestrictInfo *
Bruce Momjian's avatar
Bruce Momjian committed
574 575
match_clause_to_indexkey(RelOptInfo *rel,
						 RelOptInfo *index,
576 577
						 int indexkey,
						 int xclass,
Bruce Momjian's avatar
Bruce Momjian committed
578
						 RestrictInfo *restrictInfo,
579
						 bool join)
580
{
Bruce Momjian's avatar
Bruce Momjian committed
581
	Expr	   *clause = restrictInfo->clause;
582 583 584 585 586
	Var		   *leftop,
			   *rightop;
	Oid			join_op = InvalidOid;
	Oid			restrict_op = InvalidOid;
	bool		isIndexable = false;
587 588 589

	if (or_clause((Node *) clause) ||
		not_clause((Node *) clause) || single_node((Node *) clause))
590
		return (RestrictInfo *) NULL;
591 592 593 594

	leftop = get_leftop(clause);
	rightop = get_rightop(clause);

595
	/*
596 597
	 * If this is not a join clause, check for clauses of the form:
	 * (operator var/func constant) and (operator constant var/func)
598
	 */
599
	if (!join)
600
	{
601

602 603 604 605 606 607 608
		/*
		 * Check for standard s-argable clause
		 */
		if ((rightop && IsA(rightop, Const)) ||
			(rightop && IsA(rightop, Param)))
		{
			restrict_op = ((Oper *) ((Expr *) clause)->oper)->opno;
609

Bruce Momjian's avatar
Bruce Momjian committed
610
			isIndexable = (op_class(restrict_op, xclass, index->relam) &&
611 612 613 614 615 616
						   IndexScanableOperand(leftop,
												indexkey,
												rel,
												index));

#ifndef IGNORE_BINARY_COMPATIBLE_INDICES
617 618 619 620

			/*
			 * Didn't find an index? Then maybe we can find another
			 * binary-compatible index instead... thomas 1998-08-14
621
			 */
622
			if (!isIndexable)
623
			{
624 625
				Oid			ltype;
				Oid			rtype;
626

627 628
				ltype = exprType((Node *) leftop);
				rtype = exprType((Node *) rightop);
629

630 631 632 633
				/*
				 * make sure we have two different binary-compatible
				 * types...
				 */
634
				if ((ltype != rtype)
635
					&& IS_BINARY_COMPATIBLE(ltype, rtype))
636
				{
637 638
					char	   *opname;
					Operator	newop;
639 640

					opname = get_opname(restrict_op);
641 642 643 644
					if (opname != NULL)
						newop = oper(opname, ltype, ltype, TRUE);
					else
						newop = NULL;
645 646 647 648 649 650

					/* actually have a different operator to try? */
					if (HeapTupleIsValid(newop) && (oprid(newop) != restrict_op))
					{
						restrict_op = oprid(newop);

651
						isIndexable = (op_class(restrict_op, xclass, index->relam) &&
652
							 IndexScanableOperand(leftop,
Bruce Momjian's avatar
Bruce Momjian committed
653 654 655
												  indexkey,
												  rel,
												  index));
656 657 658 659 660 661 662

						if (isIndexable)
							((Oper *) ((Expr *) clause)->oper)->opno = restrict_op;
					}
				}
			}
#endif
663 664
		}

665
		/*
666
		 * Must try to commute the clause to standard s-arg format.
667
		 */
668 669 670
		else if ((leftop && IsA(leftop, Const)) ||
				 (leftop && IsA(leftop, Param)))
		{
671
			restrict_op = get_commutator(((Oper *) ((Expr *) clause)->oper)->opno);
672

673
			isIndexable = ((restrict_op != InvalidOid) &&
674 675 676
						   op_class(restrict_op, xclass, index->relam) &&
						   IndexScanableOperand(rightop,
												indexkey, rel, index));
677 678

#ifndef IGNORE_BINARY_COMPATIBLE_INDICES
679
			if (!isIndexable)
680
			{
681 682
				Oid			ltype;
				Oid			rtype;
683

684 685
				ltype = exprType((Node *) leftop);
				rtype = exprType((Node *) rightop);
686 687

				if ((ltype != rtype)
688
					&& IS_BINARY_COMPATIBLE(ltype, rtype))
689
				{
690 691
					char	   *opname;
					Operator	newop;
692 693 694 695

					restrict_op = ((Oper *) ((Expr *) clause)->oper)->opno;

					opname = get_opname(restrict_op);
696 697 698 699
					if (opname != NULL)
						newop = oper(opname, rtype, rtype, TRUE);
					else
						newop = NULL;
700 701 702

					if (HeapTupleIsValid(newop) && (oprid(newop) != restrict_op))
					{
703
						restrict_op = get_commutator(oprid(newop));
704 705

						isIndexable = ((restrict_op != InvalidOid) &&
706 707 708 709 710
						   op_class(restrict_op, xclass, index->relam) &&
									   IndexScanableOperand(rightop,
															indexkey,
															rel,
															index));
711 712 713 714 715 716 717

						if (isIndexable)
							((Oper *) ((Expr *) clause)->oper)->opno = oprid(newop);
					}
				}
			}
#endif
718

719 720
			if (isIndexable)
			{
721

722 723 724 725 726 727 728
				/*
				 * In place list modification. (op const var/func) -> (op
				 * var/func const)
				 */
				CommuteClause((Node *) clause);
			}
		}
729
	}
730

731 732 733 734 735
	/*
	 * Check for an indexable scan on one of the join relations. clause is
	 * of the form (operator var/func var/func)
	 */
	else
736
	{
737 738 739 740 741 742 743 744 745 746 747 748 749
		if (rightop
		&& match_index_to_operand(indexkey, (Expr *) rightop, rel, index))
		{

			join_op = get_commutator(((Oper *) ((Expr *) clause)->oper)->opno);

		}
		else if (leftop
				 && match_index_to_operand(indexkey,
										   (Expr *) leftop, rel, index))
			join_op = ((Oper *) ((Expr *) clause)->oper)->opno;

		if (join_op && op_class(join_op, xclass, index->relam) &&
750
			is_joinable((Node *) clause))
751 752 753 754 755 756 757 758 759 760
		{
			isIndexable = true;

			/*
			 * If we're using the operand's commutator we must commute the
			 * clause.
			 */
			if (join_op != ((Oper *) ((Expr *) clause)->oper)->opno)
				CommuteClause((Node *) clause);
		}
761 762
	}

763
	if (isIndexable)
Bruce Momjian's avatar
Bruce Momjian committed
764
		return restrictInfo;
765

766
	return NULL;
767 768 769
}

/****************************************************************************
770
 *				----  ROUTINES TO DO PARTIAL INDEX PREDICATE TESTS	----
771 772
 ****************************************************************************/

773
/*
774
 * pred_test--
775
 *	  Does the "predicate inclusion test" for partial indexes.
776
 *
777
 *	  Recursively checks whether the clauses in restrictinfo_list imply
778
 *	  that the given predicate is true.
779
 *
780 781 782 783 784 785
 *	  This routine (together with the routines it calls) iterates over
 *	  ANDs in the predicate first, then reduces the qualification
 *	  clauses down to their constituent terms, and iterates over ORs
 *	  in the predicate last.  This order is important to make the test
 *	  succeed whenever possible (assuming the predicate has been
 *	  successfully cnfify()-ed). --Nels, Jan '93
786
 */
787
static bool
788
pred_test(List *predicate_list, List *restrictinfo_list, List *joininfo_list)
789
{
790 791 792
	List	   *pred,
			   *items,
			   *item;
793 794 795 796 797 798 799 800

	/*
	 * Note: if Postgres tried to optimize queries by forming equivalence
	 * classes over equi-joined attributes (i.e., if it recognized that a
	 * qualification such as "where a.b=c.d and a.b=5" could make use of
	 * an index on c.d), then we could use that equivalence class info
	 * here with joininfo_list to do more complete tests for the usability
	 * of a partial index.	For now, the test only uses restriction
801
	 * clauses (those in restrictinfo_list). --Nels, Dec '92
802 803 804 805
	 */

	if (predicate_list == NULL)
		return true;			/* no predicate: the index is usable */
806
	if (restrictinfo_list == NULL)
807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
		return false;			/* no restriction clauses: the test must
								 * fail */

	foreach(pred, predicate_list)
	{

		/*
		 * if any clause is not implied, the whole predicate is not
		 * implied
		 */
		if (and_clause(lfirst(pred)))
		{
			items = ((Expr *) lfirst(pred))->args;
			foreach(item, items)
			{
822
				if (!one_pred_test(lfirst(item), restrictinfo_list))
823 824 825
					return false;
			}
		}
826
		else if (!one_pred_test(lfirst(pred), restrictinfo_list))
827
			return false;
828
	}
829
	return true;
830 831 832
}


833
/*
834
 * one_pred_test--
835 836
 *	  Does the "predicate inclusion test" for one conjunct of a predicate
 *	  expression.
837
 */
838
static bool
839
one_pred_test(Expr *predicate, List *restrictinfo_list)
840
{
841
	RestrictInfo *restrictinfo;
842
	List	   *item;
843 844

	Assert(predicate != NULL);
845
	foreach(item, restrictinfo_list)
846
	{
847
		restrictinfo = (RestrictInfo *) lfirst(item);
848
		/* if any clause implies the predicate, return true */
849
		if (one_pred_clause_expr_test(predicate, (Node *) restrictinfo->clause))
850 851 852
			return true;
	}
	return false;
853 854 855
}


856
/*
857
 * one_pred_clause_expr_test--
858 859
 *	  Does the "predicate inclusion test" for a general restriction-clause
 *	  expression.
860
 */
861
static bool
862
one_pred_clause_expr_test(Expr *predicate, Node *clause)
863
{
864 865
	List	   *items,
			   *item;
866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892

	if (is_opclause(clause))
		return one_pred_clause_test(predicate, clause);
	else if (or_clause(clause))
	{
		items = ((Expr *) clause)->args;
		foreach(item, items)
		{
			/* if any OR item doesn't imply the predicate, clause doesn't */
			if (!one_pred_clause_expr_test(predicate, lfirst(item)))
				return false;
		}
		return true;
	}
	else if (and_clause(clause))
	{
		items = ((Expr *) clause)->args;
		foreach(item, items)
		{

			/*
			 * if any AND item implies the predicate, the whole clause
			 * does
			 */
			if (one_pred_clause_expr_test(predicate, lfirst(item)))
				return true;
		}
893 894
		return false;
	}
895 896 897 898
	else
	{
		/* unknown clause type never implies the predicate */
		return false;
899 900 901 902
	}
}


903
/*
904
 * one_pred_clause_test--
905 906
 *	  Does the "predicate inclusion test" for one conjunct of a predicate
 *	  expression for a simple restriction clause.
907
 */
908
static bool
909
one_pred_clause_test(Expr *predicate, Node *clause)
910
{
911 912
	List	   *items,
			   *item;
913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939

	if (is_opclause((Node *) predicate))
		return clause_pred_clause_test(predicate, clause);
	else if (or_clause((Node *) predicate))
	{
		items = predicate->args;
		foreach(item, items)
		{
			/* if any item is implied, the whole predicate is implied */
			if (one_pred_clause_test(lfirst(item), clause))
				return true;
		}
		return false;
	}
	else if (and_clause((Node *) predicate))
	{
		items = predicate->args;
		foreach(item, items)
		{

			/*
			 * if any item is not implied, the whole predicate is not
			 * implied
			 */
			if (!one_pred_clause_test(lfirst(item), clause))
				return false;
		}
940 941
		return true;
	}
942 943 944
	else
	{
		elog(DEBUG, "Unsupported predicate type, index will not be used");
945 946 947 948 949 950 951
		return false;
	}
}


/*
 * Define an "operator implication table" for btree operators ("strategies").
952
 * The "strategy numbers" are:	(1) <	(2) <=	 (3) =	 (4) >=   (5) >
953 954 955
 *
 * The interpretation of:
 *
956
 *		test_op = BT_implic_table[given_op-1][target_op-1]
957 958 959 960
 *
 * where test_op, given_op and target_op are strategy numbers (from 1 to 5)
 * of btree operators, is as follows:
 *
961 962 963 964 965
 *	 If you know, for some ATTR, that "ATTR given_op CONST1" is true, and you
 *	 want to determine whether "ATTR target_op CONST2" must also be true, then
 *	 you can use "CONST1 test_op CONST2" as a test.  If this test returns true,
 *	 then the target expression must be true; if the test returns false, then
 *	 the target expression may be false.
966 967 968 969 970
 *
 * An entry where test_op==0 means the implication cannot be determined, i.e.,
 * this test should always be considered false.
 */

971
StrategyNumber BT_implic_table[BTMaxStrategyNumber][BTMaxStrategyNumber] = {
972 973 974 975 976
	{2, 2, 0, 0, 0},
	{1, 2, 0, 0, 0},
	{1, 2, 3, 4, 5},
	{0, 0, 0, 4, 5},
	{0, 0, 0, 4, 4}
977 978 979
};


980
/*
981
 * clause_pred_clause_test--
982 983 984 985 986 987 988
 *	  Use operator class info to check whether clause implies predicate.
 *
 *	  Does the "predicate inclusion test" for a "simple clause" predicate
 *	  for a single "simple clause" restriction.  Currently, this only handles
 *	  (binary boolean) operators that are in some btree operator class.
 *	  Eventually, rtree operators could also be handled by defining an
 *	  appropriate "RT_implic_table" array.
989
 */
990
static bool
991
clause_pred_clause_test(Expr *predicate, Node *clause)
992
{
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
	Var		   *pred_var,
			   *clause_var;
	Const	   *pred_const,
			   *clause_const;
	Oid			pred_op,
				clause_op,
				test_op;
	Oid			opclass_id;
	StrategyNumber pred_strategy,
				clause_strategy,
				test_strategy;
	Oper	   *test_oper;
	Expr	   *test_expr;
	bool		test_result,
				isNull;
	Relation	relation;
	HeapScanDesc scan;
	HeapTuple	tuple;
	ScanKeyData entry[3];
	Form_pg_amop form;
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026

	pred_var = (Var *) get_leftop(predicate);
	pred_const = (Const *) get_rightop(predicate);
	clause_var = (Var *) get_leftop((Expr *) clause);
	clause_const = (Const *) get_rightop((Expr *) clause);

	/* Check the basic form; for now, only allow the simplest case */
	if (!is_opclause(clause) ||
		!IsA(clause_var, Var) ||
		!IsA(clause_const, Const) ||
		!IsA(predicate->oper, Oper) ||
		!IsA(pred_var, Var) ||
		!IsA(pred_const, Const))
		return false;
1027

1028 1029 1030 1031 1032 1033
	/*
	 * The implication can't be determined unless the predicate and the
	 * clause refer to the same attribute.
	 */
	if (clause_var->varattno != pred_var->varattno)
		return false;
1034

1035 1036 1037
	/* Get the operators for the two clauses we're comparing */
	pred_op = ((Oper *) ((Expr *) predicate)->oper)->opno;
	clause_op = ((Oper *) ((Expr *) clause)->oper)->opno;
1038 1039


1040 1041 1042 1043 1044
	/*
	 * 1. Find a "btree" strategy number for the pred_op
	 */
	ScanKeyEntryInitialize(&entry[0], 0,
						   Anum_pg_amop_amopid,
Bruce Momjian's avatar
Bruce Momjian committed
1045
						   F_OIDEQ,
Bruce Momjian's avatar
Bruce Momjian committed
1046
						   ObjectIdGetDatum(BTREE_AM_OID));
1047

1048 1049
	ScanKeyEntryInitialize(&entry[1], 0,
						   Anum_pg_amop_amopopr,
Bruce Momjian's avatar
Bruce Momjian committed
1050
						   F_OIDEQ,
1051
						   ObjectIdGetDatum(pred_op));
1052

1053
	relation = heap_openr(AccessMethodOperatorRelationName);
1054

1055 1056 1057 1058 1059 1060 1061 1062
	/*
	 * The following assumes that any given operator will only be in a
	 * single btree operator class.  This is true at least for all the
	 * pre-defined operator classes.  If it isn't true, then whichever
	 * operator class happens to be returned first for the given operator
	 * will be used to find the associated strategy numbers for the test.
	 * --Nels, Jan '93
	 */
1063
	scan = heap_beginscan(relation, false, SnapshotNow, 2, entry);
1064
	tuple = heap_getnext(scan, 0);
1065 1066 1067 1068 1069 1070
	if (!HeapTupleIsValid(tuple))
	{
		elog(DEBUG, "clause_pred_clause_test: unknown pred_op");
		return false;
	}
	form = (Form_pg_amop) GETSTRUCT(tuple);
1071

1072 1073
	/* Get the predicate operator's strategy number (1 to 5) */
	pred_strategy = (StrategyNumber) form->amopstrategy;
1074

1075 1076
	/* Remember which operator class this strategy number came from */
	opclass_id = form->amopclaid;
1077

1078
	heap_endscan(scan);
1079 1080


1081 1082 1083 1084 1085
	/*
	 * 2. From the same opclass, find a strategy num for the clause_op
	 */
	ScanKeyEntryInitialize(&entry[1], 0,
						   Anum_pg_amop_amopclaid,
Bruce Momjian's avatar
Bruce Momjian committed
1086
						   F_OIDEQ,
1087 1088 1089 1090
						   ObjectIdGetDatum(opclass_id));

	ScanKeyEntryInitialize(&entry[2], 0,
						   Anum_pg_amop_amopopr,
Bruce Momjian's avatar
Bruce Momjian committed
1091
						   F_OIDEQ,
1092 1093
						   ObjectIdGetDatum(clause_op));

1094
	scan = heap_beginscan(relation, false, SnapshotNow, 3, entry);
1095
	tuple = heap_getnext(scan, 0);
1096 1097 1098 1099 1100 1101
	if (!HeapTupleIsValid(tuple))
	{
		elog(DEBUG, "clause_pred_clause_test: unknown clause_op");
		return false;
	}
	form = (Form_pg_amop) GETSTRUCT(tuple);
1102

1103 1104 1105
	/* Get the restriction clause operator's strategy number (1 to 5) */
	clause_strategy = (StrategyNumber) form->amopstrategy;
	heap_endscan(scan);
1106 1107


1108 1109 1110
	/*
	 * 3. Look up the "test" strategy number in the implication table
	 */
1111

1112 1113 1114
	test_strategy = BT_implic_table[clause_strategy - 1][pred_strategy - 1];
	if (test_strategy == 0)
		return false;			/* the implication cannot be determined */
1115 1116


1117 1118 1119
	/*
	 * 4. From the same opclass, find the operator for the test strategy
	 */
1120

1121 1122
	ScanKeyEntryInitialize(&entry[2], 0,
						   Anum_pg_amop_amopstrategy,
Bruce Momjian's avatar
Bruce Momjian committed
1123
						   F_INT2EQ,
1124
						   Int16GetDatum(test_strategy));
1125

1126
	scan = heap_beginscan(relation, false, SnapshotNow, 3, entry);
1127
	tuple = heap_getnext(scan, 0);
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
	if (!HeapTupleIsValid(tuple))
	{
		elog(DEBUG, "clause_pred_clause_test: unknown test_op");
		return false;
	}
	form = (Form_pg_amop) GETSTRUCT(tuple);

	/* Get the test operator */
	test_op = form->amopopr;
	heap_endscan(scan);
1138

1139 1140 1141 1142 1143 1144

	/*
	 * 5. Evaluate the test
	 */
	test_oper = makeOper(test_op,		/* opno */
						 InvalidOid,	/* opid */
1145
						 BOOLOID,		/* opresulttype */
1146 1147 1148 1149 1150 1151 1152
						 0,		/* opsize */
						 NULL); /* op_fcache */
	replace_opid(test_oper);

	test_expr = make_opclause(test_oper,
							  copyObject(clause_const),
							  copyObject(pred_const));
1153 1154

#ifndef OMIT_PARTIAL_INDEX
1155
	test_result = ExecEvalExpr((Node *) test_expr, NULL, &isNull, NULL);
1156
#endif	 /* OMIT_PARTIAL_INDEX */
1157 1158 1159 1160 1161 1162
	if (isNull)
	{
		elog(DEBUG, "clause_pred_clause_test: null test result");
		return false;
	}
	return test_result;
1163 1164 1165 1166
}


/****************************************************************************
1167
 *				----  ROUTINES TO CHECK JOIN CLAUSES  ----
1168 1169
 ****************************************************************************/

1170
/*
1171
 * indexable-joinclauses--
1172 1173 1174 1175 1176 1177
 *	  Finds all groups of join clauses from among 'joininfo-list' that can
 *	  be used in conjunction with 'index'.
 *
 *	  The first clause in the group is marked as having the other relation
 *	  in the join clause as its outer join relation.
 *
1178
 * Returns a list of these clause groups.
1179
 *
1180
 *	  Added: restrictinfo_list - list of restriction RestrictInfos. It's to
1181 1182 1183
 *		support multi-column indices in joins and for cases
 *		when a key is in both join & restriction clauses. - vadim 03/18/97
 *
1184
 */
1185
static List *
1186
indexable_joinclauses(RelOptInfo * rel, RelOptInfo * index,
1187
					  List *joininfo_list, List *restrictinfo_list)
1188
{
1189
	JoinInfo   *joininfo = (JoinInfo *) NULL;
1190 1191 1192
	List	   *cg_list = NIL;
	List	   *i = NIL;
	List	   *clausegroups = NIL;
1193 1194 1195

	foreach(i, joininfo_list)
	{
1196
		joininfo = (JoinInfo *) lfirst(i);
1197

1198
		if (joininfo->jinfo_restrictinfo == NIL)
1199
			continue;
1200
		clausegroups = group_clauses_by_ikey_for_joins(rel,
1201 1202 1203
											index,
											index->indexkeys,
											index->classlist,
1204 1205
											joininfo->jinfo_restrictinfo,
											restrictinfo_list);
1206 1207 1208

		if (clausegroups != NIL)
		{
1209
			List	   *clauses = lfirst(clausegroups);
1210

Bruce Momjian's avatar
Bruce Momjian committed
1211
			((RestrictInfo *) lfirst(clauses))->restrictinfojoinid = joininfo->otherrels;
1212 1213
		}
		cg_list = nconc(cg_list, clausegroups);
1214
	}
1215
	return cg_list;
1216 1217 1218
}

/****************************************************************************
1219
 *				----  PATH CREATION UTILITIES  ----
1220 1221 1222 1223
 ****************************************************************************/

/*
 * extract_restrict_clauses -
1224 1225
 *	  the list of clause info contains join clauses and restriction clauses.
 *	  This routine returns the restriction clauses only.
1226
 */
Bruce Momjian's avatar
Bruce Momjian committed
1227
#ifdef NOT_USED
1228
static List *
1229
extract_restrict_clauses(List *clausegroup)
1230
{
1231 1232
	List	   *restrict_cls = NIL;
	List	   *l;
1233 1234 1235

	foreach(l, clausegroup)
	{
1236
		RestrictInfo *cinfo = lfirst(l);
1237

1238
		if (!is_joinable((Node *) cinfo->clause))
1239
			restrict_cls = lappend(restrict_cls, cinfo);
1240
	}
1241
	return restrict_cls;
1242
}
1243

Bruce Momjian's avatar
Bruce Momjian committed
1244
#endif
1245

1246
/*
1247
 * index-innerjoin--
1248 1249
 *	  Creates index path nodes corresponding to paths to be used as inner
 *	  relations in nestloop joins.
1250
 *
1251
 * 'clausegroup-list' is a list of list of restrictinfo nodes which can use
1252
 * 'index' on their inner relation.
1253
 *
1254
 * Returns a list of index pathnodes.
1255
 *
1256
 */
1257
static List *
1258 1259
index_innerjoin(Query *root, RelOptInfo * rel, List *clausegroup_list,
				RelOptInfo * index)
1260
{
1261 1262 1263 1264 1265 1266
	List	   *clausegroup = NIL;
	List	   *cg_list = NIL;
	List	   *i = NIL;
	IndexPath  *pathnode = (IndexPath *) NULL;
	Cost		temp_selec;
	float		temp_pages;
1267 1268 1269

	foreach(i, clausegroup_list)
	{
1270 1271 1272
		List	   *attnos,
				   *values,
				   *flags;
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289

		clausegroup = lfirst(i);
		pathnode = makeNode(IndexPath);

		get_joinvars(lfirsti(rel->relids), clausegroup,
					 &attnos, &values, &flags);
		index_selectivity(lfirsti(index->relids),
						  index->classlist,
						  get_opnos(clausegroup),
						  getrelid(lfirsti(rel->relids),
								   root->rtable),
						  attnos,
						  values,
						  flags,
						  length(clausegroup),
						  &temp_pages,
						  &temp_selec);
Bruce Momjian's avatar
Bruce Momjian committed
1290

1291 1292
		pathnode->path.pathtype = T_IndexScan;
		pathnode->path.parent = rel;
Bruce Momjian's avatar
Bruce Momjian committed
1293 1294
	    pathnode->path.path_order.ordtype = SORTOP_ORDER;
	    pathnode->path.path_order.ord.sortop = index->ordering;
Bruce Momjian's avatar
Bruce Momjian committed
1295 1296
	    pathnode->path.keys = NIL;	/* not sure about this, bjm 1998/09/21 */

1297 1298 1299 1300
		pathnode->indexid = index->relids;
		pathnode->indexkeys = index->indexkeys;
		pathnode->indexqual = clausegroup;

Bruce Momjian's avatar
Bruce Momjian committed
1301
		pathnode->path.joinid = ((RestrictInfo *) lfirst(clausegroup))->restrictinfojoinid;
1302

1303
		pathnode->path.path_cost = cost_index((Oid) lfirsti(index->relids),
1304 1305 1306 1307 1308 1309 1310 1311 1312
					   (int) temp_pages,
					   temp_selec,
					   rel->pages,
					   rel->tuples,
					   index->pages,
					   index->tuples,
					   true);

		/*
1313
		 * copy restrictinfo list into path for expensive function
1314 1315
		 * processing -- JMH, 7/7/92
		 */
1316
		pathnode->path.loc_restrictinfo = set_difference(copyObject((Node *) rel->restrictinfo),
1317 1318 1319 1320 1321 1322
						   clausegroup);

#if 0							/* fix xfunc */
		/* add in cost for expensive functions!  -- JMH, 7/7/92 */
		if (XfuncMode != XFUNC_OFF)
		{
1323
			((Path *) pathnode)->path_cost += xfunc_get_path_cost((Path *) pathnode);
1324
		}
1325
#endif
1326 1327
		cg_list = lappend(cg_list, pathnode);
	}
1328
	return cg_list;
1329 1330
}

1331
/*
1332
 * create-index-paths--
1333 1334 1335
 *	  Creates a list of index path nodes for each group of clauses
 *	  (restriction or join) that can be used in conjunction with an index.
 *
1336
 * 'rel' is the relation for which 'index' is defined
1337
 * 'clausegroup-list' is the list of clause groups (lists of restrictinfo
1338
 *				nodes) grouped by mergejoinorder
1339
 * 'join' is a flag indicating whether or not the clauses are join
1340 1341
 *				clauses
 *
1342
 * Returns a list of new index path nodes.
1343
 *
1344
 */
1345
static List *
1346
create_index_paths(Query *root,
1347 1348
				   RelOptInfo * rel,
				   RelOptInfo * index,
1349
				   List *clausegroup_list,
1350
				   bool join)
1351
{
1352 1353 1354 1355 1356
	List	   *clausegroup = NIL;
	List	   *ip_list = NIL;
	List	   *i = NIL;
	List	   *j = NIL;
	IndexPath  *temp_path;
1357

1358 1359
	foreach(i, clausegroup_list)
	{
1360
		RestrictInfo *restrictinfo;
1361 1362
		List	   *temp_node = NIL;
		bool		temp = true;
1363 1364 1365 1366 1367

		clausegroup = lfirst(i);

		foreach(j, clausegroup)
		{
1368 1369
			restrictinfo = (RestrictInfo *) lfirst(j);
			if (!(is_joinable((Node *) restrictinfo->clause) &&
1370
				  equal_path_merge_ordering(index->ordering,
1371
											restrictinfo->mergejoinorder)))
1372 1373 1374 1375 1376 1377
				temp = false;
		}

		if (!join || temp)
		{						/* restriction, ordering scan */
			temp_path = create_index_path(root, rel, index, clausegroup, join);
Bruce Momjian's avatar
Bruce Momjian committed
1378
			temp_node = lcons(temp_path, NIL);
1379 1380 1381
			ip_list = nconc(ip_list, temp_node);
		}
	}
1382
	return ip_list;
1383 1384
}

1385
static List *
1386
add_index_paths(List *indexpaths, List *new_indexpaths)
1387
{
1388
	return append(indexpaths, new_indexpaths);
1389 1390
}

1391
static bool
1392
function_index_operand(Expr *funcOpnd, RelOptInfo * rel, RelOptInfo * index)
1393
{
1394 1395 1396 1397 1398 1399
	Oid			heapRelid = (Oid) lfirsti(rel->relids);
	Func	   *function;
	List	   *funcargs;
	int		   *indexKeys = index->indexkeys;
	List	   *arg;
	int			i;
1400

1401 1402 1403 1404 1405 1406 1407
	/*
	 * sanity check, make sure we know what we're dealing with here.
	 */
	if (funcOpnd == NULL ||
		nodeTag(funcOpnd) != T_Expr || funcOpnd->opType != FUNC_EXPR ||
		funcOpnd->oper == NULL || indexKeys == NULL)
		return false;
1408

1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
	function = (Func *) funcOpnd->oper;
	funcargs = funcOpnd->args;

	if (function->funcid != index->indproc)
		return false;

	/*
	 * Check that the arguments correspond to the same arguments used to
	 * create the functional index.  To do this we must check that 1.
	 * refer to the right relatiion. 2. the args have the right attr.
	 * numbers in the right order.
	 *
	 *
	 * Check all args refer to the correct relation (i.e. the one with the
	 * functional index defined on it (rel).  To do this we can simply
	 * compare range table entry numbers, they must be the same.
	 */
	foreach(arg, funcargs)
	{
		if (heapRelid != ((Var *) lfirst(arg))->varno)
			return false;
	}

	/*
	 * check attr numbers and order.
	 */
	i = 0;
	foreach(arg, funcargs)
	{

		if (indexKeys[i] == 0)
1440
			return false;
1441

1442
		if (((Var *) lfirst(arg))->varattno != indexKeys[i])
1443
			return false;
1444 1445 1446 1447 1448

		i++;
	}

	return true;
1449
}