database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-12 05:01:15 +03:00
Code Activity

Back out cleanup patch. Got old version and needs work.

Browse Source 
Neil Conway
This commit is contained in:
Bruce Momjian
2002-06-25 17:58:10 +00:00
parent ed275aea42
commit e2c007046f
13 changed files with 98 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
src/backend/executor/execMain.c
View File

@@ -27,7 +27,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.166 2002/06/25 17:27:20 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.167 2002/06/25 17:58:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -62,14 +62,14 @@ static TupleTableSlot *ExecutePlan(EState *estate, Plan *plan,
long numberTuples,
ScanDirection direction,
DestReceiver *destfunc);
static void ExecSelect(TupleTableSlot *slot,
static void ExecRetrieve(TupleTableSlot *slot,
DestReceiver *destfunc,
EState *estate);
static void ExecInsert(TupleTableSlot *slot, ItemPointer tupleid,
static void ExecAppend(TupleTableSlot *slot, ItemPointer tupleid,
EState *estate);
static void ExecDelete(TupleTableSlot *slot, ItemPointer tupleid,
EState *estate);
static void ExecUpdate(TupleTableSlot *slot, ItemPointer tupleid,
static void ExecReplace(TupleTableSlot *slot, ItemPointer tupleid,
EState *estate);
static TupleTableSlot *EvalPlanQualNext(EState *estate);
static void EndEvalPlanQual(EState *estate);
@@ -251,7 +251,7 @@ ExecCheckQueryPerms(CmdType operation, Query *parseTree, Plan *plan)
ExecCheckRTPerms(parseTree->rtable, operation);
/*
* Search for subplans and INSERT nodes to check their rangetables.
* Search for subplans and APPEND nodes to check their rangetables.
*/
ExecCheckPlanPerms(plan, parseTree->rtable, operation);
}
@@ -583,7 +583,7 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
/*
* Get the tuple descriptor describing the type of tuples to return.
* (this is especially important if we are creating a relation with
* "SELECT INTO")
* "retrieve into")
*/
tupType = ExecGetTupType(plan); /* tuple descriptor */
@@ -892,7 +892,7 @@ EndPlan(Plan *plan, EState *estate)
* Retrieves all tuples if numberTuples is 0
*
* result is either a slot containing the last tuple in the case
* of a SELECT or NULL otherwise.
* of a RETRIEVE or NULL otherwise.
*
* Note: the ctid attribute is a 'junk' attribute that is removed before the
* user can see it
@@ -1068,26 +1068,29 @@ lnext: ;
slot = ExecStoreTuple(newTuple, /* tuple to store */
junkfilter->jf_resultSlot, /* dest slot */
InvalidBuffer, /* this tuple has no buffer */
InvalidBuffer, /* this tuple has no
* buffer */
true); /* tuple should be pfreed */
}
} /* if (junkfilter... */
/*
* now that we have a tuple, do the appropriate thing with it..
* either return it to the user, add it to a relation someplace,
* delete it from a relation, or modify some of its attributes.
*/
switch (operation)
{
case CMD_SELECT:
ExecSelect(slot, /* slot containing tuple */
destfunc, /* destination's tuple-receiver obj */
estate);
ExecRetrieve(slot, /* slot containing tuple */
destfunc, /* destination's tuple-receiver
* obj */
estate); /* */
result = slot;
break;
case CMD_INSERT:
ExecInsert(slot, tupleid, estate);
ExecAppend(slot, tupleid, estate);
result = NULL;
break;
@@ -1097,7 +1100,7 @@ lnext: ;
break;
case CMD_UPDATE:
ExecUpdate(slot, tupleid, estate);
ExecReplace(slot, tupleid, estate);
result = NULL;
break;
@@ -1118,25 +1121,25 @@ lnext: ;
/*
* here, result is either a slot containing a tuple in the case of a
* SELECT or NULL otherwise.
* RETRIEVE or NULL otherwise.
*/
return result;
}
/* ----------------------------------------------------------------
* ExecSelect
* ExecRetrieve
*
* SELECTs are easy.. we just pass the tuple to the appropriate
* RETRIEVEs are easy.. we just pass the tuple to the appropriate
* print function. The only complexity is when we do a
* "SELECT INTO", in which case we insert the tuple into
* "retrieve into", in which case we insert the tuple into
* the appropriate relation (note: this is a newly created relation
* so we don't need to worry about indices or locks.)
* ----------------------------------------------------------------
*/
static void
ExecSelect(TupleTableSlot *slot,
DestReceiver *destfunc,
EState *estate)
ExecRetrieve(TupleTableSlot *slot,
DestReceiver *destfunc,
EState *estate)
{
HeapTuple tuple;
TupleDesc attrtype;
@@ -1166,15 +1169,16 @@ ExecSelect(TupleTableSlot *slot,
}
/* ----------------------------------------------------------------
* ExecInsert
* ExecAppend
*
* INSERTs are trickier.. we have to insert the tuple into
* APPENDs are trickier.. we have to insert the tuple into
* the base relation and insert appropriate tuples into the
* index relations.
* ----------------------------------------------------------------
*/
static void
ExecInsert(TupleTableSlot *slot,
ExecAppend(TupleTableSlot *slot,
ItemPointer tupleid,
EState *estate)
{
@@ -1223,7 +1227,7 @@ ExecInsert(TupleTableSlot *slot,
* Check the constraints of the tuple
*/
if (resultRelationDesc->rd_att->constr)
ExecConstraints("ExecInsert", resultRelInfo, slot, estate);
ExecConstraints("ExecAppend", resultRelInfo, slot, estate);
/*
* insert the tuple
@@ -1255,7 +1259,7 @@ ExecInsert(TupleTableSlot *slot,
/* ----------------------------------------------------------------
* ExecDelete
*
* DELETE is like UPDATE, we delete the tuple and its
* DELETE is like append, we delete the tuple and its
* index tuples.
* ----------------------------------------------------------------
*/
@@ -1342,18 +1346,18 @@ ldelete:;
}
/* ----------------------------------------------------------------
* ExecUpdate
* ExecReplace
*
* note: we can't run UPDATE queries with transactions
* off because UPDATEs are actually INSERTs and our
* scan will mistakenly loop forever, updating the tuple
* it just inserted.. This should be fixed but until it
* note: we can't run replace queries with transactions
* off because replaces are actually appends and our
* scan will mistakenly loop forever, replacing the tuple
* it just appended.. This should be fixed but until it
* is, we don't want to get stuck in an infinite loop
* which corrupts your database..
* ----------------------------------------------------------------
*/
static void
ExecUpdate(TupleTableSlot *slot,
ExecReplace(TupleTableSlot *slot,
ItemPointer tupleid,
EState *estate)
{
@@ -1369,7 +1373,7 @@ ExecUpdate(TupleTableSlot *slot,
*/
if (IsBootstrapProcessingMode())
{
elog(WARNING, "ExecUpdate: UPDATE can't run without transactions");
elog(WARNING, "ExecReplace: replace can't run without transactions");
return;
}
@@ -1420,7 +1424,7 @@ ExecUpdate(TupleTableSlot *slot,
*/
lreplace:;
if (resultRelationDesc->rd_att->constr)
ExecConstraints("ExecUpdate", resultRelInfo, slot, estate);
ExecConstraints("ExecReplace", resultRelInfo, slot, estate);
/*
* replace the heap tuple
@@ -1468,7 +1472,7 @@ lreplace:;
/*
* Note: instead of having to update the old index tuples associated
* with the heap tuple, all we do is form and insert new index tuples.
* This is because UPDATEs are actually DELETEs and INSERTs and index
* This is because replaces are actually deletes and inserts and index
* tuple deletion is done automagically by the vacuum daemon. All we
* do is insert new index tuples. -cim 9/27/89
*/
@@ -1477,7 +1481,7 @@ lreplace:;
* process indices
*
* heap_update updates a tuple in the base relation by invalidating it
* and then inserting a new tuple to the relation. As a side effect,
* and then appending a new tuple to the relation. As a side effect,
* the tupleid of the new tuple is placed in the new tuple's t_ctid
* field. So we now insert index tuples using the new tupleid stored
* there.
@@ -1550,7 +1554,7 @@ ExecRelCheck(ResultRelInfo *resultRelInfo,
}
void
ExecConstraints(const char *caller, ResultRelInfo *resultRelInfo,
ExecConstraints(char *caller, ResultRelInfo *resultRelInfo,
TupleTableSlot *slot, EState *estate)
{
Relation rel = resultRelInfo->ri_RelationDesc;

4
src/backend/executor/execUtils.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.84 2002/06/25 17:27:20 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.85 2002/06/25 17:58:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -18,7 +18,7 @@
*
* ExecOpenIndices \
* ExecCloseIndices | referenced by InitPlan, EndPlan,
* ExecInsertIndexTuples / ExecInsert, ExecUpdate
* ExecInsertIndexTuples / ExecAppend, ExecReplace
*
* RegisterExprContextCallback Register function shutdown callback
* UnregisterExprContextCallback Deregister function shutdown callback

12
src/backend/optimizer/path/costsize.c
View File

@@ -42,7 +42,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.86 2002/06/25 17:27:20 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.87 2002/06/25 17:58:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -154,11 +154,11 @@ cost_seqscan(Path *path, Query *root,
*
* Given a guesstimated cache size, we estimate the actual I/O cost per page
* with the entirely ad-hoc equations:
* if relpages >= effective_cache_size:
* random_page_cost * (1 - (effective_cache_size/relpages)/2)
* if relpages < effective_cache_size:
* 1 + (random_page_cost/2-1) * (relpages/effective_cache_size) ** 2
* These give the right asymptotic behavior (=> 1.0 as relpages becomes
* for rel_size <= effective_cache_size:
* 1 + (random_page_cost/2-1) * (rel_size/effective_cache_size) ** 2
* for rel_size >= effective_cache_size:
* random_page_cost * (1 - (effective_cache_size/rel_size)/2)
* These give the right asymptotic behavior (=> 1.0 as rel_size becomes
* small, => random_page_cost as it becomes large) and meet in the middle
* with the estimate that the cache is about 50% effective for a relation
* of the same size as effective_cache_size. (XXX this is probably all

17
src/backend/optimizer/prep/_deadcode/prepkeyset.c
View File

@@ -1,7 +1,7 @@
/*-------------------------------------------------------------------------
*
* prepkeyset.c
* Special preparation for keyset queries (KSQO).
* Special preperation for keyset queries.
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
@@ -14,6 +14,12 @@
#include "postgres.h"
#include "optimizer/planmain.h"
/*
* Node_Copy
* a macro to simplify calling of copyObject on the specified field
*/
#define Node_Copy(from, newnode, field) newnode->field = copyObject(from->field)
bool _use_keyset_query_optimizer = FALSE;
#ifdef ENABLE_KEY_SET_QUERY
@@ -49,20 +55,13 @@ static int TotalExpr;
* a HAVING, or a GROUP BY. It must be a single table and have KSQO
* set to 'on'.
*
* The primary use of this transformation is to avoid the exponential
* The primary use of this transformation is to avoid the exponrntial
* memory consumption of cnfify() and to make use of index access
* methods.
*
* daveh@insightdist.com 1998-08-31
*
* May want to also prune out duplicate terms.
*
* XXX: this code is currently not compiled because it has not been
* updated to work with the re-implementation of UNION/INTERSECT/EXCEPT
* in PostgreSQL 7.1. However, it is of questionable value in any
* case, because it changes the semantics of the original query:
* UNION will add an implicit SELECT DISTINCT, which might change
* the results that are returned.
**********************************************************************/
void
transformKeySetQuery(Query *origNode)