upstream/postgresql
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2026-02-03 20:40:14 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
postgresql/src/include/executor/executor.h

251 lines
9 KiB
C
Raw Normal View History

Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*-------------------------------------------------------------------------
*
Change my-function-name-- to my_function_name, and optimizer renames.
1999-02-13 18:22:53 -05:00
* executor.h
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 01:04:48 -04:00
* support for the POSTGRES executor module
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
*
*
Tag appropriate files for rc3 Also performed an initial run through of upgrading our Copyright date to extend to 2005 ... first run here was very simple ... change everything where: grep 1996-2004 && the word 'Copyright' ... scanned through the generated list with 'less' first, and after, to make sure that I only picked up the right entries ...
2004-12-31 17:04:05 -05:00
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
Add: * Portions Copyright (c) 1996-2000, PostgreSQL, Inc to all files copyright Regents of Berkeley. Man, that's a lot of files.
2000-01-26 00:58:53 -05:00
* Portions Copyright (c) 1994, Regents of the University of California
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
*
Tweak indexscan machinery to avoid taking an AccessShareLock on an index if we already have a stronger lock due to the index's table being the update target table of the query. Same optimization I applied earlier at the table level. There doesn't seem to be much interest in the more radical idea of not locking indexes at all, so do what we can ...
2005-12-03 00:51:03 -05:00
* $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.123 2005/12/03 05:51:03 tgl Exp $
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
*
*-------------------------------------------------------------------------
*/
#ifndef EXECUTOR_H
#define EXECUTOR_H
Change #include's to use <> and "" as appropriate.
1999-07-15 19:04:24 -04:00
#include "executor/execdesc.h"
Another run through. This gets us a clean compile of 'common' and 'gist' with *clean* #include files
1996-11-05 03:18:44 -05:00
Phase 1 of read-only-plans project: cause executor state nodes to point to plan nodes, not vice-versa. All executor state nodes now inherit from struct PlanState. Copying of plan trees has been simplified by not storing a list of SubPlans in Plan nodes (eliminating duplicate links). The executor still needs such a list, but it can build it during ExecutorStart since it has to scan the plan tree anyway. No initdb forced since no stored-on-disk structures changed, but you will need a full recompile because of node-numbering changes.
2002-12-05 10:50:39 -05:00
Replace the switching function ExecEvalExpr() with a macro that jumps directly to the appropriate per-node execution function, using a function pointer stored by ExecInitExpr. This speeds things up by eliminating one level of function call. The function-pointer technique also enables further small improvements such as only making one-time tests once (and then changing the function pointer). Overall this seems to gain about 10% on evaluation of simple expressions, which isn't earthshaking but seems a worthwhile gain for a relatively small hack. Per recent discussion on pghackers.
2004-03-16 20:02:24 -05:00
/*
* ExecEvalExpr was formerly a function containing a switch statement;
* now it's just a macro invoking the function pointed to by an ExprState
* node. Beware of double evaluation of the ExprState argument!
*/
#define ExecEvalExpr(expr, econtext, isNull, isDone) \
((*(expr)->evalfunc) (expr, econtext, isNull, isDone))
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*
* prototypes from functions in execAmi.c
*/
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void ExecReScan(PlanState *node, ExprContext *exprCtxt);
extern void ExecMarkPos(PlanState *node);
extern void ExecRestrPos(PlanState *node);
Be more realistic about plans involving Materialize nodes: take their cost into account while planning.
2002-11-30 00:21:03 -05:00
extern bool ExecSupportsMarkRestore(NodeTag plantype);
Restructure parsetree representation of DECLARE CURSOR: now it's a utility statement (DeclareCursorStmt) with a SELECT query dangling from it, rather than a SELECT query with a few unusual fields in it. Add code to determine whether a planned query can safely be run backwards. If DECLARE CURSOR specifies SCROLL, ensure that the plan can be run backwards by adding a Materialize plan node if it can't. Without SCROLL, you get an error if you try to fetch backwards from a cursor that can't handle it. (There is still some discussion about what the exact behavior should be, but this is necessary infrastructure in any case.) Along the way, make EXPLAIN DECLARE CURSOR work.
2003-03-09 22:53:52 -05:00
extern bool ExecSupportsBackwardScan(Plan *node);
Junkfilter logic to force a projection step during SELECT INTO was too simplistic; it recognized SELECT * FROM but not SELECT * FROM LIMIT. Per bug report from Jeff Bohmer.
2004-03-02 13:56:15 -05:00
extern bool ExecMayReturnRawTuples(PlanState *node);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
Create a new file executor/execGrouping.c to centralize utility routines shared by nodeGroup, nodeAgg, and soon nodeSubplan.
2003-01-10 18:54:24 -05:00
/*
* prototypes from functions in execGrouping.c
*/
Revise TupleTableSlot code to avoid unnecessary construction and disassembly of tuples when passing data up through multiple plan nodes. A slot can now hold either a normal "physical" HeapTuple, or a "virtual" tuple consisting of Datum/isnull arrays. Upper plan levels can usually just copy the Datum arrays, avoiding heap_formtuple() and possible subsequent nocachegetattr() calls to extract the data again. This work extends Atsushi Ogawa's earlier patch, which provided the key idea of adding Datum arrays to TupleTableSlots. (I believe however that something like this was foreseen way back in Berkeley days --- see the old comment on ExecProject.) A test case involving many levels of join of fairly wide tables (about 80 columns altogether) showed about 3x overall speedup, though simple queries will probably not be helped very much. I have also duplicated some code in heaptuple.c in order to provide versions of heap_formtuple and friends that use "bool" arrays to indicate null attributes, instead of the old convention of "char" arrays containing either 'n' or ' '. This provides a better match to the convention used by ExecEvalExpr. While I have not made a concerted effort to get rid of uses of the old routines, I think they should be deprecated and eventually removed.
2005-03-16 16:38:10 -05:00
extern bool execTuplesMatch(TupleTableSlot *slot1,
Standard pgindent run for 8.1.
2005-10-14 22:49:52 -04:00
TupleTableSlot *slot2,
int numCols,
AttrNumber *matchColIdx,
FmgrInfo *eqfunctions,
MemoryContext evalContext);
Revise TupleTableSlot code to avoid unnecessary construction and disassembly of tuples when passing data up through multiple plan nodes. A slot can now hold either a normal "physical" HeapTuple, or a "virtual" tuple consisting of Datum/isnull arrays. Upper plan levels can usually just copy the Datum arrays, avoiding heap_formtuple() and possible subsequent nocachegetattr() calls to extract the data again. This work extends Atsushi Ogawa's earlier patch, which provided the key idea of adding Datum arrays to TupleTableSlots. (I believe however that something like this was foreseen way back in Berkeley days --- see the old comment on ExecProject.) A test case involving many levels of join of fairly wide tables (about 80 columns altogether) showed about 3x overall speedup, though simple queries will probably not be helped very much. I have also duplicated some code in heaptuple.c in order to provide versions of heap_formtuple and friends that use "bool" arrays to indicate null attributes, instead of the old convention of "char" arrays containing either 'n' or ' '. This provides a better match to the convention used by ExecEvalExpr. While I have not made a concerted effort to get rid of uses of the old routines, I think they should be deprecated and eventually removed.
2005-03-16 16:38:10 -05:00
extern bool execTuplesUnequal(TupleTableSlot *slot1,
Standard pgindent run for 8.1.
2005-10-14 22:49:52 -04:00
TupleTableSlot *slot2,
int numCols,
AttrNumber *matchColIdx,
FmgrInfo *eqfunctions,
MemoryContext evalContext);
Create a new file executor/execGrouping.c to centralize utility routines shared by nodeGroup, nodeAgg, and soon nodeSubplan.
2003-01-10 18:54:24 -05:00
extern FmgrInfo *execTuplesMatchPrepare(TupleDesc tupdesc,
int numCols,
AttrNumber *matchColIdx);
Revise hash join and hash aggregation code to use the same datatype- specific hash functions used by hash indexes, rather than the old not-datatype-aware ComputeHashFunc routine. This makes it safe to do hash joining on several datatypes that previously couldn't use hashing. The sets of datatypes that are hash indexable and hash joinable are now exactly the same, whereas before each had some that weren't in the other.
2003-06-22 18:04:55 -04:00
extern void execTuplesHashPrepare(TupleDesc tupdesc,
pgindent run.
2003-08-03 20:43:34 -04:00
int numCols,
AttrNumber *matchColIdx,
FmgrInfo **eqfunctions,
FmgrInfo **hashfunctions);
Create a new file executor/execGrouping.c to centralize utility routines shared by nodeGroup, nodeAgg, and soon nodeSubplan.
2003-01-10 18:54:24 -05:00
extern TupleHashTable BuildTupleHashTable(int numCols, AttrNumber *keyColIdx,
pgindent run.
2003-08-03 20:43:34 -04:00
FmgrInfo *eqfunctions,
FmgrInfo *hashfunctions,
int nbuckets, Size entrysize,
MemoryContext tablecxt,
MemoryContext tempcxt);
Create a new file executor/execGrouping.c to centralize utility routines shared by nodeGroup, nodeAgg, and soon nodeSubplan.
2003-01-10 18:54:24 -05:00
extern TupleHashEntry LookupTupleHashEntry(TupleHashTable hashtable,
pgindent run.
2003-08-03 20:43:34 -04:00
TupleTableSlot *slot,
bool *isnew);
Create a new file executor/execGrouping.c to centralize utility routines shared by nodeGroup, nodeAgg, and soon nodeSubplan.
2003-01-10 18:54:24 -05:00
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*
* prototypes from functions in execJunk.c
*/
Fix problems with SQL functions returning rowtypes that have dropped columns. The returned tuple needs to have appropriate NULL columns inserted so that it actually matches the declared rowtype. It seemed convenient to use a JunkFilter for this, so I made some cleanups and simplifications in the JunkFilter code to allow it to support this additional functionality. (That in turn exposed a latent bug in nodeAppend.c, which is that it was returning a tuple slot whose descriptor didn't match its data.) Also, move check_sql_fn_retval out of pg_proc.c and into functions.c, where it seems to more naturally belong.
2004-10-07 14:38:51 -04:00
extern JunkFilter *ExecInitJunkFilter(List *targetList, bool hasoid,
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 01:50:21 -04:00
TupleTableSlot *slot);
Fix problems with SQL functions returning rowtypes that have dropped columns. The returned tuple needs to have appropriate NULL columns inserted so that it actually matches the declared rowtype. It seemed convenient to use a JunkFilter for this, so I made some cleanups and simplifications in the JunkFilter code to allow it to support this additional functionality. (That in turn exposed a latent bug in nodeAppend.c, which is that it was returning a tuple slot whose descriptor didn't match its data.) Also, move check_sql_fn_retval out of pg_proc.c and into functions.c, where it seems to more naturally belong.
2004-10-07 14:38:51 -04:00
extern JunkFilter *ExecInitJunkFilterConversion(List *targetList,
Standard pgindent run for 8.1.
2005-10-14 22:49:52 -04:00
TupleDesc cleanTupType,
TupleTableSlot *slot);
OK, folks, here is the pgindent output.
1998-09-01 00:40:42 -04:00
extern bool ExecGetJunkAttribute(JunkFilter *junkfilter, TupleTableSlot *slot,
Used modified version of indent that understands over 100 typedefs.
1997-09-08 17:56:23 -04:00
char *attrName, Datum *value, bool *isNull);
Revise TupleTableSlot code to avoid unnecessary construction and disassembly of tuples when passing data up through multiple plan nodes. A slot can now hold either a normal "physical" HeapTuple, or a "virtual" tuple consisting of Datum/isnull arrays. Upper plan levels can usually just copy the Datum arrays, avoiding heap_formtuple() and possible subsequent nocachegetattr() calls to extract the data again. This work extends Atsushi Ogawa's earlier patch, which provided the key idea of adding Datum arrays to TupleTableSlots. (I believe however that something like this was foreseen way back in Berkeley days --- see the old comment on ExecProject.) A test case involving many levels of join of fairly wide tables (about 80 columns altogether) showed about 3x overall speedup, though simple queries will probably not be helped very much. I have also duplicated some code in heaptuple.c in order to provide versions of heap_formtuple and friends that use "bool" arrays to indicate null attributes, instead of the old convention of "char" arrays containing either 'n' or ' '. This provides a better match to the convention used by ExecEvalExpr. While I have not made a concerted effort to get rid of uses of the old routines, I think they should be deprecated and eventually removed.
2005-03-16 16:38:10 -05:00
extern TupleTableSlot *ExecFilterJunk(JunkFilter *junkfilter,
Standard pgindent run for 8.1.
2005-10-14 22:49:52 -04:00
TupleTableSlot *slot);
Used modified version of indent that understands over 100 typedefs.
1997-09-08 17:56:23 -04:00
extern HeapTuple ExecRemoveJunk(JunkFilter *junkfilter, TupleTableSlot *slot);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*
* prototypes from functions in execMain.c
*/
Redesign query-snapshot timing so that volatile functions in READ COMMITTED mode see a fresh snapshot for each command in the function, rather than using the latest interactive command's snapshot. Also, suppress fresh snapshots as well as CommandCounterIncrement inside STABLE and IMMUTABLE functions, instead using the snapshot taken for the most closely nested regular query. (This behavior is only sane for read-only functions, so the patch also enforces that such functions contain only SELECT commands.) As per my proposal of 6-Sep-2004; I note that I floated essentially the same proposal on 19-Jun-2002, but that discussion tailed off without any action. Since 8.0 seems like the right place to be taking possibly nontrivial backwards compatibility hits, let's get it done now.
2004-09-13 16:10:13 -04:00
extern void ExecutorStart(QueryDesc *queryDesc, bool explainOnly);
Phase 1 of read-only-plans project: cause executor state nodes to point to plan nodes, not vice-versa. All executor state nodes now inherit from struct PlanState. Copying of plan trees has been simplified by not storing a list of SubPlans in Plan nodes (eliminating duplicate links). The executor still needs such a list, but it can build it during ExecutorStart since it has to scan the plan tree anyway. No initdb forced since no stored-on-disk structures changed, but you will need a full recompile because of node-numbering changes.
2002-12-05 10:50:39 -05:00
extern TupleTableSlot *ExecutorRun(QueryDesc *queryDesc,
pgindent run.
2002-09-04 16:31:48 -04:00
ScanDirection direction, long count);
Phase 1 of read-only-plans project: cause executor state nodes to point to plan nodes, not vice-versa. All executor state nodes now inherit from struct PlanState. Copying of plan trees has been simplified by not storing a list of SubPlans in Plan nodes (eliminating duplicate links). The executor still needs such a list, but it can build it during ExecutorStart since it has to scan the plan tree anyway. No initdb forced since no stored-on-disk structures changed, but you will need a full recompile because of node-numbering changes.
2002-12-05 10:50:39 -05:00
extern void ExecutorEnd(QueryDesc *queryDesc);
Implement SQL92-compatible FIRST, LAST, ABSOLUTE n, RELATIVE n options for FETCH and MOVE.
2003-03-11 14:40:24 -05:00
extern void ExecutorRewind(QueryDesc *queryDesc);
Fix permission-checking bug reported by Tim Burgess 10-Feb-03 (this time for sure...). Rather than relying on the query context of a rangetable entry to identify what permissions it wants checked, store a full AclMode mask in each RTE, and check exactly those bits. This allows an RTE specifying, say, INSERT privilege on a view to be copied into a derived UPDATE query without changing meaning. Per recent discussion thread. initdb forced due to change of stored rule representation.
2004-01-14 18:01:55 -05:00
extern void ExecCheckRTPerms(List *rangeTable);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void ExecEndPlan(PlanState *planstate, EState *estate);
Fix oversight in optimization that avoids an unnecessary projection step when scanning a table that we need all the columns from. In case of SELECT INTO, we have to check that the hasoids flag matches the desired output type, too. Per report from Mike Mascari.
2004-01-21 21:23:21 -05:00
extern bool ExecContextForcesOids(PlanState *planstate, bool *hasoids);
Error message editing in backend/executor.
2003-07-21 13:05:12 -04:00
extern void ExecConstraints(ResultRelInfo *resultRelInfo,
pgindent run. Make it all clean.
2001-03-21 23:01:46 -05:00
TupleTableSlot *slot, EState *estate);
Second round of fmgr changes: triggers are now invoked in new style, CurrentTriggerData is history.
2000-05-28 21:59:17 -04:00
extern TupleTableSlot *EvalPlanQual(EState *estate, Index rti,
Standard pgindent run for 8.1.
2005-10-14 22:49:52 -04:00
ItemPointer tid, TransactionId priorXmax);
pgindent run over code.
1999-05-25 12:15:34 -04:00
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*
* prototypes from functions in execProcnode.c
*/
Phase 1 of read-only-plans project: cause executor state nodes to point to plan nodes, not vice-versa. All executor state nodes now inherit from struct PlanState. Copying of plan trees has been simplified by not storing a list of SubPlans in Plan nodes (eliminating duplicate links). The executor still needs such a list, but it can build it during ExecutorStart since it has to scan the plan tree anyway. No initdb forced since no stored-on-disk structures changed, but you will need a full recompile because of node-numbering changes.
2002-12-05 10:50:39 -05:00
extern PlanState *ExecInitNode(Plan *node, EState *estate);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern TupleTableSlot *ExecProcNode(PlanState *node);
Create a new 'MultiExecProcNode' call API for plan nodes that don't return just a single tuple at a time. Currently the only such node type is Hash, but I expect we will soon have indexscans that can return tuple bitmaps. A side benefit is that EXPLAIN ANALYZE now shows the correct tuple count for a Hash node.
2005-04-16 16:07:35 -04:00
extern Node *MultiExecProcNode(PlanState *node);
Used modified version of indent that understands over 100 typedefs.
1997-09-08 17:56:23 -04:00
extern int ExecCountSlotsNode(Plan *node);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void ExecEndNode(PlanState *node);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*
* prototypes from functions in execQual.c
*/
Replace TupleTableSlot convention for whole-row variables and function results with tuples as ordinary varlena Datums. This commit does not in itself do much for us, except eliminate the horrid memory leak associated with evaluation of whole-row variables. However, it lays the groundwork for allowing composite types as table columns, and perhaps some other useful features as well. Per my proposal of a few days ago.
2004-04-01 16:28:47 -05:00
extern Datum GetAttributeByNum(HeapTupleHeader tuple, AttrNumber attrno,
pgindent run. Make it all clean.
2001-03-21 23:01:46 -05:00
bool *isNull);
Replace TupleTableSlot convention for whole-row variables and function results with tuples as ordinary varlena Datums. This commit does not in itself do much for us, except eliminate the horrid memory leak associated with evaluation of whole-row variables. However, it lays the groundwork for allowing composite types as table columns, and perhaps some other useful features as well. Per my proposal of a few days ago.
2004-04-01 16:28:47 -05:00
extern Datum GetAttributeByName(HeapTupleHeader tuple, const char *attname,
pgindent run. Make it all clean.
2001-03-21 23:01:46 -05:00
bool *isNull);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void init_fcache(Oid foid, FuncExprState *fcache,
pgindent run.
2003-08-03 20:43:34 -04:00
MemoryContext fcacheCxt);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern Datum ExecMakeFunctionResult(FuncExprState *fcache,
pgindent run. Make it all clean.
2001-03-21 23:01:46 -05:00
ExprContext *econtext,
bool *isNull,
ExprDoneCond *isDone);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern Tuplestorestate *ExecMakeTableFunctionResult(ExprState *funcexpr,
pgindent run.
2002-09-04 16:31:48 -04:00
ExprContext *econtext,
TupleDesc expectedDesc,
TupleDesc *returnDesc);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern Datum ExecEvalExprSwitchContext(ExprState *expression, ExprContext *econtext,
pgindent run. Make it all clean.
2001-03-21 23:01:46 -05:00
bool *isNull, ExprDoneCond *isDone);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern ExprState *ExecInitExpr(Expr *node, PlanState *parent);
extern SubPlanState *ExecInitExprInitPlan(SubPlan *node, PlanState *parent);
Revise executor APIs so that all per-query state structure is built in a per-query memory context created by CreateExecutorState --- and destroyed by FreeExecutorState. This provides a final solution to the longstanding problem of memory leaked by various ExecEndNode calls.
2002-12-15 11:17:59 -05:00
extern ExprState *ExecPrepareExpr(Expr *node, EState *estate);
Fix handling of NULL constraint conditions: per SQL92 spec, a NULL result from a constraint condition does not violate the constraint (cf. discussion on pghackers 12/9/99). Implemented by adding a parameter to ExecQual, specifying whether to return TRUE or FALSE when the qual result is really NULL in three-valued boolean logic. Currently, ExecRelCheck is the only caller that asks for TRUE, but if we find any other places that have the wrong response to NULL, it'll be easy to fix them.
2000-01-19 18:55:03 -05:00
extern bool ExecQual(List *qual, ExprContext *econtext, bool resultForNull);
Used modified version of indent that understands over 100 typedefs.
1997-09-08 17:56:23 -04:00
extern int ExecTargetListLength(List *targetlist);
Move pg_checkretval out of the planner (where it never belonged) into pg_proc.c (where it's actually used). Fix it to correctly handle tlists that contain resjunk target items, and improve error messages. This addresses bug reported by Krupnikov 6-July-00.
2000-08-21 16:55:31 -04:00
extern int ExecCleanTargetListLength(List *targetlist);
SQL-language functions are now callable in ordinary fmgr contexts ... for example, an SQL function can be used in a functional index. (I make no promises about speed, but it'll work ;-).) Clean up and simplify handling of functions returning sets.
2000-08-23 23:29:15 -04:00
extern TupleTableSlot *ExecProject(ProjectionInfo *projInfo,
pgindent run. Make it all clean.
2001-03-21 23:01:46 -05:00
ExprDoneCond *isDone);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*
* prototypes from functions in execScan.c
*/
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
typedef TupleTableSlot *(*ExecScanAccessMtd) (ScanState *node);
First stage of reclaiming memory in executor by resetting short-term memory contexts. Currently, only leaks in expressions executed as quals or projections are handled. Clean up some old dead cruft in executor while at it --- unused fields in state nodes, that sort of thing.
2000-07-11 22:37:39 -04:00
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern TupleTableSlot *ExecScan(ScanState *node, ExecScanAccessMtd accessMtd);
extern void ExecAssignScanProjectionInfo(ScanState *node);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*
* prototypes from functions in execTuples.c
*/
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void ExecInitResultTupleSlot(EState *estate, PlanState *planstate);
extern void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate);
First cut at full support for OUTER JOINs. There are still a few loose ends to clean up (see my message of same date to pghackers), but mostly it works. INITDB REQUIRED!
2000-09-12 17:07:18 -04:00
extern TupleTableSlot *ExecInitExtraTupleSlot(EState *estate);
extern TupleTableSlot *ExecInitNullTupleSlot(EState *estate,
pgindent run. Make it all clean.
2001-03-21 23:01:46 -05:00
TupleDesc tupType);
Code review for HeapTupleHeader changes. Add version number to page headers (overlaying low byte of page size) and add HEAP_HASOID bit to t_infomask, per earlier discussion. Simplify scheme for overlaying fields in tuple header (no need for cmax to live in more than one place). Don't try to clear infomask status bits in tqual.c --- not safe to do it there. Don't try to force output table of a SELECT INTO to have OIDs, either. Get rid of unnecessarily complex three-state scheme for TupleDesc.tdhasoids, which has already caused one recent failure. Improve documentation.
2002-09-01 21:05:06 -04:00
extern TupleDesc ExecTypeFromTL(List *targetList, bool hasoid);
Restructure command destination handling so that we pass around DestReceiver pointers instead of just CommandDest values. The DestReceiver is made at the point where the destination is selected, rather than deep inside the executor. This cleans up the original kluge implementation of tstoreReceiver.c, and makes it easy to support retrieving results from utility statements inside portals. Thus, you can now do fun things like Bind and Execute a FETCH or EXPLAIN command, and it'll all work as expected (e.g., you can Describe the portal, or use Execute's count parameter to suspend the output partway through). Implementation involves stuffing the utility command's output into a Tuplestore, which would be kind of annoying for huge output sets, but should be quite acceptable for typical uses of utility commands.
2003-05-06 16:26:28 -04:00
extern TupleDesc ExecCleanTypeFromTL(List *targetList, bool hasoid);
Promote row expressions to full-fledged citizens of the expression syntax, rather than allowing them only in a few special cases as before. In particular you can now pass a ROW() construct to a function that accepts a rowtype parameter. Internal generation of RowExprs fixes a number of corner cases that used to not work very well, such as referencing the whole-row result of a JOIN or subquery. This represents a further step in the work I started a month or so back to make rowtype values into first-class citizens.
2004-05-10 18:44:49 -04:00
extern TupleDesc ExecTypeFromExprList(List *exprList);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
> 2. This patch includes the same Table Function API fixes that I > submitted on July 9: > > http://archives.postgresql.org/pgsql-patches/2002-07/msg00056.php > > Please disregard that one *if* this one is applied. If this one is > rejected please go ahead with the July 9th patch. The July 9th Table Function API patch mentioned above is now in CVS, so here is an updated version of the guc patch which should apply cleanly against CVS tip. Joe Conway
2002-07-20 01:49:28 -04:00
typedef struct TupOutputState
{
Code review for standalone composite types, query-specified composite types, SRFs. Not happy with memory management yet, but I'll commit these other changes.
2002-08-28 20:17:06 -04:00
/* use "struct" here to allow forward reference */
struct AttInMetadata *metadata;
Revise TupleTableSlot code to avoid unnecessary construction and disassembly of tuples when passing data up through multiple plan nodes. A slot can now hold either a normal "physical" HeapTuple, or a "virtual" tuple consisting of Datum/isnull arrays. Upper plan levels can usually just copy the Datum arrays, avoiding heap_formtuple() and possible subsequent nocachegetattr() calls to extract the data again. This work extends Atsushi Ogawa's earlier patch, which provided the key idea of adding Datum arrays to TupleTableSlots. (I believe however that something like this was foreseen way back in Berkeley days --- see the old comment on ExecProject.) A test case involving many levels of join of fairly wide tables (about 80 columns altogether) showed about 3x overall speedup, though simple queries will probably not be helped very much. I have also duplicated some code in heaptuple.c in order to provide versions of heap_formtuple and friends that use "bool" arrays to indicate null attributes, instead of the old convention of "char" arrays containing either 'n' or ' '. This provides a better match to the convention used by ExecEvalExpr. While I have not made a concerted effort to get rid of uses of the old routines, I think they should be deprecated and eventually removed.
2005-03-16 16:38:10 -05:00
TupleTableSlot *slot;
Restructure command destination handling so that we pass around DestReceiver pointers instead of just CommandDest values. The DestReceiver is made at the point where the destination is selected, rather than deep inside the executor. This cleans up the original kluge implementation of tstoreReceiver.c, and makes it easy to support retrieving results from utility statements inside portals. Thus, you can now do fun things like Bind and Execute a FETCH or EXPLAIN command, and it'll all work as expected (e.g., you can Describe the portal, or use Execute's count parameter to suspend the output partway through). Implementation involves stuffing the utility command's output into a Tuplestore, which would be kind of annoying for huge output sets, but should be quite acceptable for typical uses of utility commands.
2003-05-06 16:26:28 -04:00
DestReceiver *dest;
> 2. This patch includes the same Table Function API fixes that I > submitted on July 9: > > http://archives.postgresql.org/pgsql-patches/2002-07/msg00056.php > > Please disregard that one *if* this one is applied. If this one is > rejected please go ahead with the July 9th patch. The July 9th Table Function API patch mentioned above is now in CVS, so here is an updated version of the guc patch which should apply cleanly against CVS tip. Joe Conway
2002-07-20 01:49:28 -04:00
} TupOutputState;
Restructure command destination handling so that we pass around DestReceiver pointers instead of just CommandDest values. The DestReceiver is made at the point where the destination is selected, rather than deep inside the executor. This cleans up the original kluge implementation of tstoreReceiver.c, and makes it easy to support retrieving results from utility statements inside portals. Thus, you can now do fun things like Bind and Execute a FETCH or EXPLAIN command, and it'll all work as expected (e.g., you can Describe the portal, or use Execute's count parameter to suspend the output partway through). Implementation involves stuffing the utility command's output into a Tuplestore, which would be kind of annoying for huge output sets, but should be quite acceptable for typical uses of utility commands.
2003-05-06 16:26:28 -04:00
extern TupOutputState *begin_tup_output_tupdesc(DestReceiver *dest,
pgindent run.
2003-08-03 20:43:34 -04:00
TupleDesc tupdesc);
> 2. This patch includes the same Table Function API fixes that I > submitted on July 9: > > http://archives.postgresql.org/pgsql-patches/2002-07/msg00056.php > > Please disregard that one *if* this one is applied. If this one is > rejected please go ahead with the July 9th patch. The July 9th Table Function API patch mentioned above is now in CVS, so here is an updated version of the guc patch which should apply cleanly against CVS tip. Joe Conway
2002-07-20 01:49:28 -04:00
extern void do_tup_output(TupOutputState *tstate, char **values);
extern void do_text_output_multiline(TupOutputState *tstate, char *text);
extern void end_tup_output(TupOutputState *tstate);
Code review for standalone composite types, query-specified composite types, SRFs. Not happy with memory management yet, but I'll commit these other changes.
2002-08-28 20:17:06 -04:00
/*
* Write a single line of text given as a C string.
*
* Should only be used with a single-TEXT-attribute tupdesc.
*/
#define do_text_output_oneline(tstate, text_to_emit) \
> 2. This patch includes the same Table Function API fixes that I > submitted on July 9: > > http://archives.postgresql.org/pgsql-patches/2002-07/msg00056.php > > Please disregard that one *if* this one is applied. If this one is > rejected please go ahead with the July 9th patch. The July 9th Table Function API patch mentioned above is now in CVS, so here is an updated version of the guc patch which should apply cleanly against CVS tip. Joe Conway
2002-07-20 01:49:28 -04:00
do { \
Code review for SHOW output changes; fix horology expected files for new SHOW output format.
2002-07-20 11:12:56 -04:00
char *values_[1]; \
Code review for standalone composite types, query-specified composite types, SRFs. Not happy with memory management yet, but I'll commit these other changes.
2002-08-28 20:17:06 -04:00
values_[0] = (text_to_emit); \
Code review for SHOW output changes; fix horology expected files for new SHOW output format.
2002-07-20 11:12:56 -04:00
do_tup_output(tstate, values_); \
> 2. This patch includes the same Table Function API fixes that I > submitted on July 9: > > http://archives.postgresql.org/pgsql-patches/2002-07/msg00056.php > > Please disregard that one *if* this one is applied. If this one is > rejected please go ahead with the July 9th patch. The July 9th Table Function API patch mentioned above is now in CVS, so here is an updated version of the guc patch which should apply cleanly against CVS tip. Joe Conway
2002-07-20 01:49:28 -04:00
} while (0)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
/*
Add missing function prototypes to stifle gcc warnings.
1999-04-16 17:27:23 -04:00
* prototypes from functions in execUtils.c
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 02:22:35 -04:00
*/
Revise executor APIs so that all per-query state structure is built in a per-query memory context created by CreateExecutorState --- and destroyed by FreeExecutorState. This provides a final solution to the longstanding problem of memory leaked by various ExecEndNode calls.
2002-12-15 11:17:59 -05:00
extern EState *CreateExecutorState(void);
extern void FreeExecutorState(EState *estate);
extern ExprContext *CreateExprContext(EState *estate);
First stage of reclaiming memory in executor by resetting short-term memory contexts. Currently, only leaks in expressions executed as quals or projections are handled. Clean up some old dead cruft in executor while at it --- unused fields in state nodes, that sort of thing.
2000-07-11 22:37:39 -04:00
extern void FreeExprContext(ExprContext *econtext);
Ensure set-returning functions in the targetlist of a plan node will be shut down cleanly if the plan node is ReScanned before the SRFs are run to completion. This fixes the problem for SQL-language functions, but still need work on functions using the SRF_XXX() macros.
2003-12-18 15:21:37 -05:00
extern void ReScanExprContext(ExprContext *econtext);
First stage of reclaiming memory in executor by resetting short-term memory contexts. Currently, only leaks in expressions executed as quals or projections are handled. Clean up some old dead cruft in executor while at it --- unused fields in state nodes, that sort of thing.
2000-07-11 22:37:39 -04:00
#define ResetExprContext(econtext) \
MemoryContextReset((econtext)->ecxt_per_tuple_memory)
Clean up per-tuple memory leaks in trigger firing and plpgsql expression evaluation.
2001-01-21 19:50:07 -05:00
extern ExprContext *MakePerTupleExprContext(EState *estate);
/* Get an EState's per-output-tuple exprcontext, making it if first use */
#define GetPerTupleExprContext(estate) \
((estate)->es_per_tuple_exprcontext ? \
(estate)->es_per_tuple_exprcontext : \
MakePerTupleExprContext(estate))
#define GetPerTupleMemoryContext(estate) \
(GetPerTupleExprContext(estate)->ecxt_per_tuple_memory)
/* Reset an EState's per-output-tuple exprcontext, if one's been created */
#define ResetPerTupleExprContext(estate) \
do { \
if ((estate)->es_per_tuple_exprcontext) \
ResetExprContext((estate)->es_per_tuple_exprcontext); \
} while (0)
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void ExecAssignExprContext(EState *estate, PlanState *planstate);
extern void ExecAssignResultType(PlanState *planstate,
Revise executor APIs so that all per-query state structure is built in a per-query memory context created by CreateExecutorState --- and destroyed by FreeExecutorState. This provides a final solution to the longstanding problem of memory leaked by various ExecEndNode calls.
2002-12-15 11:17:59 -05:00
TupleDesc tupDesc, bool shouldFree);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void ExecAssignResultTypeFromTL(PlanState *planstate);
extern TupleDesc ExecGetResultType(PlanState *planstate);
First cut at implementing IN (and NOT IN) via hashtables. There is more to be done yet, but this is a good start.
2003-01-11 23:03:34 -05:00
extern ProjectionInfo *ExecBuildProjectionInfo(List *targetList,
pgindent run.
2003-08-03 20:43:34 -04:00
ExprContext *econtext,
TupleTableSlot *slot);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void ExecAssignProjectionInfo(PlanState *planstate);
extern void ExecFreeExprContext(PlanState *planstate);
extern TupleDesc ExecGetScanType(ScanState *scanstate);
extern void ExecAssignScanType(ScanState *scanstate,
Revise executor APIs so that all per-query state structure is built in a per-query memory context created by CreateExecutorState --- and destroyed by FreeExecutorState. This provides a final solution to the longstanding problem of memory leaked by various ExecEndNode calls.
2002-12-15 11:17:59 -05:00
TupleDesc tupDesc, bool shouldFree);
Another pgindent run with updated typedefs.
2003-08-08 17:42:59 -04:00
extern void ExecAssignScanTypeFromOuterPlan(ScanState *scanstate);
Revise executor APIs so that all per-query state structure is built in a per-query memory context created by CreateExecutorState --- and destroyed by FreeExecutorState. This provides a final solution to the longstanding problem of memory leaked by various ExecEndNode calls.
2002-12-15 11:17:59 -05:00
Tweak indexscan machinery to avoid taking an AccessShareLock on an index if we already have a stronger lock due to the index's table being the update target table of the query. Same optimization I applied earlier at the table level. There doesn't seem to be much interest in the more radical idea of not locking indexes at all, so do what we can ...
2005-12-03 00:51:03 -05:00
extern bool ExecRelationIsTargetRelation(EState *estate, Index scanrelid);
Adjust scan plan nodes to avoid getting an extra AccessShareLock on a relation if it's already been locked by execMain.c as either a result relation or a FOR UPDATE/SHARE relation. This avoids an extra trip to the shared lock manager state. Per my suggestion yesterday.
2005-12-02 15:03:42 -05:00
extern Relation ExecOpenScanRelation(EState *estate, Index scanrelid);
extern void ExecCloseScanRelation(Relation scanrel);
Restructure handling of inheritance queries so that they work with outer joins, and clean things up a good deal at the same time. Append plan node no longer hacks on rangetable at runtime --- instead, all child tables are given their own RT entries during planning. Concept of multiple target tables pushed up into execMain, replacing bug-prone implementation within nodeAppend. Planner now supports generating Append plans for inheritance sets either at the top of the plan (the old way) or at the bottom. Expanding at the bottom is appropriate for tables used as sources, since they may appear inside an outer join; but we must still expand at the top when the target of an UPDATE or DELETE is an inheritance set, because we actually need a different targetlist and junkfilter for each target table in that case. Fortunately a target table can't be inside an outer join... Bizarre mutual recursion between union_planner and prepunion.c is gone --- in fact, union_planner doesn't really have much to do with union queries anymore, so I renamed it grouping_planner.
2000-11-11 19:37:02 -05:00
extern void ExecOpenIndices(ResultRelInfo *resultRelInfo);
extern void ExecCloseIndices(ResultRelInfo *resultRelInfo);
OK, folks, here is the pgindent output.
1998-09-01 00:40:42 -04:00
extern void ExecInsertIndexTuples(TupleTableSlot *slot, ItemPointer tupleid,
Mark index entries "killed" when they are no longer visible to any transaction, so as to avoid returning them out of the index AM. Saves repeated heap_fetch operations on frequently-updated rows. Also detect queries on unique keys (equality to all columns of a unique index), and don't bother continuing scan once we have found first match. Killing is implemented in the btree and hash AMs, but not yet in rtree or gist, because there isn't an equally convenient place to do it in those AMs (the outer amgetnext routine can't do it without re-pinning the index page). Did some small cleanup on APIs of HeapTupleSatisfies, heap_fetch, and index_insert to make this a little easier.
2002-05-24 14:57:57 -04:00
EState *estate, bool is_vacuum);
Another pgindent run. Fixes enum indenting, and improves #endif spacing. Also adds space for one-line comments.
2001-10-28 01:26:15 -05:00
First pass at set-returning-functions in FROM, by Joe Conway with some kibitzing from Tom Lane. Not everything works yet, and there's no documentation or regression test, but let's commit this so Joe doesn't need to cope with tracking changes in so many files ...
2002-05-12 16:10:05 -04:00
extern void RegisterExprContextCallback(ExprContext *econtext,
pgindent run.
2002-09-04 16:31:48 -04:00
ExprContextCallbackFunction function,
Datum arg);
First pass at set-returning-functions in FROM, by Joe Conway with some kibitzing from Tom Lane. Not everything works yet, and there's no documentation or regression test, but let's commit this so Joe doesn't need to cope with tracking changes in so many files ...
2002-05-12 16:10:05 -04:00
extern void UnregisterExprContextCallback(ExprContext *econtext,
pgindent run.
2002-09-04 16:31:48 -04:00
ExprContextCallbackFunction function,
Datum arg);
First pass at set-returning-functions in FROM, by Joe Conway with some kibitzing from Tom Lane. Not everything works yet, and there's no documentation or regression test, but let's commit this so Joe doesn't need to cope with tracking changes in so many files ...
2002-05-12 16:10:05 -04:00
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass.
2001-11-05 12:46:40 -05:00
#endif /* EXECUTOR_H */
Reference in a new issue Copy permalink