mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-08-20 06:43:24 +02:00
1193 lines
33 KiB
C
1193 lines
33 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* execUtils.c--
|
|
* miscellanious executor utility routines
|
|
*
|
|
* Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.9 1997/06/13 03:24:26 vadim Exp $
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
/*
|
|
* INTERFACE ROUTINES
|
|
* ExecAssignNodeBaseInfo \
|
|
* ExecAssignDebugHooks > preforms misc work done in all the
|
|
* ExecAssignExprContext / init node routines.
|
|
*
|
|
* ExecGetTypeInfo | old execCStructs interface
|
|
* ExecMakeTypeInfo | code from the version 1
|
|
* ExecOrderTypeInfo | lisp system. These should
|
|
* ExecSetTypeInfo | go away or be updated soon.
|
|
* ExecFreeTypeInfo | -cim 11/1/89
|
|
* ExecTupleAttributes /
|
|
*
|
|
|
|
* QueryDescGetTypeInfo - moved here from main.c
|
|
* am not sure what uses it -cim 10/12/89
|
|
*
|
|
* ExecGetIndexKeyInfo \
|
|
* ExecOpenIndices | referenced by InitPlan, EndPlan,
|
|
* ExecCloseIndices | ExecAppend, ExecReplace
|
|
* ExecFormIndexTuple |
|
|
* ExecInsertIndexTuple /
|
|
*
|
|
* NOTES
|
|
* This file has traditionally been the place to stick misc.
|
|
* executor support stuff that doesn't really go anyplace else.
|
|
*
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
#include "fmgr.h"
|
|
|
|
#include "executor/executor.h"
|
|
#include "executor/execdebug.h"
|
|
#include "access/itup.h"
|
|
#include "access/heapam.h"
|
|
#include "access/genam.h"
|
|
#include "optimizer/clauses.h"
|
|
#include "utils/palloc.h"
|
|
#include "utils/mcxt.h"
|
|
#include "commands/command.h"
|
|
#include "catalog/index.h"
|
|
#include "catalog/catname.h"
|
|
#include "catalog/pg_proc.h"
|
|
#include "catalog/pg_type.h"
|
|
#include "parser/parsetree.h"
|
|
|
|
/* ----------------------------------------------------------------
|
|
* global counters for number of tuples processed, retrieved,
|
|
* appended, replaced, deleted.
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
int NTupleProcessed;
|
|
int NTupleRetrieved;
|
|
int NTupleReplaced;
|
|
int NTupleAppended;
|
|
int NTupleDeleted;
|
|
int NIndexTupleInserted;
|
|
extern int NIndexTupleProcessed; /* have to be defined in the access
|
|
method level so that the cinterface.a
|
|
will link ok. */
|
|
|
|
/* ----------------------------------------------------------------
|
|
* statistic functions
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
|
|
/* ----------------------------------------------------------------
|
|
* ResetTupleCount
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
void
|
|
ResetTupleCount(void)
|
|
{
|
|
NTupleProcessed = 0;
|
|
NTupleRetrieved = 0;
|
|
NTupleAppended = 0;
|
|
NTupleDeleted = 0;
|
|
NTupleReplaced = 0;
|
|
NIndexTupleProcessed = 0;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* PrintTupleCount
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
void
|
|
DisplayTupleCount(FILE *statfp)
|
|
{
|
|
if (NTupleProcessed > 0)
|
|
fprintf(statfp, "!\t%d tuple%s processed, ", NTupleProcessed,
|
|
(NTupleProcessed == 1) ? "" : "s");
|
|
else {
|
|
fprintf(statfp, "!\tno tuples processed.\n");
|
|
return;
|
|
}
|
|
if (NIndexTupleProcessed > 0)
|
|
fprintf(statfp, "%d indextuple%s processed, ", NIndexTupleProcessed,
|
|
(NIndexTupleProcessed == 1) ? "" : "s");
|
|
if (NIndexTupleInserted > 0)
|
|
fprintf(statfp, "%d indextuple%s inserted, ", NIndexTupleInserted,
|
|
(NIndexTupleInserted == 1) ? "" : "s");
|
|
if (NTupleRetrieved > 0)
|
|
fprintf(statfp, "%d tuple%s retrieved. ", NTupleRetrieved,
|
|
(NTupleRetrieved == 1) ? "" : "s");
|
|
if (NTupleAppended > 0)
|
|
fprintf(statfp, "%d tuple%s appended. ", NTupleAppended,
|
|
(NTupleAppended == 1) ? "" : "s");
|
|
if (NTupleDeleted > 0)
|
|
fprintf(statfp, "%d tuple%s deleted. ", NTupleDeleted,
|
|
(NTupleDeleted == 1) ? "" : "s");
|
|
if (NTupleReplaced > 0)
|
|
fprintf(statfp, "%d tuple%s replaced. ", NTupleReplaced,
|
|
(NTupleReplaced == 1) ? "" : "s");
|
|
fprintf(statfp, "\n");
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* miscellanious init node support functions
|
|
*
|
|
* ExecAssignNodeBaseInfo - assigns the baseid field of the node
|
|
* ExecAssignDebugHooks - assigns the node's debugging hooks
|
|
* ExecAssignExprContext - assigns the node's expression context
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
|
|
/* ----------------
|
|
* ExecAssignNodeBaseInfo
|
|
*
|
|
* as it says, this assigns the baseid field of the node and
|
|
* increments the counter in the estate. In addition, it initializes
|
|
* the base_parent field of the basenode.
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecAssignNodeBaseInfo(EState *estate, CommonState *cstate, Plan *parent)
|
|
{
|
|
int baseId;
|
|
|
|
baseId = estate->es_BaseId;
|
|
cstate->cs_base_id = baseId;
|
|
estate->es_BaseId = baseId + 1;
|
|
}
|
|
|
|
/* ----------------
|
|
* ExecAssignExprContext
|
|
*
|
|
* This initializes the ExprContext field. It is only necessary
|
|
* to do this for nodes which use ExecQual or ExecTargetList
|
|
* because those routines depend on econtext. Other nodes which
|
|
* dont have to evaluate expressions don't need to do this.
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecAssignExprContext(EState *estate, CommonState *commonstate)
|
|
{
|
|
ExprContext *econtext;
|
|
ParamListInfo paraminfo;
|
|
List *rangeTable;
|
|
|
|
paraminfo = estate->es_param_list_info;
|
|
rangeTable = estate->es_range_table;
|
|
|
|
econtext = makeNode(ExprContext);
|
|
econtext->ecxt_scantuple = NULL; /* scan tuple slot */
|
|
econtext->ecxt_innertuple = NULL; /* inner tuple slot */
|
|
econtext->ecxt_outertuple = NULL; /* outer tuple slot */
|
|
econtext->ecxt_relation = NULL; /* relation */
|
|
econtext->ecxt_relid = 0; /* relid */
|
|
econtext->ecxt_param_list_info = paraminfo; /* param list info */
|
|
econtext->ecxt_range_table = rangeTable; /* range table */
|
|
|
|
commonstate->cs_ExprContext = econtext;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* Result slot tuple type and ProjectionInfo support
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
|
|
/* ----------------
|
|
* ExecAssignResultType
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecAssignResultType(CommonState *commonstate,
|
|
TupleDesc tupDesc)
|
|
{
|
|
TupleTableSlot *slot;
|
|
|
|
slot = commonstate->cs_ResultTupleSlot;
|
|
slot->ttc_tupleDescriptor = tupDesc;
|
|
}
|
|
|
|
/* ----------------
|
|
* ExecAssignResultTypeFromOuterPlan
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecAssignResultTypeFromOuterPlan(Plan *node, CommonState *commonstate)
|
|
{
|
|
Plan *outerPlan;
|
|
TupleDesc tupDesc;
|
|
|
|
outerPlan = outerPlan(node);
|
|
tupDesc = ExecGetTupType(outerPlan);
|
|
|
|
ExecAssignResultType(commonstate, tupDesc);
|
|
}
|
|
|
|
/* ----------------
|
|
* ExecAssignResultTypeFromTL
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecAssignResultTypeFromTL(Plan *node, CommonState *commonstate)
|
|
{
|
|
List *targetList;
|
|
int i;
|
|
int len;
|
|
List *tl;
|
|
TargetEntry *tle;
|
|
List *fjtl;
|
|
TupleDesc origTupDesc;
|
|
|
|
targetList = node->targetlist;
|
|
origTupDesc = ExecTypeFromTL(targetList);
|
|
len = ExecTargetListLength(targetList);
|
|
|
|
fjtl = NIL;
|
|
tl = targetList;
|
|
i = 0;
|
|
while (tl != NIL || fjtl != NIL) {
|
|
if (fjtl != NIL) {
|
|
tle = lfirst(fjtl);
|
|
fjtl = lnext(fjtl);
|
|
}
|
|
else {
|
|
tle = lfirst(tl);
|
|
tl = lnext(tl);
|
|
}
|
|
#ifdef SETS_FIXED
|
|
if (!tl_is_resdom(tle)) {
|
|
Fjoin *fj = (Fjoin *)lfirst(tle);
|
|
/* it is a FJoin */
|
|
fjtl = lnext(tle);
|
|
tle = fj->fj_innerNode;
|
|
}
|
|
#endif
|
|
i++;
|
|
}
|
|
if (len > 0) {
|
|
ExecAssignResultType(commonstate,
|
|
origTupDesc);
|
|
}
|
|
else
|
|
ExecAssignResultType(commonstate,
|
|
(TupleDesc)NULL);
|
|
}
|
|
|
|
/* ----------------
|
|
* ExecGetResultType
|
|
* ----------------
|
|
*/
|
|
TupleDesc
|
|
ExecGetResultType(CommonState *commonstate)
|
|
{
|
|
TupleTableSlot *slot = commonstate->cs_ResultTupleSlot;
|
|
|
|
return slot->ttc_tupleDescriptor;
|
|
}
|
|
|
|
/* ----------------
|
|
* ExecFreeResultType
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecFreeResultType(CommonState *commonstate)
|
|
{
|
|
TupleTableSlot *slot;
|
|
TupleDesc tupType;
|
|
|
|
slot = commonstate->cs_ResultTupleSlot;
|
|
tupType = slot->ttc_tupleDescriptor;
|
|
|
|
/* ExecFreeTypeInfo(tupType); */
|
|
pfree(tupType);
|
|
}
|
|
|
|
|
|
/* ----------------
|
|
* ExecAssignProjectionInfo
|
|
forms the projection information from the node's targetlist
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecAssignProjectionInfo(Plan *node, CommonState *commonstate)
|
|
{
|
|
ProjectionInfo *projInfo;
|
|
List *targetList;
|
|
int len;
|
|
|
|
targetList = node->targetlist;
|
|
len = ExecTargetListLength(targetList);
|
|
|
|
projInfo = makeNode(ProjectionInfo);
|
|
projInfo->pi_targetlist = targetList;
|
|
projInfo->pi_len = len;
|
|
projInfo->pi_tupValue =
|
|
(len <= 0) ? NULL : (Datum *) palloc(sizeof(Datum) * len);
|
|
projInfo->pi_exprContext = commonstate->cs_ExprContext;
|
|
projInfo->pi_slot = commonstate->cs_ResultTupleSlot;
|
|
|
|
commonstate->cs_ProjInfo = projInfo;
|
|
}
|
|
|
|
|
|
/* ----------------
|
|
* ExecFreeProjectionInfo
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecFreeProjectionInfo(CommonState *commonstate)
|
|
{
|
|
ProjectionInfo *projInfo;
|
|
|
|
/* ----------------
|
|
* get projection info. if NULL then this node has
|
|
* none so we just return.
|
|
* ----------------
|
|
*/
|
|
projInfo = commonstate->cs_ProjInfo;
|
|
if (projInfo == NULL)
|
|
return;
|
|
|
|
/* ----------------
|
|
* clean up memory used.
|
|
* ----------------
|
|
*/
|
|
if (projInfo->pi_tupValue != NULL)
|
|
pfree(projInfo->pi_tupValue);
|
|
|
|
pfree(projInfo);
|
|
commonstate->cs_ProjInfo = NULL;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* the following scan type support functions are for
|
|
* those nodes which are stubborn and return tuples in
|
|
* their Scan tuple slot instead of their Result tuple
|
|
* slot.. luck fur us, these nodes do not do projections
|
|
* so we don't have to worry about getting the ProjectionInfo
|
|
* right for them... -cim 6/3/91
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
|
|
/* ----------------
|
|
* ExecGetScanType
|
|
* ----------------
|
|
*/
|
|
TupleDesc
|
|
ExecGetScanType(CommonScanState *csstate)
|
|
{
|
|
TupleTableSlot *slot = csstate->css_ScanTupleSlot;
|
|
return slot->ttc_tupleDescriptor;
|
|
}
|
|
|
|
/* ----------------
|
|
* ExecFreeScanType
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecFreeScanType(CommonScanState *csstate)
|
|
{
|
|
TupleTableSlot *slot;
|
|
TupleDesc tupType;
|
|
|
|
slot = csstate->css_ScanTupleSlot;
|
|
tupType = slot->ttc_tupleDescriptor;
|
|
|
|
/* ExecFreeTypeInfo(tupType); */
|
|
pfree(tupType);
|
|
}
|
|
|
|
/* ----------------
|
|
* ExecAssignScanType
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecAssignScanType(CommonScanState *csstate,
|
|
TupleDesc tupDesc)
|
|
{
|
|
TupleTableSlot *slot;
|
|
|
|
slot = (TupleTableSlot *) csstate->css_ScanTupleSlot;
|
|
slot->ttc_tupleDescriptor = tupDesc;
|
|
}
|
|
|
|
/* ----------------
|
|
* ExecAssignScanTypeFromOuterPlan
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecAssignScanTypeFromOuterPlan(Plan *node, CommonScanState *csstate)
|
|
{
|
|
Plan *outerPlan;
|
|
TupleDesc tupDesc;
|
|
|
|
outerPlan = outerPlan(node);
|
|
tupDesc = ExecGetTupType(outerPlan);
|
|
|
|
ExecAssignScanType(csstate, tupDesc);
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
* ExecTypeFromTL support routines.
|
|
*
|
|
* these routines are used mainly from ExecTypeFromTL.
|
|
* -cim 6/12/90
|
|
*
|
|
* old comments
|
|
* Routines dealing with the structure 'attribute' which conatains
|
|
* the type information about attributes in a tuple:
|
|
*
|
|
* ExecMakeTypeInfo(noType) --
|
|
* returns pointer to array of 'noType' structure 'attribute'.
|
|
* ExecSetTypeInfo(index, typeInfo, attNum, attLen) --
|
|
* sets the element indexed by 'index' in typeInfo with
|
|
* the values: attNum, attLen.
|
|
* ExecFreeTypeInfo(typeInfo) --
|
|
* frees the structure 'typeInfo'.
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
|
|
/* ----------------
|
|
* ExecSetTypeInfo
|
|
*
|
|
* This initializes fields of a single attribute in a
|
|
* tuple descriptor from the specified parameters.
|
|
*
|
|
* XXX this duplicates much of the functionality of TupleDescInitEntry.
|
|
* the routines should be moved to the same place and be rewritten
|
|
* to share common code.
|
|
* ----------------
|
|
*/
|
|
#if 0
|
|
void
|
|
ExecSetTypeInfo(int index,
|
|
TupleDesc typeInfo,
|
|
Oid typeID,
|
|
int attNum,
|
|
int attLen,
|
|
char *attName,
|
|
bool attbyVal,
|
|
char attalign)
|
|
{
|
|
AttributeTupleForm att;
|
|
|
|
/* ----------------
|
|
* get attribute pointer and preform a sanity check..
|
|
* ----------------
|
|
*/
|
|
att = typeInfo[index];
|
|
if (att == NULL)
|
|
elog(WARN, "ExecSetTypeInfo: trying to assign through NULL");
|
|
|
|
/* ----------------
|
|
* assign values to the tuple descriptor, being careful not
|
|
* to copy a null attName..
|
|
*
|
|
* XXX it is unknown exactly what information is needed to
|
|
* initialize the attribute struct correctly so for now
|
|
* we use 0. this should be fixed -- otherwise we run the
|
|
* risk of using garbage data. -cim 5/5/91
|
|
* ----------------
|
|
*/
|
|
att->attrelid = 0; /* dummy value */
|
|
|
|
if (attName != (char *) NULL)
|
|
strncpy(att->attname.data, attName, NAMEDATALEN);
|
|
else
|
|
memset(att->attname.data,0,NAMEDATALEN);
|
|
|
|
att->atttypid = typeID;
|
|
att->attdefrel = 0; /* dummy value */
|
|
att->attnvals = 0; /* dummy value */
|
|
att->atttyparg = 0; /* dummy value */
|
|
att->attlen = attLen;
|
|
att->attnum = attNum;
|
|
att->attbound = 0; /* dummy value */
|
|
att->attbyval = attbyVal;
|
|
att->attcanindex = 0; /* dummy value */
|
|
att->attproc = 0; /* dummy value */
|
|
att->attnelems = 0; /* dummy value */
|
|
att->attcacheoff = -1;
|
|
att->attisset = false;
|
|
att->attalign = attalign;
|
|
}
|
|
|
|
/* ----------------
|
|
* ExecFreeTypeInfo frees the array of attrbutes
|
|
* created by ExecMakeTypeInfo and returned by ExecTypeFromTL...
|
|
* ----------------
|
|
*/
|
|
void
|
|
ExecFreeTypeInfo(TupleDesc typeInfo)
|
|
{
|
|
/* ----------------
|
|
* do nothing if asked to free a null pointer
|
|
* ----------------
|
|
*/
|
|
if (typeInfo == NULL)
|
|
return;
|
|
|
|
/* ----------------
|
|
* the entire array of typeinfo pointers created by
|
|
* ExecMakeTypeInfo was allocated with a single palloc()
|
|
* so we can deallocate the whole array with a single pfree().
|
|
* (we should not try and free all the elements in the array)
|
|
* -cim 6/12/90
|
|
* ----------------
|
|
*/
|
|
pfree(typeInfo);
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
* QueryDescGetTypeInfo
|
|
*
|
|
*| I don't know how this is used, all I know is that it
|
|
*| appeared one day in main.c so I moved it here. -cim 11/1/89
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
TupleDesc
|
|
QueryDescGetTypeInfo(QueryDesc *queryDesc)
|
|
{
|
|
Plan *plan;
|
|
TupleDesc tupleType;
|
|
List *targetList;
|
|
AttrInfo *attinfo = (AttrInfo *)palloc(sizeof(AttrInfo));
|
|
|
|
plan = queryDesc->plantree;
|
|
tupleType = (TupleDesc) ExecGetTupType(plan);
|
|
/*
|
|
targetList = plan->targetlist;
|
|
|
|
attinfo->numAttr = ExecTargetListLength(targetList);
|
|
attinfo->attrs = tupleType;
|
|
*/
|
|
attinfo->numAttr = tupleType->natts;
|
|
attinfo->attrs = tupleType->attrs;
|
|
return attinfo;
|
|
}
|
|
#endif
|
|
|
|
/* ----------------------------------------------------------------
|
|
* ExecInsertIndexTuples support
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
/* ----------------------------------------------------------------
|
|
* ExecGetIndexKeyInfo
|
|
*
|
|
* Extracts the index key attribute numbers from
|
|
* an index tuple form (i.e. a tuple from the pg_index relation)
|
|
* into an array of attribute numbers. The array and the
|
|
* size of the array are returned to the caller via return
|
|
* parameters.
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
void
|
|
ExecGetIndexKeyInfo(IndexTupleForm indexTuple,
|
|
int *numAttsOutP,
|
|
AttrNumber **attsOutP,
|
|
FuncIndexInfoPtr fInfoP)
|
|
{
|
|
int i;
|
|
int numKeys;
|
|
AttrNumber *attKeys;
|
|
|
|
/* ----------------
|
|
* check parameters
|
|
* ----------------
|
|
*/
|
|
if (numAttsOutP == NULL && attsOutP == NULL) {
|
|
elog(DEBUG, "ExecGetIndexKeyInfo: %s",
|
|
"invalid parameters: numAttsOutP and attsOutP must be non-NULL");
|
|
}
|
|
|
|
/* ----------------
|
|
* set the procid for a possible functional index.
|
|
* ----------------
|
|
*/
|
|
FIsetProcOid(fInfoP, indexTuple->indproc);
|
|
|
|
/* ----------------
|
|
* count the number of keys..
|
|
* ----------------
|
|
*/
|
|
numKeys = 0;
|
|
for (i=0; i<8 && indexTuple->indkey[i] != 0; i++)
|
|
numKeys++;
|
|
|
|
/* ----------------
|
|
* place number keys in callers return area
|
|
* or the number of arguments for a functional index.
|
|
*
|
|
* If we have a functional index then the number of
|
|
* attributes defined in the index must 1 (the function's
|
|
* single return value).
|
|
* ----------------
|
|
*/
|
|
if (FIgetProcOid(fInfoP) != InvalidOid) {
|
|
FIsetnArgs(fInfoP, numKeys);
|
|
(*numAttsOutP) = 1;
|
|
}
|
|
else
|
|
(*numAttsOutP) = numKeys;
|
|
|
|
if (numKeys < 1) {
|
|
elog(DEBUG, "ExecGetIndexKeyInfo: %s",
|
|
"all index key attribute numbers are zero!");
|
|
(*attsOutP) = NULL;
|
|
return;
|
|
}
|
|
|
|
/* ----------------
|
|
* allocate and fill in array of key attribute numbers
|
|
* ----------------
|
|
*/
|
|
CXT1_printf("ExecGetIndexKeyInfo: context is %d\n", CurrentMemoryContext);
|
|
|
|
attKeys = (AttrNumber*)
|
|
palloc(numKeys * sizeof(AttrNumber));
|
|
|
|
for (i=0; i<numKeys; i++)
|
|
attKeys[i] = indexTuple->indkey[i];
|
|
|
|
/* ----------------
|
|
* return array to caller.
|
|
* ----------------
|
|
*/
|
|
(*attsOutP) = attKeys;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* ExecOpenIndices
|
|
*
|
|
* Here we scan the pg_index relation to find indices
|
|
* associated with a given heap relation oid. Since we
|
|
* don't know in advance how many indices we have, we
|
|
* form lists containing the information we need from
|
|
* pg_index and then process these lists.
|
|
*
|
|
* Note: much of this code duplicates effort done by
|
|
* the IndexCatalogInformation function in plancat.c
|
|
* because IndexCatalogInformation is poorly written.
|
|
*
|
|
* It would be much better the functionality provided
|
|
* by this function and IndexCatalogInformation was
|
|
* in the form of a small set of orthogonal routines..
|
|
* If you are trying to understand this, I suggest you
|
|
* look at the code to IndexCatalogInformation and
|
|
* FormIndexTuple.. -cim 9/27/89
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
void
|
|
ExecOpenIndices(Oid resultRelationOid,
|
|
RelationInfo *resultRelationInfo)
|
|
{
|
|
Relation indexRd;
|
|
HeapScanDesc indexSd;
|
|
ScanKeyData key;
|
|
HeapTuple tuple;
|
|
IndexTupleForm indexStruct;
|
|
Oid indexOid;
|
|
List *oidList;
|
|
List *nkeyList;
|
|
List *keyList;
|
|
List *fiList;
|
|
char *predString;
|
|
List *predList;
|
|
List *indexoid;
|
|
List *numkeys;
|
|
List *indexkeys;
|
|
List *indexfuncs;
|
|
List *indexpreds;
|
|
int len;
|
|
|
|
RelationPtr relationDescs;
|
|
IndexInfo **indexInfoArray;
|
|
FuncIndexInfoPtr fInfoP;
|
|
int numKeyAtts;
|
|
AttrNumber *indexKeyAtts;
|
|
PredInfo *predicate;
|
|
int i;
|
|
|
|
/* ----------------
|
|
* open pg_index
|
|
* ----------------
|
|
*/
|
|
indexRd = heap_openr(IndexRelationName);
|
|
|
|
/* ----------------
|
|
* form a scan key
|
|
* ----------------
|
|
*/
|
|
ScanKeyEntryInitialize(&key, 0, Anum_pg_index_indrelid,
|
|
ObjectIdEqualRegProcedure,
|
|
ObjectIdGetDatum(resultRelationOid));
|
|
|
|
/* ----------------
|
|
* scan the index relation, looking for indices for our
|
|
* result relation..
|
|
* ----------------
|
|
*/
|
|
indexSd = heap_beginscan(indexRd, /* scan desc */
|
|
false, /* scan backward flag */
|
|
NowTimeQual, /* time qual */
|
|
1, /* number scan keys */
|
|
&key); /* scan keys */
|
|
|
|
oidList = NIL;
|
|
nkeyList = NIL;
|
|
keyList = NIL;
|
|
fiList = NIL;
|
|
predList = NIL;
|
|
|
|
while(tuple = heap_getnext(indexSd, /* scan desc */
|
|
false, /* scan backward flag */
|
|
NULL), /* return: buffer */
|
|
HeapTupleIsValid(tuple)) {
|
|
|
|
/* ----------------
|
|
* For each index relation we find, extract the information
|
|
* we need and store it in a list..
|
|
*
|
|
* first get the oid of the index relation from the tuple
|
|
* ----------------
|
|
*/
|
|
indexStruct = (IndexTupleForm) GETSTRUCT(tuple);
|
|
indexOid = indexStruct->indexrelid;
|
|
|
|
/* ----------------
|
|
* allocate space for functional index information.
|
|
* ----------------
|
|
*/
|
|
fInfoP = (FuncIndexInfoPtr)palloc( sizeof(*fInfoP) );
|
|
|
|
/* ----------------
|
|
* next get the index key information from the tuple
|
|
* ----------------
|
|
*/
|
|
ExecGetIndexKeyInfo(indexStruct,
|
|
&numKeyAtts,
|
|
&indexKeyAtts,
|
|
fInfoP);
|
|
|
|
/* ----------------
|
|
* next get the index predicate from the tuple
|
|
* ----------------
|
|
*/
|
|
if (VARSIZE(&indexStruct->indpred) != 0) {
|
|
predString = fmgr(F_TEXTOUT, &indexStruct->indpred);
|
|
predicate = (PredInfo*)stringToNode(predString);
|
|
pfree(predString);
|
|
} else {
|
|
predicate = NULL;
|
|
}
|
|
|
|
/* ----------------
|
|
* save the index information into lists
|
|
* ----------------
|
|
*/
|
|
oidList = lconsi(indexOid, oidList);
|
|
nkeyList = lconsi(numKeyAtts, nkeyList);
|
|
keyList = lcons(indexKeyAtts, keyList);
|
|
fiList = lcons(fInfoP, fiList);
|
|
predList = lcons(predicate, predList);
|
|
}
|
|
|
|
/* ----------------
|
|
* we have the info we need so close the pg_index relation..
|
|
* ----------------
|
|
*/
|
|
heap_endscan(indexSd);
|
|
heap_close(indexRd);
|
|
|
|
/* ----------------
|
|
* Now that we've collected the index information into three
|
|
* lists, we open the index relations and store the descriptors
|
|
* and the key information into arrays.
|
|
* ----------------
|
|
*/
|
|
len = length(oidList);
|
|
if (len > 0) {
|
|
/* ----------------
|
|
* allocate space for relation descs
|
|
* ----------------
|
|
*/
|
|
CXT1_printf("ExecOpenIndices: context is %d\n", CurrentMemoryContext);
|
|
relationDescs = (RelationPtr)
|
|
palloc(len * sizeof(Relation));
|
|
|
|
/* ----------------
|
|
* initialize index info array
|
|
* ----------------
|
|
*/
|
|
CXT1_printf("ExecOpenIndices: context is %d\n", CurrentMemoryContext);
|
|
indexInfoArray = (IndexInfo**)
|
|
palloc(len * sizeof(IndexInfo*));
|
|
|
|
for (i=0; i<len; i++) {
|
|
IndexInfo *ii = makeNode(IndexInfo);
|
|
ii->ii_NumKeyAttributes = 0;
|
|
ii->ii_KeyAttributeNumbers = (AttrNumber*) NULL;
|
|
ii->ii_FuncIndexInfo = (FuncIndexInfoPtr) NULL;
|
|
ii->ii_Predicate = NULL;
|
|
indexInfoArray[i] = ii;
|
|
}
|
|
|
|
/* ----------------
|
|
* attempt to open each of the indices. If we succeed,
|
|
* then store the index relation descriptor into the
|
|
* relation descriptor array.
|
|
* ----------------
|
|
*/
|
|
i = 0;
|
|
foreach (indexoid, oidList) {
|
|
Relation indexDesc;
|
|
|
|
indexOid = lfirsti(indexoid);
|
|
indexDesc = index_open(indexOid);
|
|
if (indexDesc != NULL)
|
|
relationDescs[i++] = indexDesc;
|
|
}
|
|
|
|
/* ----------------
|
|
* store the relation descriptor array and number of
|
|
* descs into the result relation info.
|
|
* ----------------
|
|
*/
|
|
resultRelationInfo->ri_NumIndices = i;
|
|
resultRelationInfo->ri_IndexRelationDescs = relationDescs;
|
|
|
|
/* ----------------
|
|
* store the index key information collected in our
|
|
* lists into the index info array
|
|
* ----------------
|
|
*/
|
|
i = 0;
|
|
foreach (numkeys, nkeyList) {
|
|
numKeyAtts = lfirsti(numkeys);
|
|
indexInfoArray[i++]->ii_NumKeyAttributes = numKeyAtts;
|
|
}
|
|
|
|
i = 0;
|
|
foreach (indexkeys, keyList) {
|
|
indexKeyAtts = (AttrNumber*) lfirst(indexkeys);
|
|
indexInfoArray[i++]->ii_KeyAttributeNumbers = indexKeyAtts;
|
|
}
|
|
|
|
i = 0;
|
|
foreach (indexfuncs, fiList) {
|
|
FuncIndexInfoPtr fiP = (FuncIndexInfoPtr)lfirst(indexfuncs);
|
|
indexInfoArray[i++]->ii_FuncIndexInfo = fiP;
|
|
}
|
|
|
|
i = 0;
|
|
foreach (indexpreds, predList) {
|
|
indexInfoArray[i++]->ii_Predicate = lfirst(indexpreds);
|
|
}
|
|
/* ----------------
|
|
* store the index info array into relation info
|
|
* ----------------
|
|
*/
|
|
resultRelationInfo->ri_IndexRelationInfo = indexInfoArray;
|
|
}
|
|
|
|
/* ----------------
|
|
* All done, resultRelationInfo now contains complete information
|
|
* on the indices associated with the result relation.
|
|
* ----------------
|
|
*/
|
|
|
|
/* should free oidList, nkeyList and keyList here */
|
|
/* OK - let's do it -jolly */
|
|
freeList(oidList);
|
|
freeList(nkeyList);
|
|
freeList(keyList);
|
|
freeList(fiList);
|
|
freeList(predList);
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* ExecCloseIndices
|
|
*
|
|
* Close the index relations stored in resultRelationInfo
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
void
|
|
ExecCloseIndices(RelationInfo *resultRelationInfo)
|
|
{
|
|
int i;
|
|
int numIndices;
|
|
RelationPtr relationDescs;
|
|
|
|
numIndices = resultRelationInfo->ri_NumIndices;
|
|
relationDescs = resultRelationInfo->ri_IndexRelationDescs;
|
|
|
|
for (i=0; i<numIndices; i++)
|
|
if (relationDescs[i] != NULL)
|
|
index_close(relationDescs[i]);
|
|
/*
|
|
* XXX should free indexInfo array here too.
|
|
*/
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* ExecFormIndexTuple
|
|
*
|
|
* Most of this code is cannabilized from DefaultBuild().
|
|
* As said in the comments for ExecOpenIndices, most of
|
|
* this functionality should be rearranged into a proper
|
|
* set of routines..
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
IndexTuple
|
|
ExecFormIndexTuple(HeapTuple heapTuple,
|
|
Relation heapRelation,
|
|
Relation indexRelation,
|
|
IndexInfo *indexInfo)
|
|
{
|
|
IndexTuple indexTuple;
|
|
TupleDesc heapDescriptor;
|
|
TupleDesc indexDescriptor;
|
|
Datum *datum;
|
|
char *nulls;
|
|
|
|
int numberOfAttributes;
|
|
AttrNumber *keyAttributeNumbers;
|
|
FuncIndexInfoPtr fInfoP;
|
|
|
|
/* ----------------
|
|
* get information from index info structure
|
|
* ----------------
|
|
*/
|
|
numberOfAttributes = indexInfo->ii_NumKeyAttributes;
|
|
keyAttributeNumbers = indexInfo->ii_KeyAttributeNumbers;
|
|
fInfoP = indexInfo->ii_FuncIndexInfo;
|
|
|
|
/* ----------------
|
|
* datum and null are arrays in which we collect the index attributes
|
|
* when forming a new index tuple.
|
|
* ----------------
|
|
*/
|
|
CXT1_printf("ExecFormIndexTuple: context is %d\n", CurrentMemoryContext);
|
|
datum = (Datum *) palloc(numberOfAttributes * sizeof *datum);
|
|
nulls = (char *) palloc(numberOfAttributes * sizeof *nulls);
|
|
|
|
/* ----------------
|
|
* get the tuple descriptors from the relations so we know
|
|
* how to form the index tuples..
|
|
* ----------------
|
|
*/
|
|
heapDescriptor = RelationGetTupleDescriptor(heapRelation);
|
|
indexDescriptor = RelationGetTupleDescriptor(indexRelation);
|
|
|
|
/* ----------------
|
|
* FormIndexDatum fills in its datum and null parameters
|
|
* with attribute information taken from the given heap tuple.
|
|
* ----------------
|
|
*/
|
|
FormIndexDatum(numberOfAttributes, /* num attributes */
|
|
keyAttributeNumbers, /* array of att nums to extract */
|
|
heapTuple, /* tuple from base relation */
|
|
heapDescriptor, /* heap tuple's descriptor */
|
|
InvalidBuffer, /* buffer associated with heap tuple */
|
|
datum, /* return: array of attributes */
|
|
nulls, /* return: array of char's */
|
|
fInfoP); /* functional index information */
|
|
|
|
indexTuple = index_formtuple(indexDescriptor,
|
|
datum,
|
|
nulls);
|
|
|
|
/* ----------------
|
|
* free temporary arrays
|
|
*
|
|
* XXX should store these in the IndexInfo instead of allocating
|
|
* and freeing on every insertion, but efficency here is not
|
|
* that important and FormIndexTuple is wasteful anyways..
|
|
* -cim 9/27/89
|
|
* ----------------
|
|
*/
|
|
pfree(nulls);
|
|
pfree(datum);
|
|
|
|
return indexTuple;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* ExecInsertIndexTuples
|
|
*
|
|
* This routine takes care of inserting index tuples
|
|
* into all the relations indexing the result relation
|
|
* when a heap tuple is inserted into the result relation.
|
|
* Much of this code should be moved into the genam
|
|
* stuff as it only exists here because the genam stuff
|
|
* doesn't provide the functionality needed by the
|
|
* executor.. -cim 9/27/89
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
void
|
|
ExecInsertIndexTuples(TupleTableSlot *slot,
|
|
ItemPointer tupleid,
|
|
EState *estate,
|
|
bool is_update)
|
|
{
|
|
HeapTuple heapTuple;
|
|
RelationInfo *resultRelationInfo;
|
|
int i;
|
|
int numIndices;
|
|
RelationPtr relationDescs;
|
|
Relation heapRelation;
|
|
IndexInfo **indexInfoArray;
|
|
IndexInfo *indexInfo;
|
|
Node *predicate;
|
|
bool satisfied;
|
|
ExprContext *econtext;
|
|
InsertIndexResult result;
|
|
int numberOfAttributes;
|
|
AttrNumber *keyAttributeNumbers;
|
|
FuncIndexInfoPtr fInfoP;
|
|
TupleDesc heapDescriptor;
|
|
Datum *datum;
|
|
char *nulls;
|
|
|
|
heapTuple = slot->val;
|
|
|
|
/* ----------------
|
|
* get information from the result relation info structure.
|
|
* ----------------
|
|
*/
|
|
resultRelationInfo = estate->es_result_relation_info;
|
|
numIndices = resultRelationInfo->ri_NumIndices;
|
|
relationDescs = resultRelationInfo->ri_IndexRelationDescs;
|
|
indexInfoArray = resultRelationInfo->ri_IndexRelationInfo;
|
|
heapRelation = resultRelationInfo->ri_RelationDesc;
|
|
|
|
/* ----------------
|
|
* for each index, form and insert the index tuple
|
|
* ----------------
|
|
*/
|
|
econtext = NULL;
|
|
for (i=0; i<numIndices; i++) {
|
|
if (relationDescs[i] == NULL) continue;
|
|
|
|
indexInfo = indexInfoArray[i];
|
|
predicate = indexInfo->ii_Predicate;
|
|
if (predicate != NULL) {
|
|
if (econtext == NULL) {
|
|
econtext = makeNode(ExprContext);
|
|
}
|
|
econtext->ecxt_scantuple = slot;
|
|
|
|
/* Skip this index-update if the predicate isn't satisfied */
|
|
satisfied = ExecQual((List*)predicate, econtext);
|
|
if (satisfied == false)
|
|
continue;
|
|
}
|
|
|
|
/* ----------------
|
|
* get information from index info structure
|
|
* ----------------
|
|
*/
|
|
numberOfAttributes = indexInfo->ii_NumKeyAttributes;
|
|
keyAttributeNumbers = indexInfo->ii_KeyAttributeNumbers;
|
|
fInfoP = indexInfo->ii_FuncIndexInfo;
|
|
datum = (Datum *) palloc(numberOfAttributes * sizeof *datum);
|
|
nulls = (char *) palloc(numberOfAttributes * sizeof *nulls);
|
|
heapDescriptor = (TupleDesc)RelationGetTupleDescriptor(heapRelation);
|
|
|
|
FormIndexDatum(numberOfAttributes, /* num attributes */
|
|
keyAttributeNumbers, /* array of att nums to extract */
|
|
heapTuple, /* tuple from base relation */
|
|
heapDescriptor, /* heap tuple's descriptor */
|
|
InvalidBuffer, /* buffer associated with heap tuple */
|
|
datum, /* return: array of attributes */
|
|
nulls, /* return: array of char's */
|
|
fInfoP); /* functional index information */
|
|
|
|
|
|
result = index_insert(relationDescs[i], /* index relation */
|
|
datum, /* array of heaptuple Datums */
|
|
nulls, /* info on nulls */
|
|
&(heapTuple->t_ctid), /* oid of heap tuple */
|
|
heapRelation);
|
|
|
|
/* ----------------
|
|
* keep track of index inserts for debugging
|
|
* ----------------
|
|
*/
|
|
IncrIndexInserted();
|
|
|
|
/* ----------------
|
|
* free index tuple after insertion
|
|
* ----------------
|
|
*/
|
|
if (result) pfree(result);
|
|
}
|
|
if (econtext != NULL) pfree(econtext);
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* setVarAttrLenForCreateTable -
|
|
* called when we do a SELECT * INTO TABLE tab
|
|
* needed for attributes that have a defined length, like bpchar and
|
|
* varchar
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
void
|
|
setVarAttrLenForCreateTable(TupleDesc tupType, List *targetList,
|
|
List *rangeTable)
|
|
{
|
|
List *tl;
|
|
TargetEntry *tle;
|
|
Node *expr;
|
|
int varno;
|
|
|
|
tl = targetList;
|
|
|
|
for (varno = 0; varno < tupType->natts; varno++) {
|
|
tle = lfirst(tl);
|
|
|
|
if (tupType->attrs[varno]->atttypid == BPCHAROID ||
|
|
tupType->attrs[varno]->atttypid == VARCHAROID) {
|
|
expr = tle->expr;
|
|
if (expr && IsA(expr,Var)) {
|
|
Var *var;
|
|
RangeTblEntry *rtentry;
|
|
Relation rd;
|
|
|
|
var = (Var *)expr;
|
|
rtentry = rt_fetch(var->varnoold, rangeTable);
|
|
rd = heap_open(rtentry->relid);
|
|
/* set length to that defined in relation */
|
|
tupType->attrs[varno]->attlen =
|
|
(*rd->rd_att->attrs[var->varoattno-1]).attlen;
|
|
heap_close(rd);
|
|
}
|
|
else
|
|
elog(WARN, "setVarAttrLenForCreateTable: can't get length for variable-length field");
|
|
}
|
|
tl = lnext(tl);
|
|
}
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------
|
|
* resetVarAttrLenForCreateTable -
|
|
* called when we do a SELECT * INTO TABLE tab
|
|
* needed for attributes that have a defined length, like bpchar and
|
|
* varchar
|
|
* resets length to -1 for those types
|
|
* ----------------------------------------------------------------
|
|
*/
|
|
void
|
|
resetVarAttrLenForCreateTable(TupleDesc tupType)
|
|
{
|
|
int varno;
|
|
|
|
for (varno = 0; varno < tupType->natts; varno++) {
|
|
if (tupType->attrs[varno]->atttypid == BPCHAROID ||
|
|
tupType->attrs[varno]->atttypid == VARCHAROID)
|
|
/* set length to original -1 */
|
|
tupType->attrs[varno]->attlen = -1;
|
|
}
|
|
}
|