/*-------------------------------------------------------------------------
 *
 * planner.c--
 *	  The query optimizer external interface.
 *
 * Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *	  $Header: /usr/local/cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.9 1997/09/08 21:45:27 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */
#include <sys/types.h>

#include "postgres.h"

#include "nodes/pg_list.h"
#include "nodes/plannodes.h"
#include "nodes/parsenodes.h"
#include "nodes/relation.h"

#include "parser/catalog_utils.h"
#include "parser/parse_query.h"
#include "utils/elog.h"
#include "utils/lsyscache.h"
#include "access/heapam.h"

#include "optimizer/internal.h"
#include "optimizer/planner.h"
#include "optimizer/plancat.h"
#include "optimizer/prep.h"
#include "optimizer/planmain.h"
#include "optimizer/paths.h"
#include "optimizer/cost.h"

/* DATA STRUCTURE CREATION/MANIPULATION ROUTINES */
#include "nodes/relation.h"
#include "optimizer/clauseinfo.h"
#include "optimizer/joininfo.h"
#include "optimizer/keys.h"
#include "optimizer/ordering.h"
#include "optimizer/pathnode.h"
#include "optimizer/clauses.h"
#include "optimizer/tlist.h"
#include "optimizer/var.h"

#include "executor/executor.h"

static Plan *make_sortplan(List *tlist, List *sortcls, Plan *plannode);
static Plan *init_query_planner(Query *parse);
static Existential *make_existential(Plan *left, Plan *right);

/*****************************************************************************
 *
 *	   Query optimizer entry point
 *
 *****************************************************************************/


/*
 * planner--
 *	  Main query optimizer routine.
 *
 *	  Invokes the planner on union queries if there are any left,
 *	  recursing if necessary to get them all, then processes normal plans.
 *
 * Returns a query plan.
 *
 */
Plan	   *
planner(Query *parse)
{
	List	   *tlist = parse->targetList;
	List	   *rangetable = parse->rtable;
	char	   *uniqueflag = parse->uniqueFlag;
	List	   *sortclause = parse->sortClause;
	Plan	   *special_plans = (Plan *) NULL;

	Plan	   *result_plan = (Plan *) NULL;

	int			rt_index;

	/*
	 * plan inheritance
	 */
	rt_index = first_matching_rt_entry(rangetable, INHERITS_FLAG);
	if (rt_index != -1)
	{
		special_plans = (Plan *) plan_union_queries((Index) rt_index,
													parse,
													INHERITS_FLAG);
	}

	/*
	 * plan archive queries
	 */
	rt_index = first_matching_rt_entry(rangetable, ARCHIVE_FLAG);
	if (rt_index != -1)
	{
		special_plans = (Plan *) plan_union_queries((Index) rt_index,
													parse,
													ARCHIVE_FLAG);
	}

	if (special_plans)
		result_plan = special_plans;
	else
		result_plan = init_query_planner(parse);		/* regular plans */

	/*
	 * For now, before we hand back the plan, check to see if there is a
	 * user-specified sort that needs to be done.  Eventually, this will
	 * be moved into the guts of the planner s.t. user specified sorts
	 * will be considered as part of the planning process. Since we can
	 * only make use of user-specified sorts in special cases, we can do
	 * the optimization step later.
	 */

	if (uniqueflag)
	{
		Plan	   *sortplan = make_sortplan(tlist, sortclause, result_plan);

		return ((Plan *) make_unique(tlist, sortplan, uniqueflag));
	}
	else
	{
		if (sortclause)
			return (make_sortplan(tlist, sortclause, result_plan));
		else
			return ((Plan *) result_plan);
	}

}

/*
 * make_sortplan--
 *	  Returns a sortplan which is basically a SORT node attached to the
 *	  top of the plan returned from the planner.  It also adds the
 *	   cost of sorting into the plan.
 *
 * sortkeys: ( resdom1 resdom2 resdom3 ...)
 * sortops:  (sortop1 sortop2 sortop3 ...)
 */
