diff options
Diffstat (limited to 'src/backend/executor/execUtils.c')
| -rw-r--r-- | src/backend/executor/execUtils.c | 1816 |
1 files changed, 931 insertions, 885 deletions
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c index ac2d3516036..3795c2d1018 100644 --- a/src/backend/executor/execUtils.c +++ b/src/backend/executor/execUtils.c @@ -1,43 +1,43 @@ /*------------------------------------------------------------------------- * * execUtils.c-- - * miscellanious executor utility routines + * miscellanious executor utility routines * * Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.14 1997/08/22 03:12:19 vadim Exp $ + * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.15 1997/09/07 04:41:26 momjian Exp $ * *------------------------------------------------------------------------- */ /* * INTERFACE ROUTINES - * ExecAssignNodeBaseInfo \ - * ExecAssignDebugHooks > preforms misc work done in all the - * ExecAssignExprContext / init node 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 / + * 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 + * 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 / + * 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. * - * NOTES - * This file has traditionally been the place to stick misc. - * executor support stuff that doesn't really go anyplace else. - * */ #include "postgres.h" @@ -58,1149 +58,1195 @@ #include "catalog/pg_type.h" #include "parser/parsetree.h" -static void ExecGetIndexKeyInfo(IndexTupleForm indexTuple, int *numAttsOutP, - AttrNumber **attsOutP, FuncIndexInfoPtr fInfoP); +static void +ExecGetIndexKeyInfo(IndexTupleForm indexTuple, int *numAttsOutP, + AttrNumber ** attsOutP, FuncIndexInfoPtr fInfoP); /* ---------------------------------------------------------------- - * global counters for number of tuples processed, retrieved, - * appended, replaced, deleted. + * 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. */ +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 + * statistic functions * ---------------------------------------------------------------- */ /* ---------------------------------------------------------------- - * ResetTupleCount + * ResetTupleCount * ---------------------------------------------------------------- */ #ifdef NOT_USED void ResetTupleCount(void) { - NTupleProcessed = 0; - NTupleRetrieved = 0; - NTupleAppended = 0; - NTupleDeleted = 0; - NTupleReplaced = 0; - NIndexTupleProcessed = 0; + NTupleProcessed = 0; + NTupleRetrieved = 0; + NTupleAppended = 0; + NTupleDeleted = 0; + NTupleReplaced = 0; + NIndexTupleProcessed = 0; } + #endif /* ---------------------------------------------------------------- - * PrintTupleCount + * PrintTupleCount * ---------------------------------------------------------------- */ #ifdef NOT_USED void -DisplayTupleCount(FILE *statfp) +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"); + 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"); } + #endif /* ---------------------------------------------------------------- - * miscellanious init node support functions + * 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 - assigns the baseid field of the node + * ExecAssignDebugHooks - assigns the node's debugging hooks + * ExecAssignExprContext - assigns the node's expression context * ---------------------------------------------------------------- */ /* ---------------- - * ExecAssignNodeBaseInfo + * 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. + * 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) +ExecAssignNodeBaseInfo(EState * estate, CommonState * cstate, Plan * parent) { - int baseId; - - baseId = estate->es_BaseId; - cstate->cs_base_id = baseId; - estate->es_BaseId = baseId + 1; + int baseId; + + baseId = estate->es_BaseId; + cstate->cs_base_id = baseId; + estate->es_BaseId = baseId + 1; } /* ---------------- - * ExecAssignExprContext + * 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. + * 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) +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; + 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 + * Result slot tuple type and ProjectionInfo support * ---------------------------------------------------------------- */ /* ---------------- - * ExecAssignResultType + * ExecAssignResultType * ---------------- */ void -ExecAssignResultType(CommonState *commonstate, - TupleDesc tupDesc) +ExecAssignResultType(CommonState * commonstate, + TupleDesc tupDesc) { - TupleTableSlot *slot; - - slot = commonstate->cs_ResultTupleSlot; - slot->ttc_tupleDescriptor = tupDesc; + TupleTableSlot *slot; + + slot = commonstate->cs_ResultTupleSlot; + slot->ttc_tupleDescriptor = tupDesc; } /* ---------------- - * ExecAssignResultTypeFromOuterPlan + * ExecAssignResultTypeFromOuterPlan * ---------------- */ void -ExecAssignResultTypeFromOuterPlan(Plan *node, CommonState *commonstate) +ExecAssignResultTypeFromOuterPlan(Plan * node, CommonState * commonstate) { - Plan *outerPlan; - TupleDesc tupDesc; - - outerPlan = outerPlan(node); - tupDesc = ExecGetTupType(outerPlan); - - ExecAssignResultType(commonstate, tupDesc); + Plan *outerPlan; + TupleDesc tupDesc; + + outerPlan = outerPlan(node); + tupDesc = ExecGetTupType(outerPlan); + + ExecAssignResultType(commonstate, tupDesc); } /* ---------------- - * ExecAssignResultTypeFromTL + * ExecAssignResultTypeFromTL * ---------------- */ void -ExecAssignResultTypeFromTL(Plan *node, CommonState *commonstate) +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); - } + 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; - } + 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); + i++; + } + if (len > 0) + { + ExecAssignResultType(commonstate, + origTupDesc); + } + else + ExecAssignResultType(commonstate, + (TupleDesc) NULL); } /* ---------------- - * ExecGetResultType + * ExecGetResultType * ---------------- */ TupleDesc -ExecGetResultType(CommonState *commonstate) +ExecGetResultType(CommonState * commonstate) { - TupleTableSlot *slot = commonstate->cs_ResultTupleSlot; - - return slot->ttc_tupleDescriptor; + TupleTableSlot *slot = commonstate->cs_ResultTupleSlot; + + return slot->ttc_tupleDescriptor; } /* ---------------- - * ExecFreeResultType + * ExecFreeResultType * ---------------- */ #ifdef NOT_USED void -ExecFreeResultType(CommonState *commonstate) +ExecFreeResultType(CommonState * commonstate) { - TupleTableSlot *slot; - TupleDesc tupType; - - slot = commonstate->cs_ResultTupleSlot; - tupType = slot->ttc_tupleDescriptor; - -/* ExecFreeTypeInfo(tupType); */ - pfree(tupType); + TupleTableSlot *slot; + TupleDesc tupType; + + slot = commonstate->cs_ResultTupleSlot; + tupType = slot->ttc_tupleDescriptor; + +/* ExecFreeTypeInfo(tupType); */ + pfree(tupType); } + #endif /* ---------------- - * ExecAssignProjectionInfo - forms the projection information from the node's targetlist + * ExecAssignProjectionInfo + forms the projection information from the node's targetlist * ---------------- */ void -ExecAssignProjectionInfo(Plan *node, CommonState *commonstate) +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; + 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 + * ExecFreeProjectionInfo * ---------------- */ void -ExecFreeProjectionInfo(CommonState *commonstate) +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; + 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 + * 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 + * ExecGetScanType * ---------------- */ TupleDesc -ExecGetScanType(CommonScanState *csstate) +ExecGetScanType(CommonScanState * csstate) { - TupleTableSlot *slot = csstate->css_ScanTupleSlot; - return slot->ttc_tupleDescriptor; + TupleTableSlot *slot = csstate->css_ScanTupleSlot; + + return slot->ttc_tupleDescriptor; } /* ---------------- - * ExecFreeScanType + * ExecFreeScanType * ---------------- */ #ifdef NOT_USED void -ExecFreeScanType(CommonScanState *csstate) +ExecFreeScanType(CommonScanState * csstate) { - TupleTableSlot *slot; - TupleDesc tupType; - - slot = csstate->css_ScanTupleSlot; - tupType = slot->ttc_tupleDescriptor; - -/* ExecFreeTypeInfo(tupType); */ - pfree(tupType); + TupleTableSlot *slot; + TupleDesc tupType; + + slot = csstate->css_ScanTupleSlot; + tupType = slot->ttc_tupleDescriptor; + +/* ExecFreeTypeInfo(tupType); */ + pfree(tupType); } + #endif /* ---------------- - * ExecAssignScanType + * ExecAssignScanType * ---------------- */ void -ExecAssignScanType(CommonScanState *csstate, - TupleDesc tupDesc) +ExecAssignScanType(CommonScanState * csstate, + TupleDesc tupDesc) { - TupleTableSlot *slot; - - slot = (TupleTableSlot *) csstate->css_ScanTupleSlot; - slot->ttc_tupleDescriptor = tupDesc; + TupleTableSlot *slot; + + slot = (TupleTableSlot *) csstate->css_ScanTupleSlot; + slot->ttc_tupleDescriptor = tupDesc; } /* ---------------- - * ExecAssignScanTypeFromOuterPlan + * ExecAssignScanTypeFromOuterPlan * ---------------- */ void -ExecAssignScanTypeFromOuterPlan(Plan *node, CommonScanState *csstate) +ExecAssignScanTypeFromOuterPlan(Plan * node, CommonScanState * csstate) { - Plan *outerPlan; - TupleDesc tupDesc; - - outerPlan = outerPlan(node); - tupDesc = ExecGetTupType(outerPlan); + Plan *outerPlan; + TupleDesc tupDesc; + + outerPlan = outerPlan(node); + tupDesc = ExecGetTupType(outerPlan); - ExecAssignScanType(csstate, tupDesc); + ExecAssignScanType(csstate, tupDesc); } /* ---------------------------------------------------------------- - * ExecTypeFromTL support routines. + * ExecTypeFromTL support routines. * - * these routines are used mainly from ExecTypeFromTL. - * -cim 6/12/90 + * 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: + * 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'. + * 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 + * ExecSetTypeInfo * - * This initializes fields of a single attribute in a - * tuple descriptor from the specified parameters. + * 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. + * 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. * ---------------- */ -#ifdef NOT_USED +#ifdef NOT_USED void ExecSetTypeInfo(int index, - TupleDesc typeInfo, - Oid typeID, - int attNum, - int attLen, - char *attName, - bool attbyVal, - char attalign) + 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-1); - else - memset(att->attname.data,0,NAMEDATALEN); - - att->atttypid = typeID; - att->attdefrel = 0; /* dummy value */ - att->attdisbursion = 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; + 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 - 1); + else + memset(att->attname.data, 0, NAMEDATALEN); + + att->atttypid = typeID; + att->attdefrel = 0; /* dummy value */ + att->attdisbursion = 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... + * 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); + /* ---------------- + * 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 + * 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 + *| 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) +QueryDescGetTypeInfo(QueryDesc * queryDesc) { - Plan *plan; - TupleDesc tupleType; - List *targetList; - AttrInfo *attinfo = (AttrInfo *)palloc(sizeof(AttrInfo)); - - plan = queryDesc->plantree; - tupleType = (TupleDesc) ExecGetTupType(plan); + Plan *plan; + TupleDesc tupleType; + List *targetList; + AttrInfo *attinfo = (AttrInfo *) palloc(sizeof(AttrInfo)); + + plan = queryDesc->plantree; + tupleType = (TupleDesc) ExecGetTupType(plan); /* - targetList = plan->targetlist; + targetList = plan->targetlist; - attinfo->numAttr = ExecTargetListLength(targetList); - attinfo->attrs = tupleType; + attinfo->numAttr = ExecTargetListLength(targetList); + attinfo->attrs = tupleType; */ - attinfo->numAttr = tupleType->natts; - attinfo->attrs = tupleType->attrs; - return attinfo; + attinfo->numAttr = tupleType->natts; + attinfo->attrs = tupleType->attrs; + return attinfo; } + #endif /* ---------------------------------------------------------------- - * ExecInsertIndexTuples support + * ExecInsertIndexTuples support * ---------------------------------------------------------------- */ /* ---------------------------------------------------------------- - * ExecGetIndexKeyInfo + * 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. + * 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. * ---------------------------------------------------------------- */ static void ExecGetIndexKeyInfo(IndexTupleForm indexTuple, - int *numAttsOutP, - AttrNumber **attsOutP, - FuncIndexInfoPtr fInfoP) + 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; -} + int i; + int numKeys; + AttrNumber *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 + * check parameters * ---------------- */ - indexStruct = (IndexTupleForm) GETSTRUCT(tuple); - indexOid = indexStruct->indexrelid; - + if (numAttsOutP == NULL && attsOutP == NULL) + { + elog(DEBUG, "ExecGetIndexKeyInfo: %s", + "invalid parameters: numAttsOutP and attsOutP must be non-NULL"); + } + /* ---------------- - * allocate space for functional index information. + * set the procid for a possible functional index. * ---------------- */ - fInfoP = (FuncIndexInfoPtr)palloc( sizeof(*fInfoP) ); - + FIsetProcOid(fInfoP, indexTuple->indproc); + /* ---------------- - * next get the index key information from the tuple + * count the number of keys.. * ---------------- */ - ExecGetIndexKeyInfo(indexStruct, - &numKeyAtts, - &indexKeyAtts, - fInfoP); - + numKeys = 0; + for (i = 0; i < 8 && indexTuple->indkey[i] != 0; i++) + numKeys++; + /* ---------------- - * next get the index predicate from the tuple + * 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 (VARSIZE(&indexStruct->indpred) != 0) { - predString = fmgr(F_TEXTOUT, &indexStruct->indpred); - predicate = (PredInfo*)stringToNode(predString); - pfree(predString); - } else { - predicate = NULL; + 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; } - + /* ---------------- - * save the index information into lists + * allocate and fill in array of key attribute numbers * ---------------- */ - 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) { + 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]; + /* ---------------- - * allocate space for relation descs + * return array to caller. * ---------------- */ - CXT1_printf("ExecOpenIndices: context is %d\n", CurrentMemoryContext); - relationDescs = (RelationPtr) - palloc(len * sizeof(Relation)); - + (*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; + /* ---------------- - * initialize index info array + * open pg_index * ---------------- */ - 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; - } - + indexRd = heap_openr(IndexRelationName); + /* ---------------- - * attempt to open each of the indices. If we succeed, - * then store the index relation descriptor into the - * relation descriptor array. + * form a scan key * ---------------- */ - i = 0; - foreach (indexoid, oidList) { - Relation indexDesc; - - indexOid = lfirsti(indexoid); - indexDesc = index_open(indexOid); - if (indexDesc != NULL) - relationDescs[i++] = indexDesc; + 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); } - + /* ---------------- - * store the relation descriptor array and number of - * descs into the result relation info. + * we have the info we need so close the pg_index relation.. * ---------------- */ - resultRelationInfo->ri_NumIndices = i; - resultRelationInfo->ri_IndexRelationDescs = relationDescs; - + heap_endscan(indexSd); + heap_close(indexRd); + /* ---------------- - * store the index key information collected in our - * lists into the index info array + * 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. * ---------------- */ - 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); + 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; } + /* ---------------- - * store the index info array into relation info + * All done, resultRelationInfo now contains complete information + * on the indices associated with the result relation. * ---------------- */ - 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); + + /* should free oidList, nkeyList and keyList here */ + /* OK - let's do it -jolly */ + freeList(oidList); + freeList(nkeyList); + freeList(keyList); + freeList(fiList); + freeList(predList); } /* ---------------------------------------------------------------- - * ExecCloseIndices + * ExecCloseIndices * - * Close the index relations stored in resultRelationInfo + * Close the index relations stored in resultRelationInfo * ---------------------------------------------------------------- */ void -ExecCloseIndices(RelationInfo *resultRelationInfo) +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. - */ + 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 + * 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.. + * 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.. * ---------------------------------------------------------------- */ #ifdef NOT_USED IndexTuple ExecFormIndexTuple(HeapTuple heapTuple, - Relation heapRelation, - Relation indexRelation, - IndexInfo *indexInfo) + 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; + 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; } + #endif /* ---------------------------------------------------------------- - * ExecInsertIndexTuples + * 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 + * 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) +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; - } + 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 index info structure + * get information from the result relation 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(); - + resultRelationInfo = estate->es_result_relation_info; + numIndices = resultRelationInfo->ri_NumIndices; + relationDescs = resultRelationInfo->ri_IndexRelationDescs; + indexInfoArray = resultRelationInfo->ri_IndexRelationInfo; + heapRelation = resultRelationInfo->ri_RelationDesc; + /* ---------------- - * free index tuple after insertion + * for each index, form and insert the index tuple * ---------------- */ - if (result) pfree(result); - } - if (econtext != NULL) pfree(econtext); + 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 + * 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) +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); - } + 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); + } } -#ifdef NOT_USED /* look at execMain.c */ +#ifdef NOT_USED /* look at execMain.c */ /* ---------------------------------------------------------------- * 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 + * 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; - } + 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; + } } + #endif |