/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*-------------------------------------------------------------------------
 *
 * planmain.h
 *	  prototypes for various files in optimizer/plan
 *
 *
 * Portions Copyright (c) 2005-2009, Greenplum inc
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * $PostgreSQL: pgsql/src/include/optimizer/planmain.h,v 1.94 2006/07/26 00:34:48 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */
#ifndef PLANMAIN_H
#define PLANMAIN_H

#include "nodes/plannodes.h"
#include "nodes/relation.h"
#include "optimizer/clauses.h" /* AggClauseCounts */
#include "utils/uri.h"

/* GUC parameters */
#define DEFAULT_CURSOR_TUPLE_FRACTION 1.0 /* assume all rows will be fetched */
extern double cursor_tuple_fraction;

/*
 * A structure that contains information for planning GROUP BY 
 * queries.
 */
typedef struct GroupContext
{
	Path *best_path;
	Path *cheapest_path;

	/*
	 * If subplan is given, use it (including its targetlist).  
	 *
	 * If sub_tlist and no subplan is given, then use sub_tlist
	 * on the input plan. (This is intended to  assure that targets 
	 * that appear in the SortClauses of AggOrder  nodes have targets 
	 * in the subplan that match in sortgroupref.
	 *
	 * If neither subplan nor sub_tlist is given, just make a plan with
	 * a flat target list.
	 */
	Plan *subplan;
	List *sub_tlist;

	List *tlist;
	bool use_hashed_grouping;
	double tuple_fraction;
	CanonicalGroupingSets *canonical_grpsets;
	uint64 grouping;

	/*
	 * When subplan is privided, groupColIdx and distinctColIdx are also provided.
	 */
	int numGroupCols;
	AttrNumber *groupColIdx;
	int numDistinctCols;
	AttrNumber *distinctColIdx;

	double *p_dNumGroups;
	List **pcurrent_pathkeys;
	bool *querynode_changed;
} GroupContext;

/*
 * prototypes for plan/planmain.c
 */
extern void query_planner(PlannerInfo *root, List *tlist,
			  double tuple_fraction,
			  Path **cheapest_path, Path **sorted_path,
			  double *num_groups);

/*
 * prototypes for plan/planagg.c
 */
extern Plan *optimize_minmax_aggregates(PlannerInfo *root, List *tlist,
						   Path *best_path);

/*
 * prototype for plan/plangroupexp.c
 */
extern Plan *make_distinctaggs_for_rollup(PlannerInfo *root, bool is_agg,
										  List *tlist, bool twostage, List *sub_tlist,
										  List *qual, AggStrategy aggstrategy,
										  int numGroupCols, AttrNumber *grpColIdx,
										  double numGroups, int *rollup_gs_times,
										  int numAggs, int transSpace,
										  double *p_dNumGroups,
										  List **p_current_pathkeys,
										  Plan *lefttree);

/*
 * prototypes for plan/planwindow.c
 */
extern Plan *window_planner(PlannerInfo *root, double tuple_fraction, List **pathkeys_ptr);
extern RangeTblEntry *package_plan_as_rte(Query *query, Plan *plan, Alias *eref, List *pathkeys);
extern Value *get_tle_name(TargetEntry *tle, List* rtable, const char *default_name);
extern bool contain_windowref(Node *node, void *context);
extern bool window_edge_is_delayed(WindowFrameEdge *edge);
extern Plan *wrap_plan(PlannerInfo *root, Plan *plan, Query *query, List **p_pathkeys,
       const char *alias_name, List *col_names, Query **query_p);


/*
 * prototype for plan/plangroupexp.c
 */
extern Plan *plan_grouping_extension(PlannerInfo *root,
									 Path *path,
									 double tuple_fraction,
									 bool use_hashed_grouping,
									 List **p_tlist, List *sub_tlist,
									 bool is_agg, bool twostage,
									 List *qual,
									 int *p_numGroupCols, AttrNumber **p_grpColIdx,
									 AggClauseCounts *agg_counts,
									 CanonicalGroupingSets *canonical_grpsets,
									 double *p_dNumGroups,
									 bool *querynode_changed,
									 List **p_current_pathkeys,
									 Plan *lefttree);
extern void free_canonical_groupingsets(CanonicalGroupingSets *canonical_grpsets);
extern Plan *add_repeat_node(Plan *result_plan, int repeat_count, uint64 grouping);

/*
 * prototypes for plan/createplan.c
 */
extern Plan *create_plan(PlannerInfo *root, Path *path);
extern bool is_pxf_protocol(Uri *uri);
extern int pxf_calc_participating_segments(int total_segments);

extern SubqueryScan *make_subqueryscan(PlannerInfo *root, List *qptlist, List *qpqual,
				  Index scanrelid, Plan *subplan, List *subrtable);
extern Append *make_append(List *appendplans, bool isTarget, List *tlist);
extern Sort *make_sort_from_sortclauses(PlannerInfo *root, List *sortcls,
						   Plan *lefttree);