static Plan *
make_sortplan(List *tlist, List *sortcls, Plan *plannode)
{
	Plan	   *sortplan = (Plan *) NULL;
	List	   *temp_tlist = NIL;
	List	   *i = NIL;
	Resdom	   *resnode = (Resdom *) NULL;
	Resdom	   *resdom = (Resdom *) NULL;
	int			keyno = 1;

	/*
	 * First make a copy of the tlist so that we don't corrupt the the
	 * original .
	 */

	temp_tlist = new_unsorted_tlist(tlist);

	foreach(i, sortcls)
	{
		SortClause *sortcl = (SortClause *) lfirst(i);

		resnode = sortcl->resdom;
		resdom = tlist_resdom(temp_tlist, resnode);

		/*
		 * Order the resdom keys and replace the operator OID for each key
		 * with the regproc OID.
		 */
		resdom->reskey = keyno;
		resdom->reskeyop = get_opcode(sortcl->opoid);
		keyno += 1;
	}

	sortplan = (Plan *) make_sort(temp_tlist,
								  _TEMP_RELATION_ID_,
								  (Plan *) plannode,
								  length(sortcls));

	/*
	 * XXX Assuming that an internal sort has no. cost. This is wrong, but
	 * given that at this point, we don't know the no. of tuples returned,
	 * etc, we can't do better than to add a constant cost. This will be
	 * fixed once we move the sort further into the planner, but for now
	 * ... functionality....
	 */

	sortplan->cost = plannode->cost;

	return (sortplan);
}


/*
 * init-query-planner--
 *	  Deals with all non-union preprocessing, including existential
 *	  qualifications and CNFifying the qualifications.
 *
 * Returns a query plan.
 * MODIFIES: tlist,qual
 *
 */
static Plan *
init_query_planner(Query *root)
{
	List	   *primary_qual;
	List	   *existential_qual;
	Existential *exist_plan;
	List	   *tlist = root->targetList;

	tlist = preprocess_targetlist(tlist,
								  root->commandType,
								  root->resultRelation,
								  root->rtable);

	primary_qual =
		preprocess_qualification((Expr *) root->qual,
								 tlist,
								 &existential_qual);

	if (existential_qual == NULL)
	{
		return (query_planner(root,
							  root->commandType,
							  tlist,
							  primary_qual));
	}
	else
	{
		int			temp = root->commandType;
		Plan	   *existential_plan;

		root->commandType = CMD_SELECT;
		existential_plan = query_planner(root,
										 temp,
										 NIL,
										 existential_qual);

		exist_plan = make_existential(existential_plan,
									  query_planner(root,
													root->commandType,
													tlist,
													primary_qual));
		return ((Plan *) exist_plan);
	}
}

/*
 * make_existential--
 *	  Instantiates an existential plan node and fills in
 *	  the left and right subtree slots.
 */
static Existential *
make_existential(Plan *left, Plan *right)
{
	Existential *node = makeNode(Existential);

	node->lefttree = left;
	node->righttree = left;
	return (node);
}

/*
 * pg_checkretval() -- check return value of a list of sql parse
 *						trees.
 *
 * The return value of a sql function is the value returned by
 * the final query in the function.  We do some ad-hoc define-time
 * type checking here to be sure that the user is returning the
 * type he claims.
 */
