diff options
Diffstat (limited to 'src/backend/executor')
22 files changed, 0 insertions, 1255 deletions
diff --git a/src/backend/executor/execFlatten.h b/src/backend/executor/execFlatten.h deleted file mode 100644 index fe06823619f..00000000000 --- a/src/backend/executor/execFlatten.h +++ /dev/null @@ -1,26 +0,0 @@ -/*------------------------------------------------------------------------- - * - * execFlatten.h-- - * prototypes for execFlatten.c. - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: execFlatten.h,v 1.1.1.1 1996/07/09 06:21:24 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef EXECFLATTEN_H -#define EXECFLATTEN_H - -extern Datum ExecEvalIter(Iter *iterNode, ExprContext *econtext, bool *resultIsNull, bool *iterIsDone); - -extern void ExecEvalFjoin(TargetEntry *tlist, ExprContext *econtext, bool *isNullVect, bool *fj_isDone); - -extern bool FjoinBumpOuterNodes(TargetEntry *tlist, ExprContext *econtext, DatumPtr results, char *nulls); - - -#endif /* EXECFLATTEN_H */ - - - diff --git a/src/backend/executor/execdebug.h b/src/backend/executor/execdebug.h deleted file mode 100644 index b5200ca2577..00000000000 --- a/src/backend/executor/execdebug.h +++ /dev/null @@ -1,377 +0,0 @@ -/*------------------------------------------------------------------------- - * - * execdebug.h-- - * #defines governing debugging behaviour in the executor - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: execdebug.h,v 1.1.1.1 1996/07/09 06:21:25 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef EXECDEBUG_H -#define EXECDEBUG_H - -/* ---------------------------------------------------------------- - * debugging defines. - * - * If you want certain debugging behaviour, then #define - * the variable to 1, else #undef it. -cim 10/26/89 - * ---------------------------------------------------------------- - */ - -/* ---------------- - * EXEC_DEBUGSTORETUP is for tuple table debugging - this - * will print a message every time we call ExecStoreTuple. - * -cim 3/20/91 - * ---------------- - */ -#undef EXEC_DEBUGSTORETUP - -/* ---------------- - * EXEC_TUPLECOUNT is a #define which causes the - * executor keep track of tuple counts. This might be - * causing some problems with the decstation stuff so - * you might want to undefine this if you are doing work - * on the decs - cim 10/20/89 - * ---------------- - */ -#undef EXEC_TUPLECOUNT - -/* ---------------- - * EXEC_SHOWBUFSTATS controls whether or not buffer statistics - * are shown for each query. -cim 2/9/89 - * ---------------- - */ -#undef EXEC_SHOWBUFSTATS - -/* ---------------- - * EXEC_CONTEXTDEBUG turns on the printing of debugging information - * by CXT_printf() calls regarding which memory context is the - * CurrentMemoryContext for palloc() calls. - * ---------------- - */ -#undef EXEC_CONTEXTDEBUG - -/* ---------------- - * EXEC_RETURNSIZE is a compile flag governing the - * behaviour of lispFmgr.. See ExecMakeFunctionResult(). - * Undefining this avoids a problem in the system cache. - * - * Note: undefining this means that there is incorrect - * information in the const nodes corresponding - * to function (or operator) results. The thing is, - * 99% of the time this is fine because when you do - * something like x = emp.sal + 1, you already know - * the type and size of x so the fact that + didn't - * return the correct size doesn't matter. - * With variable length stuff the size is stored in - * the first few bytes of the data so again, it's - * not likely to matter. - * ---------------- - */ -#undef EXEC_RETURNSIZE - -/* ---------------- - * EXEC_UTILSDEBUG is a flag which turns on debugging of the - * executor utilities by EU_printf() in eutils.c - * ---------------- - */ -#undef EXEC_UTILSDEBUG - -/* ---------------- - * EXEC_NESTLOOPDEBUG is a flag which turns on debugging of the - * nest loop node by NL_printf() and ENL_printf() in nestloop.c - * ---------------- - */ -#undef EXEC_NESTLOOPDEBUG - -/* ---------------- - * EXEC_PROCDEBUG is a flag which turns on debugging of - * ExecProcNode() by PN_printf() in procnode.c - * ---------------- - */ -#undef EXEC_PROCDEBUG - -/* ---------------- - * EXEC_EVALDEBUG is a flag which turns on debugging of - * ExecEval and ExecTargetList() stuff by EV_printf() in qual.c - * ---------------- - */ -#undef EXEC_EVALDEBUG - -/* ---------------- - * EXEC_SCANDEBUG is a flag which turns on debugging of - * the ExecSeqScan() stuff by S_printf() in seqscan.c - * ---------------- - */ -#undef EXEC_SCANDEBUG - -/* ---------------- - * EXEC_SORTDEBUG is a flag which turns on debugging of - * the ExecSort() stuff by SO_printf() in sort.c - * ---------------- - */ -#undef EXEC_SORTDEBUG - -/* ---------------- - * EXEC_MERGEJOINDEBUG is a flag which turns on debugging of - * the ExecMergeJoin() stuff by MJ_printf() in mergejoin.c - * ---------------- - */ -#undef EXEC_MERGEJOINDEBUG - -/* ---------------- - * EXEC_MERGEJOINPFREE is a flag which causes merge joins - * to pfree intermittant tuples (which is the proper thing) - * Not defining this means we avoid menory management problems - * at the cost of doing deallocation of stuff only at the - * end of the transaction - * ---------------- - */ -#undef EXEC_MERGEJOINPFREE - -/* ---------------- - * EXEC_DEBUGINTERACTIVE is a flag which enables the - * user to issue "DEBUG" commands from an interactive - * backend. - * ---------------- - */ -#undef EXEC_DEBUGINTERACTIVE - -/* ---------------- - * EXEC_DEBUGVARIABLEFILE is string, which if defined will - * be loaded when the executor is initialized. If this - * string is not defined then nothing will be loaded.. - * - * Example: - * - * #define EXEC_DEBUGVARIABLEFILE "/a/postgres/cimarron/.pg_debugvars" - # - * Note: since these variables are read at execution time, - * they can't affect the first query.. this hack should be - * replaced by something better sometime. -cim 11/2/89 - * ---------------- - */ -#undef EXEC_DEBUGVARIABLEFILE - -/* ---------------------------------------------------------------- - * #defines controlled by above definitions - * - * Note: most of these are "incomplete" because I didn't - * need the ones not defined. More should be added - * only as necessary -cim 10/26/89 - * ---------------------------------------------------------------- - */ -#define T_OR_F(b) (b ? "true" : "false") -#define NULL_OR_TUPLE(slot) (TupIsNull(slot) ? "null" : "a tuple") - - -/* #define EXEC_TUPLECOUNT - XXX take out for now for executor stubbing -- jolly*/ -/* ---------------- - * tuple count debugging defines - * ---------------- - */ -#ifdef EXEC_TUPLECOUNT -extern int NTupleProcessed; -extern int NTupleRetrieved; -extern int NTupleReplaced; -extern int NTupleAppended; -extern int NTupleDeleted; -extern int NIndexTupleProcessed; -extern int NIndexTupleInserted; - -#define IncrRetrieved() NTupleRetrieved++ -#define IncrAppended() NTupleAppended++ -#define IncrDeleted() NTupleDeleted++ -#define IncrReplaced() NTupleReplaced++ -#define IncrInserted() NTupleInserted++ -#define IncrProcessed() NTupleProcessed++ -#define IncrIndexProcessed() NIndexTupleProcessed++ -#define IncrIndexInserted() NIndexTupleInserted++ -#else -#define IncrRetrieved() -#define IncrAppended() -#define IncrDeleted() -#define IncrReplaced() -#define IncrInserted() -#define IncrProcessed() -#define IncrIndexProcessed() -#define IncrIndexInserted() -#endif /* EXEC_TUPLECOUNT */ - -/* ---------------- - * memory context debugging defines - * ---------------- - */ -#ifdef EXEC_CONTEXTDEBUG -#define CXT_printf(s) printf(s) -#define CXT1_printf(s, a) printf(s, a) -#else -#define CXT_printf(s) -#define CXT1_printf(s, a) -#endif /* EXEC_CONTEXTDEBUG */ - -/* ---------------- - * eutils debugging defines - * ---------------- - */ -#ifdef EXEC_UTILSDEBUG -#define EU_nodeDisplay(l) nodeDisplay(l, 0) -#define EU_printf(s) printf(s) -#define EU1_printf(s, a) printf(s, a) -#define EU4_printf(s, a, b, c, d) printf(s, a, b, c, d) -#else -#define EU_nodeDisplay(l) -#define EU_printf(s) -#define EU1_printf(s, a) -#define EU4_printf(s, a, b, c, d) -#endif /* EXEC_UTILSDEBUG */ - - -/* ---------------- - * nest loop debugging defines - * ---------------- - */ -#ifdef EXEC_NESTLOOPDEBUG -#define NL_nodeDisplay(l) nodeDisplay(l, 0) -#define NL_printf(s) printf(s) -#define NL1_printf(s, a) printf(s, a) -#define NL4_printf(s, a, b, c, d) printf(s, a, b, c, d) -#define ENL1_printf(message) printf("ExecNestLoop: %s\n", message) -#else -#define NL_nodeDisplay(l) -#define NL_printf(s) -#define NL1_printf(s, a) -#define NL4_printf(s, a, b, c, d) -#define ENL1_printf(message) -#endif /* EXEC_NESTLOOPDEBUG */ - -/* ---------------- - * proc node debugging defines - * ---------------- - */ -#ifdef EXEC_PROCDEBUG -#define PN_printf(s) printf(s) -#define PN1_printf(s, p) printf(s, p) -#else -#define PN_printf(s) -#define PN1_printf(s, p) -#endif /* EXEC_PROCDEBUG */ - -/* ---------------- - * exec eval / target list debugging defines - * ---------------- - */ -#ifdef EXEC_EVALDEBUG -#define EV_nodeDisplay(l) nodeDisplay(l, 0) -#define EV_printf(s) printf(s) -#define EV1_printf(s, a) printf(s, a) -#define EV5_printf(s, a, b, c, d, e) printf(s, a, b, c, d, e) -#else -#define EV_nodeDisplay(l) -#define EV_printf(s) -#define EV1_printf(s, a) -#define EV5_printf(s, a, b, c, d, e) -#endif /* EXEC_EVALDEBUG */ - -/* ---------------- - * scan debugging defines - * ---------------- - */ -#ifdef EXEC_SCANDEBUG -#define S_nodeDisplay(l) nodeDisplay(l, 0) -#define S_printf(s) printf(s) -#define S1_printf(s, p) printf(s, p) -#else -#define S_nodeDisplay(l) -#define S_printf(s) -#define S1_printf(s, p) -#endif /* EXEC_SCANDEBUG */ - -/* ---------------- - * sort node debugging defines - * ---------------- - */ -#ifdef EXEC_SORTDEBUG -#define SO_nodeDisplay(l) nodeDisplay(l, 0) -#define SO_printf(s) printf(s) -#define SO1_printf(s, p) printf(s, p) -#else -#define SO_nodeDisplay(l) -#define SO_printf(s) -#define SO1_printf(s, p) -#endif /* EXEC_SORTDEBUG */ - -/* ---------------- - * merge join debugging defines - * ---------------- - */ -#ifdef EXEC_MERGEJOINDEBUG -#define MJ_nodeDisplay(l) nodeDisplay(l, 0) -#define MJ_printf(s) printf(s) -#define MJ1_printf(s, p) printf(s, p) -#define MJ2_printf(s, p1, p2) printf(s, p1, p2) -#define MJ_debugtup(tuple, type) debugtup(tuple, type) -#define MJ_dump(context, state) ExecMergeTupleDump(econtext, state) -#define MJ_DEBUG_QUAL(clause, res) \ - MJ2_printf(" ExecQual(%s, econtext) returns %s\n", \ - CppAsString(clause), T_OR_F(res)); - -#define MJ_DEBUG_MERGE_COMPARE(qual, res) \ - MJ2_printf(" MergeCompare(mergeclauses, %s, ..) returns %s\n", \ - CppAsString(qual), T_OR_F(res)); - -#define MJ_DEBUG_PROC_NODE(slot) \ - MJ2_printf(" %s = ExecProcNode(innerPlan) returns %s\n", \ - CppAsString(slot), NULL_OR_TUPLE(slot)); -#else -#define MJ_nodeDisplay(l) -#define MJ_printf(s) -#define MJ1_printf(s, p) -#define MJ2_printf(s, p1, p2) -#define MJ_debugtup(tuple, type) -#define MJ_dump(context, state) -#define MJ_DEBUG_QUAL(clause, res) -#define MJ_DEBUG_MERGE_COMPARE(qual, res) -#define MJ_DEBUG_PROC_NODE(slot) -#endif /* EXEC_MERGEJOINDEBUG */ - -/* ---------------------------------------------------------------- - * DO NOT DEFINE THESE EVER OR YOU WILL BURN! - * ---------------------------------------------------------------- - */ -/* ---------------- - * DOESNOTWORK is currently placed around memory manager - * code that is known to cause problems. Code in between - * is likely not converted and probably won't work anyways. - * ---------------- - */ -#undef DOESNOTWORK - -/* ---------------- - * PERHAPSNEVER is placed around the "scan attribute" - * support code for the rule manager because for now we - * do things inefficiently. The correct solution to our - * problem is to add code to the parser/planner to save - * attribute information for the rule manager rather than - * have the executor have to grope through the entire plan - * for it so if we ever decide to make things better, - * we should probably delete the stuff in between PERHAPSNEVER.. - * ---------------- - */ -#undef PERHAPSNEVER - -/* ---------------- - * NOTYET is placed around any code not yet implemented - * in the executor. Only remove these when actually implementing - * said code. - * ---------------- - */ -#undef NOTYET - -extern long NDirectFileRead; -extern long NDirectFileWrite; - -#endif /* ExecDebugIncluded */ diff --git a/src/backend/executor/execdefs.h b/src/backend/executor/execdefs.h deleted file mode 100644 index b0101bdbe40..00000000000 --- a/src/backend/executor/execdefs.h +++ /dev/null @@ -1,47 +0,0 @@ -/*------------------------------------------------------------------------- - * - * execdefs.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: execdefs.h,v 1.2 1996/07/30 07:45:29 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef EXECDEFS_H -#define EXECDEFS_H - -/* ---------------- - * ExecutePlan() tuplecount definitions - * ---------------- - */ -#define ALL_TUPLES 0 /* return all tuples */ -#define ONE_TUPLE 1 /* return only one tuple */ - -/* ---------------- - * constants used by ExecMain - * ---------------- - */ -#define EXEC_RUN 3 -#define EXEC_FOR 4 -#define EXEC_BACK 5 -#define EXEC_RETONE 6 -#define EXEC_RESULT 7 - -/* ---------------- - * Merge Join states - * ---------------- - */ -#define EXEC_MJ_INITIALIZE 1 -#define EXEC_MJ_JOINMARK 2 -#define EXEC_MJ_JOINTEST 3 -#define EXEC_MJ_JOINTUPLES 4 -#define EXEC_MJ_NEXTOUTER 5 -#define EXEC_MJ_TESTOUTER 6 -#define EXEC_MJ_NEXTINNER 7 -#define EXEC_MJ_SKIPINNER 8 -#define EXEC_MJ_SKIPOUTER 9 - -#endif /* EXECDEFS_H */ diff --git a/src/backend/executor/execdesc.h b/src/backend/executor/execdesc.h deleted file mode 100644 index 54752625f55..00000000000 --- a/src/backend/executor/execdesc.h +++ /dev/null @@ -1,38 +0,0 @@ -/*------------------------------------------------------------------------- - * - * execdesc.h-- - * plan and query descriptor accessor macros used by the executor - * and related modules. - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: execdesc.h,v 1.1.1.1 1996/07/09 06:21:25 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef EXECDESC_H -#define EXECDESC_H - -#include "nodes/parsenodes.h" -#include "nodes/plannodes.h" -#include "tcop/dest.h" - -/* ---------------- - * query descriptor: - * a QueryDesc encapsulates everything that the executor - * needs to execute the query - * --------------------- - */ -typedef struct QueryDesc { - CmdType operation; /* CMD_SELECT, CMD_UPDATE, etc. */ - Query *parsetree; - Plan *plantree; - CommandDest dest; /* the destination output of the execution */ -} QueryDesc; - -/* in pquery.c */ -extern QueryDesc *CreateQueryDesc(Query *parsetree, Plan *plantree, - CommandDest dest); - -#endif /* EXECDESC_H */ diff --git a/src/backend/executor/executor.h b/src/backend/executor/executor.h deleted file mode 100644 index 65caf098f13..00000000000 --- a/src/backend/executor/executor.h +++ /dev/null @@ -1,229 +0,0 @@ -/*------------------------------------------------------------------------- - * - * executor.h-- - * support for the POSTGRES executor module - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: executor.h,v 1.1.1.1 1996/07/09 06:21:25 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef EXECUTOR_H -#define EXECUTOR_H - -/* ---------------------------------------------------------------- - * #includes - * ---------------------------------------------------------------- - */ -#include <stdio.h> -#include <string.h> - -#include "postgres.h" -#include "nodes/pg_list.h" - -/* ---------------- - * executor debugging definitions are kept in a separate file - * so people can customize what debugging they want to see and not - * have this information clobbered every time a new version of - * executor.h is checked in -cim 10/26/89 - * ---------------- - */ -#include "executor/execdebug.h" - -#include "access/heapam.h" -#include "access/htup.h" -#include "access/istrat.h" -#include "access/itup.h" -#include "access/skey.h" -#include "utils/tqual.h" -#include "catalog/catname.h" -#include "utils/syscache.h" -#include "executor/execdefs.h" -#include "executor/tuptable.h" - -#include "nodes/parsenodes.h" - -#include "storage/buf.h" -#include "miscadmin.h" -#include "fmgr.h" -#include "utils/elog.h" -#include "utils/mcxt.h" -#include "utils/memutils.h" -#include "utils/rel.h" - -#include "catalog/pg_index.h" -#include "catalog/pg_proc.h" -#include "catalog/pg_type.h" -#include "catalog/pg_aggregate.h" - -#include "access/printtup.h" -#include "nodes/primnodes.h" -#include "nodes/plannodes.h" -#include "nodes/execnodes.h" - -#include "tcop/dest.h" -#include "storage/smgr.h" - -#include "access/genam.h" -#include "executor/execdesc.h" - -/* - * prototypes from functions in execAmi.c - */ -extern void ExecOpenScanR(Oid relOid, int nkeys, ScanKey skeys, bool isindex, - ScanDirection dir, TimeQual timeRange, - Relation *returnRelation, Pointer *returnScanDesc); -extern Relation ExecOpenR(Oid relationOid, bool isindex); -extern Pointer ExecBeginScan(Relation relation, int nkeys, ScanKey skeys, - bool isindex, ScanDirection dir, TimeQual time_range); -extern void ExecCloseR(Plan *node); -extern void ExecReScan(Plan *node, ExprContext *exprCtxt, Plan *parent); -extern HeapScanDesc ExecReScanR(Relation relDesc, HeapScanDesc scanDesc, - ScanDirection direction, int nkeys, ScanKey skeys); -extern void ExecMarkPos(Plan *node); -extern void ExecRestrPos(Plan *node); -extern Relation ExecCreatR(TupleDesc tupType, Oid relationOid); - -/* - * prototypes from functions in execJunk.c - */ -extern JunkFilter *ExecInitJunkFilter(List *targetList); -extern bool ExecGetJunkAttribute(JunkFilter *junkfilter, TupleTableSlot *slot, - char *attrName, Datum *value, bool *isNull); -extern HeapTuple ExecRemoveJunk(JunkFilter *junkfilter, TupleTableSlot *slot); - - -/* - * prototypes from functions in execMain.c - */ -extern TupleDesc ExecutorStart(QueryDesc *queryDesc, EState *estate); -extern TupleTableSlot* ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, int count); -extern void ExecutorEnd(QueryDesc *queryDesc, EState *estate); - -/* - * prototypes from functions in execProcnode.c - */ -extern bool ExecInitNode(Plan *node, EState *estate, Plan *parent); -extern TupleTableSlot *ExecProcNode(Plan *node, Plan *parent); -extern int ExecCountSlotsNode(Plan *node); -extern void ExecEndNode(Plan *node, Plan *parent); - -/* - * prototypes from functions in execQual.c - */ -extern bool execConstByVal; -extern int execConstLen; - -extern Datum ExecExtractResult(TupleTableSlot *slot, AttrNumber attnum, - bool *isNull); -extern Datum ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull); -extern Datum ExecEvalParam(Param *expression, ExprContext *econtext, - bool *isNull); -extern char *GetAttributeByNum(TupleTableSlot *slot, AttrNumber attrno, - bool *isNull); -extern char *att_by_num(TupleTableSlot *slot, AttrNumber attrno, - bool *isNull); -/* stop here */ -extern char *GetAttributeByName(TupleTableSlot *slot, char *attname, - bool *isNull); -extern char *att_by_name(TupleTableSlot *slot, char *attname, bool *isNull); -extern void ExecEvalFuncArgs(FunctionCachePtr fcache, ExprContext *econtext, - List *argList, Datum argV[], bool *argIsDone); -extern Datum ExecMakeFunctionResult(Node *node, List *arguments, - ExprContext *econtext, bool *isNull, bool *isDone); -extern Datum ExecEvalOper(Expr *opClause, ExprContext *econtext, - bool *isNull); -extern Datum ExecEvalFunc(Expr *funcClause, ExprContext *econtext, - bool *isNull, bool *isDone); -extern Datum ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull); -extern Datum ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull); -extern Datum ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull); -extern Datum ExecEvalExpr(Node *expression, ExprContext *econtext, bool *isNull, - bool *isDone); -extern bool ExecQualClause(Node *clause, ExprContext *econtext); -extern bool ExecQual(List *qual, ExprContext *econtext); -extern int ExecTargetListLength(List *targetlist); -extern TupleTableSlot *ExecProject(ProjectionInfo *projInfo, bool *isDone); - -/* - * prototypes from functions in execScan.c - */ -extern TupleTableSlot *ExecScan(Scan *node, TupleTableSlot* (*accessMtd)()); - -/* - * prototypes from functions in execTuples.c - */ -extern TupleTable ExecCreateTupleTable(int initialSize); -extern void ExecDestroyTupleTable(TupleTable table, bool shouldFree); -extern TupleTableSlot* ExecAllocTableSlot(TupleTable table); -extern TupleTableSlot* ExecStoreTuple(HeapTuple tuple, - TupleTableSlot *slot, - Buffer buffer, - bool shouldFree); -extern TupleTableSlot* ExecClearTuple(TupleTableSlot* slot); -extern bool ExecSlotPolicy(TupleTableSlot *slot); -extern bool ExecSetSlotPolicy(TupleTableSlot *slot, bool shouldFree); -extern TupleDesc ExecSetSlotDescriptor(TupleTableSlot *slot, - TupleDesc tupdesc); -extern void ExecSetSlotDescriptorIsNew(TupleTableSlot *slot, bool isNew); -extern TupleDesc ExecSetNewSlotDescriptor(TupleTableSlot *slot, - TupleDesc tupdesc); -extern Buffer ExecSetSlotBuffer(TupleTableSlot *slot, Buffer b); -extern void ExecIncrSlotBufferRefcnt(TupleTableSlot *slot); -extern bool TupIsNull(TupleTableSlot* slot); -extern bool ExecSlotDescriptorIsNew(TupleTableSlot *slot); -extern void ExecInitResultTupleSlot(EState *estate, CommonState *commonstate); -extern void ExecInitScanTupleSlot(EState *estate, - CommonScanState *commonscanstate); -extern void ExecInitMarkedTupleSlot(EState *estate, MergeJoinState *mergestate); -extern void ExecInitOuterTupleSlot(EState *estate, HashJoinState *hashstate); -extern void ExecInitHashTupleSlot(EState *estate, HashJoinState *hashstate); -extern TupleTableSlot *NodeGetResultTupleSlot(Plan *node); - -extern TupleDesc ExecGetTupType(Plan *node); -extern TupleDesc ExecTypeFromTL(List *targetList); - -/* - * prototypes from functions in execTuples.c - */ -extern void ResetTupleCount(); -extern void DisplayTupleCount(FILE *statfp); -extern void ExecAssignNodeBaseInfo(EState *estate, CommonState *basenode, - Plan *parent); -extern void ExecAssignExprContext(EState *estate, CommonState *commonstate); -extern void ExecAssignResultType(CommonState *commonstate, - TupleDesc tupDesc); -extern void ExecAssignResultTypeFromOuterPlan(Plan *node, - CommonState *commonstate); -extern void ExecAssignResultTypeFromTL(Plan *node, CommonState *commonstate); -extern TupleDesc ExecGetResultType(CommonState *commonstate); -extern void ExecFreeResultType(CommonState *commonstate); -extern void ExecAssignProjectionInfo(Plan *node, CommonState *commonstate); -extern void ExecFreeProjectionInfo(CommonState *commonstate); -extern TupleDesc ExecGetScanType(CommonScanState *csstate); -extern void ExecFreeScanType(CommonScanState *csstate); -extern void ExecAssignScanType(CommonScanState *csstate, - TupleDesc tupDesc); -extern void ExecAssignScanTypeFromOuterPlan(Plan *node, - CommonScanState *csstate); -extern AttributeTupleForm ExecGetTypeInfo(Relation relDesc); - -extern void ExecGetIndexKeyInfo(IndexTupleForm indexTuple, int *numAttsOutP, - AttrNumber **attsOutP, FuncIndexInfoPtr fInfoP); -extern void ExecOpenIndices(Oid resultRelationOid, - RelationInfo *resultRelationInfo); -extern void ExecCloseIndices(RelationInfo *resultRelationInfo); -extern IndexTuple ExecFormIndexTuple(HeapTuple heapTuple, - Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo); -extern void ExecInsertIndexTuples(TupleTableSlot *slot, ItemPointer tupleid, - EState *estate); - - -/* ---------------------------------------------------------------- - * the end - * ---------------------------------------------------------------- - */ - -#endif /* EXECUTOR_H */ diff --git a/src/backend/executor/functions.h b/src/backend/executor/functions.h deleted file mode 100644 index 1a1a88b36a1..00000000000 --- a/src/backend/executor/functions.h +++ /dev/null @@ -1,22 +0,0 @@ -/*------------------------------------------------------------------------- - * - * functions.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: functions.h,v 1.1.1.1 1996/07/09 06:21:25 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef FUNCTIONS_H -#define FUNCTIONS_H - -extern Datum ProjectAttribute(TupleDesc TD, TargetEntry *tlist, - HeapTuple tup, bool *isnullP); - -extern Datum postquel_function(Func *funcNode, char **args, - bool *isNull, bool *isDone); - -#endif /* FUNCTIONS_H */ diff --git a/src/backend/executor/hashjoin.h b/src/backend/executor/hashjoin.h deleted file mode 100644 index e7ae086fe16..00000000000 --- a/src/backend/executor/hashjoin.h +++ /dev/null @@ -1,82 +0,0 @@ -/*------------------------------------------------------------------------- - * - * hashjoin.h-- - * internal structures for hash table and buckets - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: hashjoin.h,v 1.1.1.1 1996/07/09 06:21:25 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef HASHJOIN_H -#define HASHJOIN_H - -#include "access/htup.h" -#include "storage/ipc.h" - -/* ----------------- - * have to use relative address as pointers in the hashtable - * because the hashtable may reallocate in difference processes - * ----------------- - */ -typedef int RelativeAddr; - -/* ------------------ - * the relative addresses are always relative to the head of the - * hashtable, the following macro converts them to absolute address. - * ------------------ - */ -#define ABSADDR(X) ((X) < 0 ? NULL: (char*)hashtable + X) -#define RELADDR(X) (RelativeAddr)((char*)(X) - (char*)hashtable) - -typedef char **charPP; -typedef int *intP; - -/* ---------------------------------------------------------------- - * hash-join hash table structures - * ---------------------------------------------------------------- - */ -typedef struct HashTableData { - int nbuckets; - int totalbuckets; - int bucketsize; - IpcMemoryId shmid; - RelativeAddr top; /* char* */ - RelativeAddr bottom; /* char* */ - RelativeAddr overflownext; /* char* */ - RelativeAddr batch; /* char* */ - RelativeAddr readbuf; /* char* */ - int nbatch; - RelativeAddr outerbatchNames; /* RelativeAddr* */ - RelativeAddr outerbatchPos; /* RelativeAddr* */ - RelativeAddr innerbatchNames; /* RelativeAddr* */ - RelativeAddr innerbatchPos; /* RelativeAddr* */ - RelativeAddr innerbatchSizes; /* int* */ - int curbatch; - int nprocess; - int pcount; -} HashTableData; /* real hash table follows here */ - -typedef HashTableData *HashJoinTable; - -typedef struct OverflowTupleData { - RelativeAddr tuple; /* HeapTuple */ - RelativeAddr next; /* struct OverflowTupleData * */ -} OverflowTupleData; /* real tuple follows here */ - -typedef OverflowTupleData *OverflowTuple; - -typedef struct HashBucketData { - RelativeAddr top; /* HeapTuple */ - RelativeAddr bottom; /* HeapTuple */ - RelativeAddr firstotuple; /* OverflowTuple */ - RelativeAddr lastotuple; /* OverflowTuple */ -} HashBucketData; /* real bucket follows here */ - -typedef HashBucketData *HashBucket; - -#define HASH_PERMISSION 0700 - -#endif /* HASHJOIN_H */ diff --git a/src/backend/executor/nodeAgg.h b/src/backend/executor/nodeAgg.h deleted file mode 100644 index 51c2b2b2270..00000000000 --- a/src/backend/executor/nodeAgg.h +++ /dev/null @@ -1,21 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeAgg.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeAgg.h,v 1.1.1.1 1996/07/09 06:21:26 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODEAGG_H -#define NODEAGG_H - -extern TupleTableSlot *ExecAgg(Agg *node); -extern bool ExecInitAgg(Agg *node, EState *estate, Plan *parent); -extern int ExecCountSlotsAgg(Agg *node); -extern void ExecEndAgg(Agg *node); - -#endif /* NODEAGG_H */ diff --git a/src/backend/executor/nodeAppend.h b/src/backend/executor/nodeAppend.h deleted file mode 100644 index fd2cdbbe81e..00000000000 --- a/src/backend/executor/nodeAppend.h +++ /dev/null @@ -1,22 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeAppend.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeAppend.h,v 1.1.1.1 1996/07/09 06:21:26 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODEAPPEND_H -#define NODEAPPEND_H - -extern bool exec_append_initialize_next(Append *node); -extern bool ExecInitAppend(Append *node, EState *estate, Plan *parent); -extern int ExecCountSlotsAppend(Append *node); -extern TupleTableSlot *ExecProcAppend(Append *node); -extern void ExecEndAppend(Append *node); - -#endif /* NODEAPPEND_H */ diff --git a/src/backend/executor/nodeGroup.h b/src/backend/executor/nodeGroup.h deleted file mode 100644 index 067028ea8e1..00000000000 --- a/src/backend/executor/nodeGroup.h +++ /dev/null @@ -1,21 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeGroup.h-- - * prototypes for nodeGroup.c - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeGroup.h,v 1.1.1.1 1996/07/09 06:21:26 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODEGROUP_H -#define NODEGROUP_H - -extern TupleTableSlot *ExecGroup(Group *node); -extern bool ExecInitGroup(Group *node, EState *estate, Plan *parent); -extern int ExecCountSlotsGroup(Group *node); -extern void ExecEndGroup(Group *node); - -#endif /* NODEGROUP_H */ diff --git a/src/backend/executor/nodeHash.h b/src/backend/executor/nodeHash.h deleted file mode 100644 index cec479dbb01..00000000000 --- a/src/backend/executor/nodeHash.h +++ /dev/null @@ -1,35 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeHash.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeHash.h,v 1.1.1.1 1996/07/09 06:21:26 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODEHASH_H -#define NODEHASH_H - -extern TupleTableSlot *ExecHash(Hash *node); -extern bool ExecInitHash(Hash *node, EState *estate, Plan *parent); -extern int ExecCountSlotsHash(Hash *node); -extern void ExecEndHash(Hash *node); -extern RelativeAddr hashTableAlloc(int size, HashJoinTable hashtable); -extern HashJoinTable ExecHashTableCreate(Hash *node); -extern void ExecHashTableInsert(HashJoinTable hashtable, ExprContext *econtext, - Var *hashkey, File *batches); -extern void ExecHashTableDestroy(HashJoinTable hashtable); -extern int ExecHashGetBucket(HashJoinTable hashtable, ExprContext *econtext, - Var *hashkey); -extern void ExecHashOverflowInsert(HashJoinTable hashtable, HashBucket bucket, - HeapTuple heapTuple); -extern HeapTuple ExecScanHashBucket(HashJoinState *hjstate, HashBucket bucket, - HeapTuple curtuple, List *hjclauses, - ExprContext *econtext); -extern int ExecHashPartition(Hash *node); -extern void ExecHashTableReset(HashJoinTable hashtable, int ntuples); - -#endif /* NODEHASH_H */ diff --git a/src/backend/executor/nodeHashjoin.h b/src/backend/executor/nodeHashjoin.h deleted file mode 100644 index b8c12942b3b..00000000000 --- a/src/backend/executor/nodeHashjoin.h +++ /dev/null @@ -1,33 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeHashjoin.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeHashjoin.h,v 1.1.1.1 1996/07/09 06:21:26 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODEHASHJOIN_H -#define NODEHASHJOIN_H - -extern TupleTableSlot *ExecHashJoin(HashJoin *node); - -extern bool ExecInitHashJoin(HashJoin *node, EState *estate, Plan *parent); - -extern int ExecCountSlotsHashJoin(HashJoin *node); - -extern void ExecEndHashJoin(HashJoin *node); - -extern int ExecHashJoinNewBatch(HashJoinState *hjstate); - -extern char *ExecHashJoinSaveTuple(HeapTuple heapTuple, char *buffer, - File file, char *position); - -extern int ExecHashJoinGetBatch(int bucketno, HashJoinTable hashtable, - int nbatch); - - -#endif /* NODEHASHJOIN_H */ diff --git a/src/backend/executor/nodeIndexscan.h b/src/backend/executor/nodeIndexscan.h deleted file mode 100644 index 27bbff0a293..00000000000 --- a/src/backend/executor/nodeIndexscan.h +++ /dev/null @@ -1,32 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeIndexscan.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeIndexscan.h,v 1.1.1.1 1996/07/09 06:21:26 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODEINDEXSCAN_H -#define NODEINDEXSCAN_H - -extern TupleTableSlot *ExecIndexScan(IndexScan *node); - -extern void ExecIndexReScan(IndexScan *node, ExprContext *exprCtxt, Plan *parent); - -extern void ExecEndIndexScan(IndexScan *node); - -extern void ExecIndexMarkPos(IndexScan *node); - -extern void ExecIndexRestrPos(IndexScan *node); - -extern void ExecUpdateIndexScanKeys(IndexScan *node, ExprContext *econtext); - -extern bool ExecInitIndexScan(IndexScan *node, EState *estate, Plan *parent); - -extern int ExecCountSlotsIndexScan(IndexScan *node); - -#endif /* NODEINDEXSCAN_H */ diff --git a/src/backend/executor/nodeMaterial.h b/src/backend/executor/nodeMaterial.h deleted file mode 100644 index d85b025b7bf..00000000000 --- a/src/backend/executor/nodeMaterial.h +++ /dev/null @@ -1,23 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeMaterial.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeMaterial.h,v 1.1.1.1 1996/07/09 06:21:27 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODEMATERIAL_H -#define NODEMATERIAL_H - -extern TupleTableSlot *ExecMaterial(Material *node); -extern bool ExecInitMaterial(Material *node, EState *estate, Plan *parent); -extern int ExecCountSlotsMaterial(Material *node); -extern void ExecEndMaterial(Material *node); -extern List ExecMaterialMarkPos(Material *node); -extern void ExecMaterialRestrPos(Material *node); - -#endif /* NODEMATERIAL_H */ diff --git a/src/backend/executor/nodeMergejoin.h b/src/backend/executor/nodeMergejoin.h deleted file mode 100644 index ebdca08e32f..00000000000 --- a/src/backend/executor/nodeMergejoin.h +++ /dev/null @@ -1,40 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeMergejoin.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeMergejoin.h,v 1.1.1.1 1996/07/09 06:21:27 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODEMERGEJOIN_H -#define NODEMERGEJOIN_H - -#if 0 /* aren't these static? */ -extern List MJFormOSortopI(List qualList, Oid sortOp); -extern List MJFormISortopO(List qualList, Oid sortOp); -#endif -extern bool MergeCompare(List *eqQual, List *compareQual, ExprContext *econtext); - -extern void ExecMergeTupleDumpInner(ExprContext *econtext); - -extern void ExecMergeTupleDumpOuter(ExprContext *econtext); - -extern void ExecMergeTupleDumpMarked(ExprContext *econtext, - MergeJoinState *mergestate); - -extern void ExecMergeTupleDump(ExprContext *econtext, - MergeJoinState *mergestate); - -extern TupleTableSlot *ExecMergeJoin(MergeJoin *node); - -extern bool ExecInitMergeJoin(MergeJoin *node, EState *estate, Plan *parent); - -extern int ExecCountSlotsMergeJoin(MergeJoin *node); - -extern void ExecEndMergeJoin(MergeJoin *node); - -#endif /* NODEMERGEJOIN_H; */ diff --git a/src/backend/executor/nodeNestloop.h b/src/backend/executor/nodeNestloop.h deleted file mode 100644 index c227c90a735..00000000000 --- a/src/backend/executor/nodeNestloop.h +++ /dev/null @@ -1,21 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeNestloop.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeNestloop.h,v 1.1.1.1 1996/07/09 06:21:27 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODENESTLOOP_H -#define NODENESTLOOP_H - -extern TupleTableSlot *ExecNestLoop(NestLoop *node, Plan *parent); -extern bool ExecInitNestLoop(NestLoop *node, EState *estate, Plan *parent); -extern int ExecCountSlotsNestLoop(NestLoop *node); -extern void ExecEndNestLoop(NestLoop *node); - -#endif /* NODENESTLOOP_H */ diff --git a/src/backend/executor/nodeResult.h b/src/backend/executor/nodeResult.h deleted file mode 100644 index a2ab286c089..00000000000 --- a/src/backend/executor/nodeResult.h +++ /dev/null @@ -1,21 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeResult.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeResult.h,v 1.1.1.1 1996/07/09 06:21:27 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODERESULT_H -#define NODERESULT_H - -extern TupleTableSlot *ExecResult(Result *node); -extern bool ExecInitResult(Result *node, EState *estate, Plan *parent); -extern int ExecCountSlotsResult(Result *node); -extern void ExecEndResult(Result *node); - -#endif /* NODERESULT_H */ diff --git a/src/backend/executor/nodeSeqscan.h b/src/backend/executor/nodeSeqscan.h deleted file mode 100644 index cce029d40b7..00000000000 --- a/src/backend/executor/nodeSeqscan.h +++ /dev/null @@ -1,27 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeSeqscan.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeSeqscan.h,v 1.1.1.1 1996/07/09 06:21:27 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODESEQSCAN_H -#define NODESEQSCAN_H - -extern TupleTableSlot *SeqNext(SeqScan *node); -extern TupleTableSlot *ExecSeqScan(SeqScan *node); -extern Oid InitScanRelation(SeqScan *node, EState *estate, - CommonScanState *scanstate, Plan *outerPlan); -extern bool ExecInitSeqScan(SeqScan *node, EState *estate, Plan *parent); -extern int ExecCountSlotsSeqScan(SeqScan *node); -extern void ExecEndSeqScan(SeqScan *node); -extern void ExecSeqReScan(SeqScan *node, ExprContext *exprCtxt, Plan* parent); -extern void ExecSeqMarkPos(SeqScan *node); -extern void ExecSeqRestrPos(SeqScan *node); - -#endif /* NODESEQSCAN_H */ diff --git a/src/backend/executor/nodeSort.h b/src/backend/executor/nodeSort.h deleted file mode 100644 index 504b8a1f19e..00000000000 --- a/src/backend/executor/nodeSort.h +++ /dev/null @@ -1,23 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeSort.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeSort.h,v 1.1.1.1 1996/07/09 06:21:27 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODESORT_H -#define NODESORT_H - -extern TupleTableSlot *ExecSort(Sort *node); -extern bool ExecInitSort(Sort *node, EState *estate, Plan *parent); -extern int ExecCountSlotsSort(Sort *node); -extern void ExecEndSort(Sort *node); -extern void ExecSortMarkPos(Sort *node); -extern void ExecSortRestrPos(Sort *node); - -#endif /* NODESORT_H */ diff --git a/src/backend/executor/nodeTee.h b/src/backend/executor/nodeTee.h deleted file mode 100644 index aa50efdead4..00000000000 --- a/src/backend/executor/nodeTee.h +++ /dev/null @@ -1,22 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeTee.h-- - * support functions for a Tee executor node - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeTee.h,v 1.1.1.1 1996/07/09 06:21:27 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ - -#ifndef NODETEE_H -#define NODETEE_H - -extern TupleTableSlot* ExecTee(Tee* node, Plan* parent); -extern bool ExecInitTee(Tee* node, EState* estate, Plan* parent); -extern void ExecTeeReScan(Tee *node, ExprContext *exprCtxt, Plan *parent); -extern void ExecEndTee(Tee* node, Plan* parent); -extern int ExecCountSlotsTee(Tee* node); - -#endif /* NODETEE_H */ diff --git a/src/backend/executor/nodeUnique.h b/src/backend/executor/nodeUnique.h deleted file mode 100644 index a8dfc9bd6b9..00000000000 --- a/src/backend/executor/nodeUnique.h +++ /dev/null @@ -1,21 +0,0 @@ -/*------------------------------------------------------------------------- - * - * nodeUnique.h-- - * - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: nodeUnique.h,v 1.1.1.1 1996/07/09 06:21:28 scrappy Exp $ - * - *------------------------------------------------------------------------- - */ -#ifndef NODEUNIQUE_H -#define NODEUNIQUE_H - -extern TupleTableSlot *ExecUnique(Unique *node); -extern bool ExecInitUnique(Unique *node, EState *estate, Plan *parent); -extern int ExecCountSlotsUnique(Unique *node); -extern void ExecEndUnique(Unique *node); - -#endif /* NODEUNIQUE_H */ diff --git a/src/backend/executor/tuptable.h b/src/backend/executor/tuptable.h deleted file mode 100644 index 33f7de33589..00000000000 --- a/src/backend/executor/tuptable.h +++ /dev/null @@ -1,72 +0,0 @@ -/*------------------------------------------------------------------------- - * - * tuptable.h-- - * tuple table support stuff - * - * - * Copyright (c) 1994, Regents of the University of California - * - * $Id: tuptable.h,v 1.1.1.1 1996/07/09 06:21:28 scrappy Exp $ - * - * NOTES - * The tuple table interface is getting pretty ugly. - * It should be redesigned soon. - * - *------------------------------------------------------------------------- - */ -#ifndef TUPTABLE_H -#define TUPTABLE_H - -/* ---------------- - * Note: the executor tuple table is managed and manipulated by special - * code and macros in executor/execTuples.c and tupTable.h - * - * TupleTableSlot information - * - * shouldFree boolean - should we call pfree() on tuple - * descIsNew boolean - true when tupleDescriptor changes - * tupleDescriptor type information kept regarding the tuple data - * buffer the buffer for tuples pointing to disk pages - * - * The executor stores pointers to tuples in a ``tuple table'' - * which is composed of TupleTableSlot's. Some of the tuples - * are pointers to buffer pages and others are pointers to - * palloc'ed memory and the shouldFree variable tells us when - * we may call pfree() on a tuple. -cim 9/23/90 - * - * In the implementation of nested-dot queries such as - * "retrieve (EMP.hobbies.all)", a single scan may return tuples - * of many types, so now we return pointers to tuple descriptors - * along with tuples returned via the tuple table. -cim 1/18/90 - * ---------------- - */ -typedef struct TupleTableSlot { - NodeTag type; - HeapTuple val; - bool ttc_shouldFree; - bool ttc_descIsNew; - TupleDesc ttc_tupleDescriptor; - Buffer ttc_buffer; - int ttc_whichplan; -} TupleTableSlot; - -/* ---------------- - * tuple table data structure - * ---------------- - */ -typedef struct TupleTableData { - int size; /* size of the table */ - int next; /* next available slot number */ - TupleTableSlot *array; /* array of TupleTableSlot's */ -} TupleTableData; - -typedef TupleTableData *TupleTable; - -/* - tuple table macros are all excised from the system now - see executor.h for decls of functions defined in execTuples.c - - - jolly -*/ - -#endif /* TUPTABLE_H */ |