extern Sort *make_sort_from_groupcols(PlannerInfo *root, List *groupcls,
									  AttrNumber *grpColIdx, bool appendGrouping,
									  Plan *lefttree);
extern Sort *make_sort_from_reordered_groupcols(PlannerInfo *root,
												List *groupcls,
												AttrNumber *orig_grpColIdx,
												AttrNumber *new_grpColIdx,
												TargetEntry *grouping,
												TargetEntry *groupid,
												int req_ngrpkeys,
												Plan *lefttree);
extern List *reconstruct_group_clause(List *orig_groupClause, List *tlist,
									  AttrNumber *grpColIdx, int numcols);

extern Agg *make_agg(PlannerInfo *root, List *tlist, List *qual,
					 AggStrategy aggstrategy, bool streaming,
					 int numGroupCols, AttrNumber *grpColIdx,
					 long numGroups, int numNullCols,
					 uint64 inputGrouping, uint64 grouping,
					 int rollupGSTimes,
					 int numAggs, int transSpace,
					 Plan *lefttree);
extern HashJoin *make_hashjoin(List *tlist,
			  List *joinclauses, List *otherclauses,
			  List *hashclauses, List *hashqualclauses,
			  Plan *lefttree, Plan *righttree,
			  JoinType jointype);
extern Hash *make_hash(Plan *lefttree);
extern NestLoop *make_nestloop(List *tlist,
							   List *joinclauses, List *otherclauses,
							   Plan *lefttree, Plan *righttree,
							   JoinType jointype);
extern MergeJoin *make_mergejoin(List *tlist,
			   List *joinclauses, List *otherclauses,
			   List *mergeclauses,
			   Plan *lefttree, Plan *righttree,
			   JoinType jointype);
extern Window *make_window(PlannerInfo *root, List *tlist,
		   int numPartCols, AttrNumber *partColIdx, List *windowKeys,
		   Plan *lefttree);
extern Material *make_material(Plan *lefttree);
extern Plan *materialize_finished_plan(PlannerInfo *root, Plan *subplan);
extern Unique *make_unique(Plan *lefttree, List *distinctList);
extern Limit *make_limit(Plan *lefttree, Node *limitOffset, Node *limitCount,
		   int64 offset_est, int64 count_est);
extern SetOp *make_setop(SetOpCmd cmd, Plan *lefttree,
		   List *distinctList, AttrNumber flagColIdx);
extern Result *make_result(List *tlist, Node *resconstantqual, Plan *subplan);
extern Repeat *make_repeat(List *tlist,
						   List *qual,
						   Expr *repeatCountExpr,
						   uint64 grouping,
						   Plan *subplan);
extern bool is_projection_capable_plan(Plan *plan);
extern Sort *make_sort_from_pathkeys(PlannerInfo *root, Plan *lefttree,
                                     List *pathkeys, Relids relids,
                                     bool add_keys_to_targetlist);
extern Plan *add_sort_cost(PlannerInfo *root, Plan *input, 
						   int numCols, 
						   AttrNumber *sortColIdx, Oid *sortOperators);
extern Plan *add_agg_cost(PlannerInfo *root, Plan *plan, 
		 List *tlist, List *qual,
		 AggStrategy aggstrategy, 
		 bool streaming, 
		 int numGroupCols, AttrNumber *grpColIdx,
		 long numGroups, int num_nullcols,
		 int numAggs, int transSpace);
extern Plan *plan_pushdown_tlist(Plan *plan, List *tlist);      /*CDB*/

/*
 * prototypes for plan/initsplan.c
 */
extern int	from_collapse_limit;
extern int	join_collapse_limit;

extern void add_base_rels_to_query(PlannerInfo *root, Node *jtnode);
extern void build_base_rel_tlists(PlannerInfo *root, List *final_tlist);
extern void add_IN_vars_to_tlists(PlannerInfo *root);
extern List *deconstruct_jointree(PlannerInfo *root);
extern void process_implied_equality(PlannerInfo *root,
						 Node *item1, Node *item2,
						 Oid sortop1, Oid sortop2,
						 Relids item1_relids, Relids item2_relids,
						 bool delete_it);
extern void distribute_qual_to_rels(PlannerInfo *root, Node *clause,
						bool is_deduced,
						bool is_deduced_but_not_equijoin,
						bool below_outer_join,
						Relids qualscope,
						Relids ojscope,
						Relids outerjoin_nonnullable,
						List **ptrToLocalEquiKeyList,
						List **postponed_qual_list);


/*
 * prototypes for plan/setrefs.c
 */
Plan *
set_plan_references(PlannerGlobal *glob, Plan *plan, List *rtable);

List *
set_returning_clause_references(PlannerGlobal *glob,
								List *rlist,
								Plan *topplan,
								Index resultRelation);

extern void
extract_query_dependencies(List *queries,
						   List **relationOids,
						   List **invalItems);
extern void fix_opfuncids(Node *node);
extern void set_opfuncid(OpExpr *opexpr);

extern int num_distcols_in_grouplist(List *gc);

#endif   /* PLANMAIN_H */