void
pg_checkretval(Oid rettype, QueryTreeList *queryTreeList)
{
	Query	   *parse;
	List	   *tlist;
	List	   *rt;
	int			cmd;
	Type		typ;
	Resdom	   *resnode;
	Relation	reln;
	Oid			relid;
	Oid			tletype;
	int			relnatts;
	int			i;

	/* find the final query */
	parse = queryTreeList->qtrees[queryTreeList->len - 1];

	/*
	 * test 1:	if the last query is a utility invocation, then there had
	 * better not be a return value declared.
	 */
	if (parse->commandType == CMD_UTILITY)
	{
		if (rettype == InvalidOid)
			return;
		else
			elog(WARN, "return type mismatch in function decl: final query is a catalog utility");
	}

	/* okay, it's an ordinary query */
	tlist = parse->targetList;
	rt = parse->rtable;
	cmd = parse->commandType;

	/*
	 * test 2:	if the function is declared to return no value, then the
	 * final query had better not be a retrieve.
	 */
	if (rettype == InvalidOid)
	{
		if (cmd == CMD_SELECT)
			elog(WARN,
				 "function declared with no return type, but final query is a retrieve");
		else
			return;
	}

	/* by here, the function is declared to return some type */
	if ((typ = (Type) get_id_type(rettype)) == NULL)
		elog(WARN, "can't find return type %d for function\n", rettype);

	/*
	 * test 3:	if the function is declared to return a value, then the
	 * final query had better be a retrieve.
	 */
	if (cmd != CMD_SELECT)
		elog(WARN, "function declared to return type %s, but final query is not a retrieve", tname(typ));

	/*
	 * test 4:	for base type returns, the target list should have exactly
	 * one entry, and its type should agree with what the user declared.
	 */

	if (get_typrelid(typ) == InvalidOid)
	{
		if (exec_tlist_length(tlist) > 1)
			elog(WARN, "function declared to return %s returns multiple values in final retrieve", tname(typ));

		resnode = (Resdom *) ((TargetEntry *) lfirst(tlist))->resdom;
		if (resnode->restype != rettype)
			elog(WARN, "return type mismatch in function: declared to return %s, returns %s", tname(typ), tname(get_id_type(resnode->restype)));

		/* by here, base return types match */
		return;
	}

	/*
	 * If the target list is of length 1, and the type of the varnode in
	 * the target list is the same as the declared return type, this is
	 * okay.  This can happen, for example, where the body of the function
	 * is 'retrieve (x = func2())', where func2 has the same return type
	 * as the function that's calling it.
	 */
	if (exec_tlist_length(tlist) == 1)
	{
		resnode = (Resdom *) ((TargetEntry *) lfirst(tlist))->resdom;
		if (resnode->restype == rettype)
			return;
	}

	/*
	 * By here, the procedure returns a (set of) tuples.  This part of the
	 * typechecking is a hack.	We look up the relation that is the
	 * declared return type, and be sure that attributes 1 .. n in the
	 * target list match the declared types.
	 */
	reln = heap_open(get_typrelid(typ));

	if (!RelationIsValid(reln))
		elog(WARN, "cannot open relation relid %d", get_typrelid(typ));

	relid = reln->rd_id;
	relnatts = reln->rd_rel->relnatts;

	if (exec_tlist_length(tlist) != relnatts)
		elog(WARN, "function declared to return type %s does not retrieve (%s.*)", tname(typ), tname(typ));

	/* expect attributes 1 .. n in order */
	for (i = 1; i <= relnatts; i++)
	{
		TargetEntry *tle = lfirst(tlist);
		Node	   *thenode = tle->expr;

		tlist = lnext(tlist);
		tletype = exprType(thenode);

#if 0							/* fix me */
		/* this is tedious */
		if (IsA(thenode, Var))
			tletype = (Oid) ((Var *) thenode)->vartype;
		else if (IsA(thenode, Const))
			tletype = (Oid) ((Const *) thenode)->consttype;
		else if (IsA(thenode, Param))
			tletype = (Oid) ((Param *) thenode)->paramtype;
		else if (IsA(thenode, Expr))
			tletype = Expr;

		else if (IsA(thenode, LispList))
		{
			thenode = lfirst(thenode);
			if (IsA(thenode, Oper))
				tletype = (Oid) get_opresulttype((Oper *) thenode);
			else if (IsA(thenode, Func))
				tletype = (Oid) get_functype((Func *) thenode);
			else
				elog(WARN, "function declared to return type %s does not retrieve (%s.all)", tname(typ), tname(typ));
		}
		else
			elog(WARN, "function declared to return type %s does not retrieve (%s.all)", tname(typ), tname(typ));
#endif
		/* reach right in there, why don't you? */
		if (tletype != reln->rd_att->attrs[i - 1]->atttypid)
			elog(WARN, "function declared to return type %s does not retrieve (%s.all)", tname(typ), tname(typ));
	}

	heap_close(reln);

	/* success */
	return;
}