OK, folks, here is the pgindent output.
This commit is contained in:
parent
af74855a60
commit
fa1a8d6a97
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.40 1998/09/01 03:20:41 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.41 1998/09/01 04:26:39 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* The old interface functions have been converted to macros
|
||||
|
@ -935,7 +935,8 @@ heap_modifytuple(HeapTuple tuple,
|
|||
(char *) &tuple->t_oid,
|
||||
((char *) &tuple->t_hoff - (char *) &tuple->t_oid)); /* XXX */
|
||||
newTuple->t_infomask = infomask;
|
||||
newTuple->t_natts = numberOfAttributes; /* fix t_natts just in case */
|
||||
newTuple->t_natts = numberOfAttributes; /* fix t_natts just in
|
||||
* case */
|
||||
return newTuple;
|
||||
}
|
||||
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.34 1998/09/01 03:20:45 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.35 1998/09/01 04:26:40 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -82,8 +82,10 @@ printtup(HeapTuple tuple, TupleDesc typeinfo)
|
|||
Datum attr;
|
||||
bool isnull;
|
||||
Oid typoutput;
|
||||
|
||||
#ifdef MULTIBYTE
|
||||
unsigned char *p;
|
||||
|
||||
#endif
|
||||
|
||||
/* ----------------
|
||||
|
@ -147,7 +149,7 @@ printtup(HeapTuple tuple, TupleDesc typeinfo)
|
|||
outputstr = "<unprintable>";
|
||||
pq_putint(strlen(outputstr) + VARHDRSZ, VARHDRSZ);
|
||||
pq_putnchar(outputstr, strlen(outputstr));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.43 1998/09/01 03:20:46 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.44 1998/09/01 04:26:41 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* some of the executor utility code such as "ExecTypeFromTL" should be
|
||||
|
@ -75,7 +75,7 @@ CreateTemplateTupleDesc(int natts)
|
|||
* ----------------------------------------------------------------
|
||||
*/
|
||||
TupleDesc
|
||||
CreateTupleDesc(int natts, Form_pg_attribute *attrs)
|
||||
CreateTupleDesc(int natts, Form_pg_attribute * attrs)
|
||||
{
|
||||
TupleDesc desc;
|
||||
|
||||
|
|
|
@ -33,42 +33,32 @@
|
|||
#endif
|
||||
|
||||
/* non-export function prototypes */
|
||||
static InsertIndexResult
|
||||
gistdoinsert(Relation r, IndexTuple itup,
|
||||
static InsertIndexResult gistdoinsert(Relation r, IndexTuple itup,
|
||||
GISTSTATE *GISTstate);
|
||||
static InsertIndexResult
|
||||
gistentryinsert(Relation r, GISTSTACK *stk,
|
||||
static InsertIndexResult gistentryinsert(Relation r, GISTSTACK *stk,
|
||||
IndexTuple tup,
|
||||
GISTSTATE *giststate);
|
||||
static void
|
||||
gistentryinserttwo(Relation r, GISTSTACK *stk, IndexTuple ltup,
|
||||
static void gistentryinserttwo(Relation r, GISTSTACK *stk, IndexTuple ltup,
|
||||
IndexTuple rtup, GISTSTATE *giststate);
|
||||
static void
|
||||
gistAdjustKeys(Relation r, GISTSTACK *stk, BlockNumber blk,
|
||||
static void gistAdjustKeys(Relation r, GISTSTACK *stk, BlockNumber blk,
|
||||
char *datum, int att_size, GISTSTATE *giststate);
|
||||
static void
|
||||
gistintinsert(Relation r, GISTSTACK *stk, IndexTuple ltup,
|
||||
static void gistintinsert(Relation r, GISTSTACK *stk, IndexTuple ltup,
|
||||
IndexTuple rtup, GISTSTATE *giststate);
|
||||
static InsertIndexResult
|
||||
gistSplit(Relation r, Buffer buffer,
|
||||
static InsertIndexResult gistSplit(Relation r, Buffer buffer,
|
||||
GISTSTACK *stack, IndexTuple itup,
|
||||
GISTSTATE *giststate);
|
||||
static void
|
||||
gistnewroot(GISTSTATE *giststate, Relation r, IndexTuple lt,
|
||||
static void gistnewroot(GISTSTATE *giststate, Relation r, IndexTuple lt,
|
||||
IndexTuple rt);
|
||||
static void GISTInitBuffer(Buffer b, uint32 f);
|
||||
static BlockNumber
|
||||
gistChooseSubtree(Relation r, IndexTuple itup, int level,
|
||||
static BlockNumber gistChooseSubtree(Relation r, IndexTuple itup, int level,
|
||||
GISTSTATE *giststate,
|
||||
GISTSTACK **retstack, Buffer *leafbuf);
|
||||
static OffsetNumber
|
||||
gistchoose(Relation r, Page p, IndexTuple it,
|
||||
static OffsetNumber gistchoose(Relation r, Page p, IndexTuple it,
|
||||
GISTSTATE *giststate);
|
||||
static int gistnospace(Page p, IndexTuple it);
|
||||
void gistdelete(Relation r, ItemPointer tid);
|
||||
static IndexTuple gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t);
|
||||
static void
|
||||
gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
|
||||
static void gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
|
||||
Relation r, Page pg, OffsetNumber o, int b, bool l);
|
||||
static char *int_range_out(INTRANGE *r);
|
||||
|
||||
|
@ -169,7 +159,7 @@ gistbuild(Relation heap,
|
|||
slot = NULL;
|
||||
econtext = NULL;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
/* int the tuples as we insert them */
|
||||
nh = ni = 0;
|
||||
|
||||
|
@ -193,7 +183,7 @@ gistbuild(Relation heap,
|
|||
ni++;
|
||||
continue;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -207,7 +197,7 @@ gistbuild(Relation heap,
|
|||
slot->val = htup;
|
||||
if (ExecQual((List *) pred, econtext) == false)
|
||||
continue;
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
ni++;
|
||||
|
@ -286,7 +276,7 @@ gistbuild(Relation heap,
|
|||
#ifndef OMIT_PARTIAL_INDEX
|
||||
ExecDestroyTupleTable(tupleTable, true);
|
||||
pfree(econtext);
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -1168,7 +1158,7 @@ initGISTstate(GISTSTATE *giststate, Relation index)
|
|||
itupform = (Form_pg_index) GETSTRUCT(htup);
|
||||
if (!HeapTupleIsValid(htup))
|
||||
elog(ERROR, "initGISTstate: index %d not found",
|
||||
RelationGetRelid(index));
|
||||
RelationGetRelid(index));
|
||||
giststate->haskeytype = itupform->indhaskeytype;
|
||||
if (giststate->haskeytype)
|
||||
{
|
||||
|
@ -1377,4 +1367,4 @@ int_range_out(INTRANGE *r)
|
|||
return result;
|
||||
}
|
||||
|
||||
#endif /* defined GISTDEBUG */
|
||||
#endif /* defined GISTDEBUG */
|
||||
|
|
|
@ -28,15 +28,13 @@
|
|||
#endif
|
||||
|
||||
|
||||
static OffsetNumber
|
||||
gistfindnext(IndexScanDesc s, Page p, OffsetNumber n,
|
||||
static OffsetNumber gistfindnext(IndexScanDesc s, Page p, OffsetNumber n,
|
||||
ScanDirection dir);
|
||||
static RetrieveIndexResult gistscancache(IndexScanDesc s, ScanDirection dir);
|
||||
static RetrieveIndexResult gistfirst(IndexScanDesc s, ScanDirection dir);
|
||||
static RetrieveIndexResult gistnext(IndexScanDesc s, ScanDirection dir);
|
||||
static ItemPointer gistheapptr(Relation r, ItemPointer itemp);
|
||||
static bool
|
||||
gistindex_keytest(IndexTuple tuple, TupleDesc tupdesc,
|
||||
static bool gistindex_keytest(IndexTuple tuple, TupleDesc tupdesc,
|
||||
int scanKeySize, ScanKey key, GISTSTATE *giststate,
|
||||
Relation r, Page p, OffsetNumber offset);
|
||||
|
||||
|
|
|
@ -29,14 +29,11 @@
|
|||
/* routines defined and used here */
|
||||
static void gistregscan(IndexScanDesc s);
|
||||
static void gistdropscan(IndexScanDesc s);
|
||||
static void
|
||||
gistadjone(IndexScanDesc s, int op, BlockNumber blkno,
|
||||
static void gistadjone(IndexScanDesc s, int op, BlockNumber blkno,
|
||||
OffsetNumber offnum);
|
||||
static void
|
||||
adjuststack(GISTSTACK *stk, BlockNumber blkno,
|
||||
static void adjuststack(GISTSTACK *stk, BlockNumber blkno,
|
||||
OffsetNumber offnum);
|
||||
static void
|
||||
adjustiptr(IndexScanDesc s, ItemPointer iptr,
|
||||
static void adjustiptr(IndexScanDesc s, ItemPointer iptr,
|
||||
int op, BlockNumber blkno, OffsetNumber offnum);
|
||||
|
||||
/*
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.21 1998/09/01 03:20:53 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.22 1998/09/01 04:26:48 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This file contains only the public interface routines.
|
||||
|
@ -118,7 +118,7 @@ hashbuild(Relation heap,
|
|||
tupleTable = 0;
|
||||
slot = 0;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
|
||||
/* build the index */
|
||||
nhtups = nitups = 0;
|
||||
|
@ -145,7 +145,7 @@ hashbuild(Relation heap,
|
|||
nitups++;
|
||||
continue;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -159,7 +159,7 @@ hashbuild(Relation heap,
|
|||
slot->val = htup;
|
||||
if (ExecQual((List *) pred, econtext) == false)
|
||||
continue;
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
nitups++;
|
||||
|
@ -232,7 +232,7 @@ hashbuild(Relation heap,
|
|||
#ifndef OMIT_PARTIAL_INDEX
|
||||
ExecDestroyTupleTable(tupleTable, true);
|
||||
pfree(econtext);
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.11 1998/09/01 03:20:54 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.12 1998/09/01 04:26:49 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* These functions are stored in pg_amproc. For each operator class
|
||||
|
@ -136,11 +136,11 @@ hashoid(Oid key)
|
|||
uint32
|
||||
hashoid8(Oid *key)
|
||||
{
|
||||
int i;
|
||||
uint32 result = 0;
|
||||
int i;
|
||||
uint32 result = 0;
|
||||
|
||||
for (i=0; i < 8; i++)
|
||||
result = result ^ (~(uint32)key[i]);
|
||||
for (i = 0; i < 8; i++)
|
||||
result = result ^ (~(uint32) key[i]);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.34 1998/09/01 03:21:05 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.35 1998/09/01 04:26:51 momjian Exp $
|
||||
*
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
|
@ -109,10 +109,10 @@ static bool ImmediateInvalidation;
|
|||
*/
|
||||
static void
|
||||
initscan(HeapScanDesc scan,
|
||||
Relation relation,
|
||||
int atend,
|
||||
unsigned nkeys,
|
||||
ScanKey key)
|
||||
Relation relation,
|
||||
int atend,
|
||||
unsigned nkeys,
|
||||
ScanKey key)
|
||||
{
|
||||
if (!RelationGetNumberOfBlocks(relation))
|
||||
{
|
||||
|
@ -258,7 +258,7 @@ heapgettup(Relation relation,
|
|||
elog(DEBUG, "heapgettup: relation(%c)=`%s', %p",
|
||||
relation->rd_rel->relkind, &relation->rd_rel->relname,
|
||||
snapshot);
|
||||
#endif /* !defined(HEAPDEBUGALL) */
|
||||
#endif /* !defined(HEAPDEBUGALL) */
|
||||
|
||||
if (!ItemPointerIsValid(tid))
|
||||
Assert(!PointerIsValid(tid));
|
||||
|
@ -283,12 +283,12 @@ heapgettup(Relation relation,
|
|||
/* assume it is a valid TID XXX */
|
||||
if (ItemPointerIsValid(tid) == false)
|
||||
{
|
||||
*buf= InvalidBuffer;
|
||||
*buf = InvalidBuffer;
|
||||
return NULL;
|
||||
}
|
||||
*buf = RelationGetBufferWithBuffer(relation,
|
||||
ItemPointerGetBlockNumber(tid),
|
||||
*buf);
|
||||
ItemPointerGetBlockNumber(tid),
|
||||
*buf);
|
||||
|
||||
#ifndef NO_BUFFERISVALID
|
||||
if (!BufferIsValid(*buf))
|
||||
|
@ -414,6 +414,7 @@ heapgettup(Relation relation,
|
|||
|
||||
if (ItemPointerGetBlockNumber(iptr) != page)
|
||||
{
|
||||
|
||||
/*
|
||||
* set block id to the correct page number --- this is
|
||||
* a hack to support the virtual fragment concept
|
||||
|
@ -762,7 +763,7 @@ elog(DEBUG, "heap_getnext([%s,nkeys=%d],backw=%d) called", \
|
|||
#define HEAPDEBUG_5
|
||||
#define HEAPDEBUG_6
|
||||
#define HEAPDEBUG_7
|
||||
#endif /* !defined(HEAPDEBUGALL) */
|
||||
#endif /* !defined(HEAPDEBUGALL) */
|
||||
|
||||
|
||||
HeapTuple
|
||||
|
@ -990,7 +991,7 @@ heap_getnext(HeapScanDesc scandesc, int backw)
|
|||
* value, and they are required to BuffferRelease() it when they
|
||||
* are done. If they want to make a copy of it before releasing it,
|
||||
* they can call heap_copytyple().
|
||||
|
||||
|
||||
* ----------------
|
||||
*/
|
||||
HeapTuple
|
||||
|
@ -1005,8 +1006,8 @@ heap_fetch(Relation relation,
|
|||
HeapTuple tuple;
|
||||
OffsetNumber offnum;
|
||||
|
||||
AssertMacro(PointerIsValid(userbuf)); /* see comments above */
|
||||
|
||||
AssertMacro(PointerIsValid(userbuf)); /* see comments above */
|
||||
|
||||
/* ----------------
|
||||
* increment access statistics
|
||||
* ----------------
|
||||
|
@ -1074,7 +1075,8 @@ heap_fetch(Relation relation,
|
|||
* ----------------
|
||||
*/
|
||||
|
||||
*userbuf = buffer; /* user is required to ReleaseBuffer() this */
|
||||
*userbuf = buffer; /* user is required to ReleaseBuffer()
|
||||
* this */
|
||||
|
||||
return tuple;
|
||||
}
|
||||
|
@ -1193,7 +1195,7 @@ heap_delete(Relation relation, ItemPointer tid)
|
|||
{ /* XXX L_SH better ??? */
|
||||
elog(ERROR, "heap_delete: failed ReadBuffer");
|
||||
}
|
||||
#endif /* NO_BUFFERISVALID */
|
||||
#endif /* NO_BUFFERISVALID */
|
||||
|
||||
dp = (PageHeader) BufferGetPage(buf);
|
||||
lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(tid));
|
||||
|
@ -1206,10 +1208,11 @@ heap_delete(Relation relation, ItemPointer tid)
|
|||
Assert(HeapTupleIsValid(tp));
|
||||
if (TupleUpdatedByCurXactAndCmd(tp))
|
||||
{
|
||||
|
||||
/*
|
||||
Vadim says this is no longer needed 1998/6/15
|
||||
elog(NOTICE, "Non-functional delete, tuple already deleted");
|
||||
*/
|
||||
* Vadim says this is no longer needed 1998/6/15 elog(NOTICE,
|
||||
* "Non-functional delete, tuple already deleted");
|
||||
*/
|
||||
if (IsSystemRelationName(RelationGetRelationName(relation)->data))
|
||||
RelationUnsetLockForWrite(relation);
|
||||
ReleaseBuffer(buf);
|
||||
|
@ -1309,7 +1312,7 @@ heap_replace(Relation relation, ItemPointer otid, HeapTuple replace_tuple)
|
|||
/* XXX L_SH better ??? */
|
||||
elog(ERROR, "amreplace: failed ReadBuffer");
|
||||
}
|
||||
#endif /* NO_BUFFERISVALID */
|
||||
#endif /* NO_BUFFERISVALID */
|
||||
|
||||
dp = (Page) BufferGetPage(buffer);
|
||||
lp = PageGetItemId(dp, ItemPointerGetOffsetNumber(otid));
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.24 1998/09/01 03:21:09 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.25 1998/09/01 04:26:55 momjian Exp $
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
* index_open - open an index relation by relationId
|
||||
|
@ -112,7 +112,7 @@
|
|||
CppAsString(x), CppAsString(y)) \
|
||||
: (void)NULL \
|
||||
)
|
||||
|
||||
|
||||
#define GET_SCAN_PROCEDURE(x,y) \
|
||||
( \
|
||||
procedure = scan->relation->rd_am->y, \
|
||||
|
@ -331,7 +331,7 @@ index_getnext(IndexScanDesc scan,
|
|||
* have the am's gettuple proc do all the work.
|
||||
* ----------------
|
||||
*/
|
||||
result = (RetrieveIndexResult)fmgr(procedure, scan, direction);
|
||||
result = (RetrieveIndexResult) fmgr(procedure, scan, direction);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.27 1998/09/01 03:21:10 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.28 1998/09/01 04:26:56 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -29,16 +29,13 @@
|
|||
|
||||
#ifdef USE_ASSERT_CHECKING
|
||||
static bool StrategyEvaluationIsValid(StrategyEvaluation evaluation);
|
||||
static bool
|
||||
StrategyExpressionIsValid(StrategyExpression expression,
|
||||
static bool StrategyExpressionIsValid(StrategyExpression expression,
|
||||
StrategyNumber maxStrategy);
|
||||
static ScanKey StrategyMapGetScanKeyEntry(StrategyMap map,
|
||||
StrategyNumber strategyNumber);
|
||||
static bool
|
||||
StrategyOperatorIsValid(StrategyOperator operator,
|
||||
static bool StrategyOperatorIsValid(StrategyOperator operator,
|
||||
StrategyNumber maxStrategy);
|
||||
static bool
|
||||
StrategyTermIsValid(StrategyTerm term,
|
||||
static bool StrategyTermIsValid(StrategyTerm term,
|
||||
StrategyNumber maxStrategy);
|
||||
|
||||
#endif
|
||||
|
@ -378,8 +375,8 @@ RelationInvokeStrategy(Relation relation,
|
|||
termData.degree = 1;
|
||||
|
||||
strategyMap = IndexStrategyGetStrategyMap(RelationGetIndexStrategy(relation),
|
||||
evaluation->maxStrategy,
|
||||
attributeNumber);
|
||||
evaluation->maxStrategy,
|
||||
attributeNumber);
|
||||
|
||||
entry = StrategyMapGetScanKeyEntry(strategyMap, strategy);
|
||||
|
||||
|
@ -456,9 +453,7 @@ RelationInvokeStrategy(Relation relation,
|
|||
}
|
||||
|
||||
if (index == (*termP)->degree)
|
||||
{
|
||||
return StrategyTermEvaluate(*termP, strategyMap, left, right);
|
||||
}
|
||||
|
||||
termP += 1;
|
||||
}
|
||||
|
@ -494,7 +489,7 @@ OperatorRelationFillScanKeyEntry(Relation operatorRelation,
|
|||
else
|
||||
{
|
||||
ScanKeyData scanKeyData;
|
||||
|
||||
|
||||
ScanKeyEntryInitialize(&scanKeyData, 0,
|
||||
ObjectIdAttributeNumber,
|
||||
F_OIDEQ,
|
||||
|
@ -502,7 +497,7 @@ OperatorRelationFillScanKeyEntry(Relation operatorRelation,
|
|||
|
||||
scan = heap_beginscan(operatorRelation, false, SnapshotNow,
|
||||
1, &scanKeyData);
|
||||
|
||||
|
||||
tuple = heap_getnext(scan, 0);
|
||||
}
|
||||
|
||||
|
@ -521,7 +516,7 @@ OperatorRelationFillScanKeyEntry(Relation operatorRelation,
|
|||
|
||||
if (IsBootstrapProcessingMode())
|
||||
heap_endscan(scan);
|
||||
|
||||
|
||||
if (!RegProcedureIsValid(entry->sk_procedure))
|
||||
{
|
||||
elog(ERROR,
|
||||
|
@ -565,7 +560,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
|
|||
ScanKeyEntryInitialize(&entry[0], 0, Anum_pg_index_indexrelid,
|
||||
F_OIDEQ,
|
||||
ObjectIdGetDatum(indexObjectId));
|
||||
|
||||
|
||||
relation = heap_openr(IndexRelationName);
|
||||
scan = heap_beginscan(relation, false, SnapshotNow, 1, entry);
|
||||
tuple = heap_getnext(scan, 0);
|
||||
|
@ -601,7 +596,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
|
|||
heap_endscan(scan);
|
||||
heap_close(relation);
|
||||
}
|
||||
|
||||
|
||||
/* if support routines exist for this access method, load them */
|
||||
if (maxSupportNumber > 0)
|
||||
{
|
||||
|
@ -615,7 +610,7 @@ IndexSupportInitialize(IndexStrategy indexStrategy,
|
|||
relation = heap_openr(AccessMethodProcedureRelationName);
|
||||
|
||||
for (attributeNumber = 1; attributeNumber <= maxAttributeNumber;
|
||||
attributeNumber++)
|
||||
attributeNumber++)
|
||||
{
|
||||
int16 support;
|
||||
Form_pg_amproc form;
|
||||
|
@ -723,4 +718,4 @@ IndexStrategyDisplay(IndexStrategy indexStrategy,
|
|||
}
|
||||
}
|
||||
|
||||
#endif /* defined(ISTRATDEBUG) */
|
||||
#endif /* defined(ISTRATDEBUG) */
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.18 1998/09/01 03:21:12 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.19 1998/09/01 04:26:59 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* These functions are stored in pg_amproc. For each operator class
|
||||
|
@ -87,10 +87,11 @@ btoidcmp(Oid a, Oid b)
|
|||
int32
|
||||
btoid8cmp(Oid *a, Oid *b)
|
||||
{
|
||||
int i;
|
||||
for (i=0; i < 8; i++)
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 8; i++)
|
||||
/* we use this because we need the int4gt, etc */
|
||||
if (!int4eq(a[i], b[i]))
|
||||
if (!int4eq(a[i], b[i]))
|
||||
if (int4gt(a[i], b[i]))
|
||||
return 1;
|
||||
else
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.29 1998/09/01 03:21:13 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.30 1998/09/01 04:27:01 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -54,7 +54,7 @@ _bt_doinsert(Relation rel, BTItem btitem, bool index_is_unique, Relation heapRel
|
|||
int natts = rel->rd_rel->relnatts;
|
||||
InsertIndexResult res;
|
||||
Buffer buffer;
|
||||
|
||||
|
||||
itup = &(btitem->bti_itup);
|
||||
|
||||
/* we need a scan key to do our search, so build one */
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.31 1998/09/01 03:21:16 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.32 1998/09/01 04:27:03 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This file contains only the public interface routines.
|
||||
|
@ -44,7 +44,7 @@ bool BuildingBtree = false; /* see comment in btbuild() */
|
|||
bool FastBuild = true; /* use sort/build instead of insertion
|
||||
* build */
|
||||
|
||||
static void _bt_restscan(IndexScanDesc scan);
|
||||
static void _bt_restscan(IndexScanDesc scan);
|
||||
|
||||
/*
|
||||
* btbuild() -- build a new btree index.
|
||||
|
@ -151,7 +151,7 @@ btbuild(Relation heap,
|
|||
*/
|
||||
usefast = false;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
|
||||
/* start a heap scan */
|
||||
/* build the index */
|
||||
|
@ -184,7 +184,7 @@ btbuild(Relation heap,
|
|||
nitups++;
|
||||
continue;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -198,7 +198,7 @@ btbuild(Relation heap,
|
|||
slot->val = htup;
|
||||
if (ExecQual((List *) pred, econtext) == false)
|
||||
continue;
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
nitups++;
|
||||
|
@ -283,7 +283,7 @@ btbuild(Relation heap,
|
|||
#ifndef OMIT_PARTIAL_INDEX
|
||||
ExecDestroyTupleTable(tupleTable, true);
|
||||
pfree(econtext);
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -361,14 +361,13 @@ btinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation
|
|||
/*
|
||||
* See comments in btbuild.
|
||||
*
|
||||
* if (itup->t_info & INDEX_NULL_MASK)
|
||||
return (InsertIndexResult) NULL;
|
||||
* if (itup->t_info & INDEX_NULL_MASK) return (InsertIndexResult) NULL;
|
||||
*/
|
||||
|
||||
btitem = _bt_formitem(itup);
|
||||
|
||||
res = _bt_doinsert(rel, btitem,
|
||||
IndexIsUnique(RelationGetRelid(rel)), heapRel);
|
||||
IndexIsUnique(RelationGetRelid(rel)), heapRel);
|
||||
|
||||
pfree(btitem);
|
||||
pfree(itup);
|
||||
|
@ -397,27 +396,26 @@ btgettuple(IndexScanDesc scan, ScanDirection dir)
|
|||
|
||||
if (ItemPointerIsValid(&(scan->currentItemData)))
|
||||
{
|
||||
|
||||
/*
|
||||
* Now we don't adjust scans on insertion (comments in
|
||||
* nbtscan.c:_bt_scandel()) and I hope that we will unlock
|
||||
* current index page before leaving index in LLL: this
|
||||
* means that current index tuple could be moved right
|
||||
* before we get here and we have to restore our scan
|
||||
* position. We save heap TID pointed by current index
|
||||
* tuple and use it. This will work untill we start
|
||||
* to re-use (move heap tuples) without vacuum...
|
||||
* - vadim 07/29/98
|
||||
* nbtscan.c:_bt_scandel()) and I hope that we will unlock current
|
||||
* index page before leaving index in LLL: this means that current
|
||||
* index tuple could be moved right before we get here and we have
|
||||
* to restore our scan position. We save heap TID pointed by
|
||||
* current index tuple and use it. This will work untill we start
|
||||
* to re-use (move heap tuples) without vacuum... - vadim 07/29/98
|
||||
*/
|
||||
_bt_restscan(scan);
|
||||
res = _bt_next(scan, dir);
|
||||
}
|
||||
else
|
||||
res = _bt_first(scan, dir);
|
||||
|
||||
|
||||
/* Save heap TID to use it in _bt_restscan */
|
||||
if (res)
|
||||
((BTScanOpaque)scan->opaque)->curHeapIptr = res->heap_iptr;
|
||||
|
||||
((BTScanOpaque) scan->opaque)->curHeapIptr = res->heap_iptr;
|
||||
|
||||
return (char *) res;
|
||||
}
|
||||
|
||||
|
@ -627,33 +625,34 @@ btdelete(Relation rel, ItemPointer tid)
|
|||
static void
|
||||
_bt_restscan(IndexScanDesc scan)
|
||||
{
|
||||
Relation rel = scan->relation;
|
||||
BTScanOpaque so = (BTScanOpaque) scan->opaque;
|
||||
Buffer buf = so->btso_curbuf;
|
||||
Page page = BufferGetPage(buf);
|
||||
ItemPointer current = &(scan->currentItemData);
|
||||
OffsetNumber offnum = ItemPointerGetOffsetNumber(current),
|
||||
maxoff = PageGetMaxOffsetNumber(page);
|
||||
BTPageOpaque opaque = (BTPageOpaque) PageGetSpecialPointer(page);
|
||||
ItemPointerData target = so->curHeapIptr;
|
||||
BTItem item;
|
||||
BlockNumber blkno;
|
||||
Relation rel = scan->relation;
|
||||
BTScanOpaque so = (BTScanOpaque) scan->opaque;
|
||||
Buffer buf = so->btso_curbuf;
|
||||
Page page = BufferGetPage(buf);
|
||||
ItemPointer current = &(scan->currentItemData);
|
||||
OffsetNumber offnum = ItemPointerGetOffsetNumber(current),
|
||||
maxoff = PageGetMaxOffsetNumber(page);
|
||||
BTPageOpaque opaque = (BTPageOpaque) PageGetSpecialPointer(page);
|
||||
ItemPointerData target = so->curHeapIptr;
|
||||
BTItem item;
|
||||
BlockNumber blkno;
|
||||
|
||||
if (maxoff >= offnum)
|
||||
{
|
||||
/*
|
||||
* if the item is where we left it or has just moved right
|
||||
* on this page, we're done
|
||||
|
||||
/*
|
||||
* if the item is where we left it or has just moved right on this
|
||||
* page, we're done
|
||||
*/
|
||||
for ( ;
|
||||
for (;
|
||||
offnum <= maxoff;
|
||||
offnum = OffsetNumberNext(offnum))
|
||||
{
|
||||
item = (BTItem) PageGetItem(page, PageGetItemId(page, offnum));
|
||||
if (item->bti_itup.t_tid.ip_blkid.bi_hi == \
|
||||
target.ip_blkid.bi_hi && \
|
||||
target.ip_blkid.bi_hi && \
|
||||
item->bti_itup.t_tid.ip_blkid.bi_lo == \
|
||||
target.ip_blkid.bi_lo && \
|
||||
target.ip_blkid.bi_lo && \
|
||||
item->bti_itup.t_tid.ip_posid == target.ip_posid)
|
||||
{
|
||||
current->ip_posid = offnum;
|
||||
|
@ -662,8 +661,8 @@ _bt_restscan(IndexScanDesc scan)
|
|||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* By here, the item we're looking for moved right at least one page
|
||||
/*
|
||||
* By here, the item we're looking for moved right at least one page
|
||||
*/
|
||||
for (;;)
|
||||
{
|
||||
|
@ -678,15 +677,15 @@ _bt_restscan(IndexScanDesc scan)
|
|||
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
|
||||
|
||||
/* see if it's on this page */
|
||||
for (offnum = P_RIGHTMOST(opaque) ? P_HIKEY : P_FIRSTKEY ;
|
||||
for (offnum = P_RIGHTMOST(opaque) ? P_HIKEY : P_FIRSTKEY;
|
||||
offnum <= maxoff;
|
||||
offnum = OffsetNumberNext(offnum))
|
||||
{
|
||||
item = (BTItem) PageGetItem(page, PageGetItemId(page, offnum));
|
||||
if (item->bti_itup.t_tid.ip_blkid.bi_hi == \
|
||||
target.ip_blkid.bi_hi && \
|
||||
target.ip_blkid.bi_hi && \
|
||||
item->bti_itup.t_tid.ip_blkid.bi_lo == \
|
||||
target.ip_blkid.bi_lo && \
|
||||
target.ip_blkid.bi_lo && \
|
||||
item->bti_itup.t_tid.ip_posid == target.ip_posid)
|
||||
{
|
||||
ItemPointerSet(current, blkno, offnum);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtscan.c,v 1.17 1998/09/01 03:21:17 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtscan.c,v 1.18 1998/09/01 04:27:04 momjian Exp $
|
||||
*
|
||||
*
|
||||
* NOTES
|
||||
|
@ -166,10 +166,10 @@ _bt_scandel(IndexScanDesc scan, int op, BlockNumber blkno, OffsetNumber offno)
|
|||
so->btso_curbuf = buf;
|
||||
if (ItemPointerIsValid(current))
|
||||
{
|
||||
Page page = BufferGetPage(buf);
|
||||
BTItem btitem = (BTItem) PageGetItem(page,
|
||||
PageGetItemId(page, ItemPointerGetOffsetNumber(current)));
|
||||
|
||||
Page page = BufferGetPage(buf);
|
||||
BTItem btitem = (BTItem) PageGetItem(page,
|
||||
PageGetItemId(page, ItemPointerGetOffsetNumber(current)));
|
||||
|
||||
so->curHeapIptr = btitem->bti_itup.t_tid;
|
||||
}
|
||||
}
|
||||
|
@ -209,10 +209,10 @@ _bt_scandel(IndexScanDesc scan, int op, BlockNumber blkno, OffsetNumber offno)
|
|||
scan->currentItemData = tmp;
|
||||
if (ItemPointerIsValid(current))
|
||||
{
|
||||
Page page = BufferGetPage(buf);
|
||||
BTItem btitem = (BTItem) PageGetItem(page,
|
||||
PageGetItemId(page, ItemPointerGetOffsetNumber(current)));
|
||||
|
||||
Page page = BufferGetPage(buf);
|
||||
BTItem btitem = (BTItem) PageGetItem(page,
|
||||
PageGetItemId(page, ItemPointerGetOffsetNumber(current)));
|
||||
|
||||
so->mrkHeapIptr = btitem->bti_itup.t_tid;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.37 1998/09/01 03:21:18 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.38 1998/09/01 04:27:06 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -28,14 +28,11 @@
|
|||
#endif
|
||||
|
||||
|
||||
static BTStack
|
||||
_bt_searchr(Relation rel, int keysz, ScanKey scankey,
|
||||
static BTStack _bt_searchr(Relation rel, int keysz, ScanKey scankey,
|
||||
Buffer *bufP, BTStack stack_in);
|
||||
static OffsetNumber
|
||||
_bt_firsteq(Relation rel, TupleDesc itupdesc, Page page,
|
||||
static OffsetNumber _bt_firsteq(Relation rel, TupleDesc itupdesc, Page page,
|
||||
Size keysz, ScanKey scankey, OffsetNumber offnum);
|
||||
static int
|
||||
_bt_compare(Relation rel, TupleDesc itupdesc, Page page,
|
||||
static int _bt_compare(Relation rel, TupleDesc itupdesc, Page page,
|
||||
int keysz, ScanKey scankey, OffsetNumber offnum);
|
||||
static bool
|
||||
_bt_twostep(IndexScanDesc scan, Buffer *bufP, ScanDirection dir);
|
||||
|
@ -219,8 +216,8 @@ _bt_moveright(Relation rel,
|
|||
if (_bt_skeycmp(rel, keysz, scankey, page,
|
||||
PageGetItemId(page, P_FIRSTKEY),
|
||||
BTEqualStrategyNumber))
|
||||
elog(FATAL, "btree: BTP_CHAIN flag was expected in %s (access = %s)",
|
||||
rel->rd_rel->relname, access ? "bt_write" : "bt_read");
|
||||
elog(FATAL, "btree: BTP_CHAIN flag was expected in %s (access = %s)",
|
||||
rel->rd_rel->relname, access ? "bt_write" : "bt_read");
|
||||
if (_bt_skeycmp(rel, keysz, scankey, page,
|
||||
PageGetItemId(page, offmax),
|
||||
BTEqualStrategyNumber))
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Id: nbtsort.c,v 1.32 1998/09/01 03:21:19 momjian Exp $
|
||||
* $Id: nbtsort.c,v 1.33 1998/09/01 04:27:07 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
*
|
||||
|
@ -184,7 +184,7 @@ _bt_isortcmp(BTSortKey *k1, BTSortKey *k2)
|
|||
return 1; /* 1 > 2 */
|
||||
}
|
||||
else if (k2->btsk_item == (BTItem) NULL)
|
||||
return -1; /* 1 < 2 */
|
||||
return -1; /* 1 < 2 */
|
||||
|
||||
for (i = 0; i < _bt_nattr; i++)
|
||||
{
|
||||
|
@ -198,14 +198,14 @@ _bt_isortcmp(BTSortKey *k1, BTSortKey *k2)
|
|||
return 1; /* NULL ">" NOT_NULL */
|
||||
}
|
||||
else if (k2_nulls[i] != ' ') /* k2 attr is NULL */
|
||||
return -1; /* NOT_NULL "<" NULL */
|
||||
return -1; /* NOT_NULL "<" NULL */
|
||||
|
||||
if (_bt_invokestrat(_bt_sortrel, i + 1, BTGreaterStrategyNumber,
|
||||
k1_datum[i], k2_datum[i]))
|
||||
return 1; /* 1 > 2 */
|
||||
else if (_bt_invokestrat(_bt_sortrel, i + 1, BTGreaterStrategyNumber,
|
||||
k2_datum[i], k1_datum[i]))
|
||||
return -1; /* 1 < 2 */
|
||||
return -1; /* 1 < 2 */
|
||||
}
|
||||
|
||||
if (_bt_inspool->isunique && !equal_isnull)
|
||||
|
@ -731,7 +731,7 @@ _bt_spool(Relation index, BTItem btitem, void *spool)
|
|||
printf("_bt_spool: inserted <%x> into output tape %d\n",
|
||||
d, btspool->bts_tape);
|
||||
}
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_SPOOL */
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_SPOOL */
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -975,7 +975,7 @@ _bt_buildadd(Relation index, void *pstate, BTItem bti, int flags)
|
|||
printf("_bt_buildadd: moved <%x> to offset %d at level %d\n",
|
||||
d, n, state->btps_level);
|
||||
}
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -1058,7 +1058,7 @@ _bt_buildadd(Relation index, void *pstate, BTItem bti, int flags)
|
|||
printf("_bt_buildadd: inserted <%x> at offset %d at level %d\n",
|
||||
d, off, state->btps_level);
|
||||
}
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
#endif
|
||||
if (last_bti == (BTItem) NULL)
|
||||
first_off = P_FIRSTKEY;
|
||||
|
@ -1254,7 +1254,7 @@ _bt_merge(Relation index, BTSpool *btspool)
|
|||
npass, nruns, d, t,
|
||||
BufferGetBlockNumber(state->btps_buf));
|
||||
}
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -1283,7 +1283,7 @@ _bt_merge(Relation index, BTSpool *btspool)
|
|||
npass, nruns, d, t,
|
||||
btspool->bts_tape);
|
||||
}
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
}
|
||||
|
||||
if (btsk.btsk_datum != (Datum *) NULL)
|
||||
|
@ -1408,7 +1408,7 @@ _bt_upperbuild(Relation index)
|
|||
printf("_bt_upperbuild: inserting <%x> at %d\n",
|
||||
d, state->btps_level);
|
||||
}
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
#endif /* FASTBUILD_DEBUG && FASTBUILD_MERGE */
|
||||
_bt_buildadd(index, state, nbti, 0);
|
||||
pfree((void *) nbti);
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtget.c,v 1.11 1998/09/01 03:21:24 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtget.c,v 1.12 1998/09/01 04:27:09 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -27,8 +27,7 @@
|
|||
#endif
|
||||
|
||||
|
||||
static OffsetNumber
|
||||
findnext(IndexScanDesc s, Page p, OffsetNumber n,
|
||||
static OffsetNumber findnext(IndexScanDesc s, Page p, OffsetNumber n,
|
||||
ScanDirection dir);
|
||||
static RetrieveIndexResult rtscancache(IndexScanDesc s, ScanDirection dir);
|
||||
static RetrieveIndexResult rtfirst(IndexScanDesc s, ScanDirection dir);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.27 1998/09/01 03:21:27 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.28 1998/09/01 04:27:10 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -50,25 +50,19 @@ typedef struct RTSTATE
|
|||
} RTSTATE;
|
||||
|
||||
/* non-export function prototypes */
|
||||
static InsertIndexResult
|
||||
rtdoinsert(Relation r, IndexTuple itup,
|
||||
static InsertIndexResult rtdoinsert(Relation r, IndexTuple itup,
|
||||
RTSTATE *rtstate);
|
||||
static void
|
||||
rttighten(Relation r, RTSTACK *stk, char *datum, int att_size,
|
||||
static void rttighten(Relation r, RTSTACK *stk, char *datum, int att_size,
|
||||
RTSTATE *rtstate);
|
||||
static InsertIndexResult
|
||||
dosplit(Relation r, Buffer buffer, RTSTACK *stack,
|
||||
static InsertIndexResult dosplit(Relation r, Buffer buffer, RTSTACK *stack,
|
||||
IndexTuple itup, RTSTATE *rtstate);
|
||||
static void
|
||||
rtintinsert(Relation r, RTSTACK *stk, IndexTuple ltup,
|
||||
static void rtintinsert(Relation r, RTSTACK *stk, IndexTuple ltup,
|
||||
IndexTuple rtup, RTSTATE *rtstate);
|
||||
static void rtnewroot(Relation r, IndexTuple lt, IndexTuple rt);
|
||||
static void
|
||||
picksplit(Relation r, Page page, SPLITVEC *v, IndexTuple itup,
|
||||
static void picksplit(Relation r, Page page, SPLITVEC *v, IndexTuple itup,
|
||||
RTSTATE *rtstate);
|
||||
static void RTInitBuffer(Buffer b, uint32 f);
|
||||
static OffsetNumber
|
||||
choose(Relation r, Page p, IndexTuple it,
|
||||
static OffsetNumber choose(Relation r, Page p, IndexTuple it,
|
||||
RTSTATE *rtstate);
|
||||
static int nospace(Page p, IndexTuple it);
|
||||
static void initRtstate(RTSTATE *rtstate, Relation index);
|
||||
|
@ -163,12 +157,12 @@ rtbuild(Relation heap,
|
|||
tupleTable = NULL;
|
||||
slot = NULL;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
|
||||
/* count the tuples as we insert them */
|
||||
nh = ni = 0;
|
||||
|
||||
scan = heap_beginscan(heap, 0, SnapshotNow, 0, (ScanKey) NULL);
|
||||
scan = heap_beginscan(heap, 0, SnapshotNow, 0, (ScanKey) NULL);
|
||||
|
||||
while (HeapTupleIsValid(htup = heap_getnext(scan, 0)))
|
||||
{
|
||||
|
@ -188,7 +182,7 @@ rtbuild(Relation heap,
|
|||
ni++;
|
||||
continue;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -202,7 +196,7 @@ rtbuild(Relation heap,
|
|||
slot->val = htup;
|
||||
if (ExecQual((List *) pred, econtext) == false)
|
||||
continue;
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
ni++;
|
||||
|
@ -263,7 +257,7 @@ rtbuild(Relation heap,
|
|||
#ifndef OMIT_PARTIAL_INDEX
|
||||
ExecDestroyTupleTable(tupleTable, true);
|
||||
pfree(econtext);
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -1042,4 +1036,4 @@ _rtdump(Relation r)
|
|||
}
|
||||
}
|
||||
|
||||
#endif /* defined RTDEBUG */
|
||||
#endif /* defined RTDEBUG */
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.18 1998/09/01 03:21:28 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.19 1998/09/01 04:27:12 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -30,14 +30,11 @@
|
|||
/* routines defined and used here */
|
||||
static void rtregscan(IndexScanDesc s);
|
||||
static void rtdropscan(IndexScanDesc s);
|
||||
static void
|
||||
rtadjone(IndexScanDesc s, int op, BlockNumber blkno,
|
||||
static void rtadjone(IndexScanDesc s, int op, BlockNumber blkno,
|
||||
OffsetNumber offnum);
|
||||
static void
|
||||
adjuststack(RTSTACK *stk, BlockNumber blkno,
|
||||
static void adjuststack(RTSTACK *stk, BlockNumber blkno,
|
||||
OffsetNumber offnum);
|
||||
static void
|
||||
adjustiptr(IndexScanDesc s, ItemPointer iptr,
|
||||
static void adjustiptr(IndexScanDesc s, ItemPointer iptr,
|
||||
int op, BlockNumber blkno, OffsetNumber offnum);
|
||||
|
||||
/*
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.9 1998/09/01 03:21:30 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.10 1998/09/01 04:27:13 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -18,8 +18,7 @@
|
|||
#include <access/rtree.h>
|
||||
#include <access/istrat.h>
|
||||
|
||||
static StrategyNumber
|
||||
RelationGetRTStrategy(Relation r,
|
||||
static StrategyNumber RelationGetRTStrategy(Relation r,
|
||||
AttrNumber attnum, RegProcedure proc);
|
||||
|
||||
/*
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.18 1998/09/01 03:21:31 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.19 1998/09/01 04:27:15 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This file contains the high level access-method interface to the
|
||||
|
@ -29,8 +29,7 @@
|
|||
static int RecoveryCheckingEnabled(void);
|
||||
static void TransRecover(Relation logRelation);
|
||||
static bool TransactionLogTest(TransactionId transactionId, XidStatus status);
|
||||
static void
|
||||
TransactionLogUpdate(TransactionId transactionId,
|
||||
static void TransactionLogUpdate(TransactionId transactionId,
|
||||
XidStatus status);
|
||||
|
||||
/* ----------------
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.16 1998/01/07 21:02:19 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.17 1998/09/01 04:27:16 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This file contains support functions for the high
|
||||
|
@ -23,11 +23,9 @@
|
|||
#include <access/xact.h>
|
||||
#include <storage/lmgr.h>
|
||||
|
||||
static XidStatus
|
||||
TransBlockGetXidStatus(Block tblock,
|
||||
static XidStatus TransBlockGetXidStatus(Block tblock,
|
||||
TransactionId transactionId);
|
||||
static void
|
||||
TransBlockSetXidStatus(Block tblock,
|
||||
static void TransBlockSetXidStatus(Block tblock,
|
||||
TransactionId transactionId, XidStatus xstatus);
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.16 1998/07/21 06:17:13 vadim Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.17 1998/09/01 04:27:18 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -31,7 +31,7 @@ static void VariableRelationPutNextOid(Oid *oidP);
|
|||
*/
|
||||
int OidGenLockId;
|
||||
|
||||
VariableCache ShmemVariableCache = NULL;
|
||||
VariableCache ShmemVariableCache = NULL;
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* variable relation query/update routines
|
||||
|
@ -292,11 +292,11 @@ GetNewTransactionId(TransactionId *xid)
|
|||
}
|
||||
|
||||
SpinAcquire(OidGenLockId); /* not good for concurrency... */
|
||||
|
||||
|
||||
if (ShmemVariableCache->xid_count == 0)
|
||||
{
|
||||
TransactionId nextid;
|
||||
|
||||
|
||||
VariableRelationGetNextXid(&nextid);
|
||||
TransactionIdStore(nextid, &(ShmemVariableCache->nextXid));
|
||||
ShmemVariableCache->xid_count = VAR_XID_PREFETCH;
|
||||
|
@ -307,7 +307,7 @@ GetNewTransactionId(TransactionId *xid)
|
|||
TransactionIdStore(ShmemVariableCache->nextXid, xid);
|
||||
TransactionIdAdd(&(ShmemVariableCache->nextXid), 1);
|
||||
(ShmemVariableCache->xid_count)--;
|
||||
|
||||
|
||||
SpinRelease(OidGenLockId);
|
||||
}
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.22 1998/09/01 03:21:33 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.23 1998/09/01 04:27:19 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Transaction aborts can now occur two ways:
|
||||
|
@ -898,7 +898,7 @@ CommitTransaction()
|
|||
* ----------------
|
||||
*/
|
||||
|
||||
/* handle commit for large objects [ PA, 7/17/98 ] */
|
||||
/* handle commit for large objects [ PA, 7/17/98 ] */
|
||||
_lo_commit();
|
||||
|
||||
CloseSequences();
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.50 1998/09/01 03:21:36 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.51 1998/09/01 04:27:21 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -325,7 +325,8 @@ BootstrapMain(int argc, char *argv[])
|
|||
DataDir = optarg;
|
||||
break;
|
||||
case 'd':
|
||||
DebugMode = true; /* print out debugging info while parsing */
|
||||
DebugMode = true; /* print out debugging info while
|
||||
* parsing */
|
||||
break;
|
||||
case 'C':
|
||||
Noversion = true;
|
||||
|
@ -601,7 +602,7 @@ DefineAttr(char *name, char *type, int attnum)
|
|||
printf("<%s %s> ", attrtypes[attnum]->attname.data, type);
|
||||
attrtypes[attnum]->attnum = 1 + attnum; /* fillatt */
|
||||
attlen = attrtypes[attnum]->attlen = Procid[typeoid].len;
|
||||
attrtypes[attnum]->attbyval = (attlen == 1) || (attlen == 2) ||(attlen == 4);
|
||||
attrtypes[attnum]->attbyval = (attlen == 1) || (attlen == 2) || (attlen == 4);
|
||||
attrtypes[attnum]->attalign = 'i';
|
||||
}
|
||||
attrtypes[attnum]->attcacheoff = -1;
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.15 1998/09/01 03:21:38 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.16 1998/09/01 04:27:27 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* See acl.h.
|
||||
|
@ -185,7 +185,7 @@ get_grosysid(char *groname)
|
|||
|
||||
tuple = SearchSysCacheTuple(GRONAME,
|
||||
PointerGetDatum(groname),
|
||||
0, 0, 0);
|
||||
0, 0, 0);
|
||||
if (HeapTupleIsValid(tuple))
|
||||
id = ((Form_pg_group) GETSTRUCT(tuple))->grosysid;
|
||||
else
|
||||
|
@ -201,7 +201,7 @@ get_groname(AclId grosysid)
|
|||
|
||||
tuple = SearchSysCacheTuple(GROSYSID,
|
||||
ObjectIdGetDatum(grosysid),
|
||||
0, 0, 0);
|
||||
0, 0, 0);
|
||||
if (HeapTupleIsValid(tuple))
|
||||
name = (((Form_pg_group) GETSTRUCT(tuple))->groname).data;
|
||||
else
|
||||
|
@ -229,13 +229,13 @@ in_group(AclId uid, AclId gid)
|
|||
}
|
||||
tuple = SearchSysCacheTuple(GROSYSID,
|
||||
ObjectIdGetDatum(gid),
|
||||
0, 0, 0);
|
||||
0, 0, 0);
|
||||
if (HeapTupleIsValid(tuple) &&
|
||||
!heap_attisnull(tuple, Anum_pg_group_grolist))
|
||||
{
|
||||
tmp = (IdList *) heap_getattr(tuple,
|
||||
Anum_pg_group_grolist,
|
||||
RelationGetDescr(relation),
|
||||
RelationGetDescr(relation),
|
||||
(bool *) NULL);
|
||||
/* XXX make me a function */
|
||||
num = IDLIST_NUM(tmp);
|
||||
|
@ -369,7 +369,7 @@ pg_aclcheck(char *relname, char *usename, AclMode mode)
|
|||
|
||||
tuple = SearchSysCacheTuple(USENAME,
|
||||
PointerGetDatum(usename),
|
||||
0, 0, 0);
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "pg_aclcheck: user \"%s\" not found",
|
||||
usename);
|
||||
|
@ -420,8 +420,8 @@ pg_aclcheck(char *relname, char *usename, AclMode mode)
|
|||
|
||||
#ifndef ACLDEBUG
|
||||
tuple = SearchSysCacheTuple(RELNAME,
|
||||
PointerGetDatum(relname),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(relname),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
{
|
||||
elog(ERROR, "pg_aclcheck: class \"%s\" not found",
|
||||
|
@ -450,10 +450,10 @@ pg_aclcheck(char *relname, char *usename, AclMode mode)
|
|||
|
||||
relation = heap_openr(RelationRelationName);
|
||||
ownerId = (int4) heap_getattr(tuple,
|
||||
Anum_pg_class_relowner,
|
||||
RelationGetDescr(relation),
|
||||
(bool *) NULL);
|
||||
acl = aclownerdefault(relname, (AclId)ownerId);
|
||||
Anum_pg_class_relowner,
|
||||
RelationGetDescr(relation),
|
||||
(bool *) NULL);
|
||||
acl = aclownerdefault(relname, (AclId) ownerId);
|
||||
}
|
||||
#else
|
||||
{ /* This is why the syscache is great... */
|
||||
|
@ -469,14 +469,14 @@ pg_aclcheck(char *relname, char *usename, AclMode mode)
|
|||
return ACLCHECK_NO_CLASS;
|
||||
}
|
||||
tuple = SearchSysCacheTuple(RELNAME,
|
||||
PointerGetDatum(relname),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(relname),
|
||||
0, 0, 0);
|
||||
if (HeapTupleIsValid(tuple) &&
|
||||
!heap_attisnull(tuple, Anum_pg_class_relacl))
|
||||
{
|
||||
tmp = (Acl *) heap_getattr(tuple,
|
||||
Anum_pg_class_relacl,
|
||||
RelationGetDescr(relation),
|
||||
RelationGetDescr(relation),
|
||||
(bool *) NULL);
|
||||
acl = makeacl(ACL_NUM(tmp));
|
||||
memmove((char *) acl, (char *) tmp, ACL_SIZE(tmp));
|
||||
|
@ -501,7 +501,7 @@ pg_ownercheck(char *usename,
|
|||
|
||||
tuple = SearchSysCacheTuple(USENAME,
|
||||
PointerGetDatum(usename),
|
||||
0, 0, 0);
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "pg_ownercheck: user \"%s\" not found",
|
||||
usename);
|
||||
|
@ -520,7 +520,7 @@ pg_ownercheck(char *usename,
|
|||
}
|
||||
|
||||
tuple = SearchSysCacheTuple(cacheid, PointerGetDatum(value),
|
||||
0, 0, 0);
|
||||
0, 0, 0);
|
||||
switch (cacheid)
|
||||
{
|
||||
case OPROID:
|
||||
|
@ -568,7 +568,7 @@ pg_func_ownercheck(char *usename,
|
|||
|
||||
tuple = SearchSysCacheTuple(USENAME,
|
||||
PointerGetDatum(usename),
|
||||
0, 0, 0);
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "pg_func_ownercheck: user \"%s\" not found",
|
||||
usename);
|
||||
|
@ -587,10 +587,10 @@ pg_func_ownercheck(char *usename,
|
|||
}
|
||||
|
||||
tuple = SearchSysCacheTuple(PRONAME,
|
||||
PointerGetDatum(funcname),
|
||||
Int32GetDatum(nargs),
|
||||
PointerGetDatum(arglist),
|
||||
0);
|
||||
PointerGetDatum(funcname),
|
||||
Int32GetDatum(nargs),
|
||||
PointerGetDatum(arglist),
|
||||
0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
func_error("pg_func_ownercheck", funcname, nargs, arglist, NULL);
|
||||
|
||||
|
@ -610,7 +610,7 @@ pg_aggr_ownercheck(char *usename,
|
|||
|
||||
tuple = SearchSysCacheTuple(USENAME,
|
||||
PointerGetDatum(usename),
|
||||
0, 0, 0);
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "pg_aggr_ownercheck: user \"%s\" not found",
|
||||
usename);
|
||||
|
@ -629,9 +629,9 @@ pg_aggr_ownercheck(char *usename,
|
|||
}
|
||||
|
||||
tuple = SearchSysCacheTuple(AGGNAME,
|
||||
PointerGetDatum(aggname),
|
||||
ObjectIdGetDatum(basetypeID),
|
||||
0, 0);
|
||||
PointerGetDatum(aggname),
|
||||
ObjectIdGetDatum(basetypeID),
|
||||
0, 0);
|
||||
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
agg_error("pg_aggr_ownercheck", aggname, basetypeID);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.17 1998/09/01 03:21:40 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.18 1998/09/01 04:27:28 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -174,7 +174,7 @@ fillatt(TupleDesc tupleDesc)
|
|||
for (i = 0; i < natts;)
|
||||
{
|
||||
tuple = SearchSysCacheTuple(TYPOID,
|
||||
ObjectIdGetDatum((*attributeP)->atttypid),
|
||||
ObjectIdGetDatum((*attributeP)->atttypid),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
{
|
||||
|
@ -193,7 +193,7 @@ fillatt(TupleDesc tupleDesc)
|
|||
*/
|
||||
if (!(*attributeP)->attisset)
|
||||
{
|
||||
typp = (Form_pg_type) GETSTRUCT(tuple); /* XXX */
|
||||
typp = (Form_pg_type) GETSTRUCT(tuple); /* XXX */
|
||||
(*attributeP)->attlen = typp->typlen;
|
||||
(*attributeP)->attbyval = typp->typbyval;
|
||||
}
|
||||
|
|
|
@ -7,12 +7,12 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.63 1998/09/01 03:21:41 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.64 1998/09/01 04:27:29 momjian Exp $
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
* heap_create() - Create an uncataloged heap relation
|
||||
* heap_create_with_catalog() - Create a cataloged relation
|
||||
* heap_destroy_with_catalog() - Removes named relation from catalogs
|
||||
* heap_destroy_with_catalog() - Removes named relation from catalogs
|
||||
*
|
||||
* NOTES
|
||||
* this code taken from access/heap/create.c, which contains
|
||||
|
@ -65,10 +65,9 @@
|
|||
#include <string.h>
|
||||
#endif
|
||||
|
||||
static void
|
||||
AddPgRelationTuple(Relation pg_class_desc,
|
||||
Relation new_rel_desc, Oid new_rel_oid, unsigned natts,
|
||||
char relkind);
|
||||
static void AddPgRelationTuple(Relation pg_class_desc,
|
||||
Relation new_rel_desc, Oid new_rel_oid, unsigned natts,
|
||||
char relkind);
|
||||
static void AddToTempRelList(Relation r);
|
||||
static void DeletePgAttributeTuples(Relation rel);
|
||||
static void DeletePgRelationTuple(Relation rel);
|
||||
|
@ -317,7 +316,7 @@ heap_create(char *name,
|
|||
* ----------------
|
||||
*/
|
||||
|
||||
rel->rd_tmpunlinked = TRUE; /* change once table is created */
|
||||
rel->rd_tmpunlinked = TRUE; /* change once table is created */
|
||||
rel->rd_fd = (File) smgrcreate(DEFAULT_SMGR, rel);
|
||||
rel->rd_tmpunlinked = FALSE;
|
||||
|
||||
|
@ -479,8 +478,8 @@ RelationAlreadyExists(Relation pg_class_desc, char *relname)
|
|||
if (!IsBootstrapProcessingMode())
|
||||
{
|
||||
tup = SearchSysCacheTuple(RELNAME,
|
||||
PointerGetDatum(relname),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(relname),
|
||||
0, 0, 0);
|
||||
if (HeapTupleIsValid(tup))
|
||||
return true;
|
||||
else
|
||||
|
@ -878,7 +877,7 @@ RelationRemoveInheritance(Relation relation)
|
|||
HeapScanDesc scan;
|
||||
ScanKeyData entry;
|
||||
bool found = false;
|
||||
|
||||
|
||||
/* ----------------
|
||||
* open pg_inherits
|
||||
* ----------------
|
||||
|
@ -892,7 +891,7 @@ RelationRemoveInheritance(Relation relation)
|
|||
*/
|
||||
ScanKeyEntryInitialize(&entry, 0x0, Anum_pg_inherits_inhparent,
|
||||
F_OIDEQ,
|
||||
ObjectIdGetDatum(RelationGetRelid(relation)));
|
||||
ObjectIdGetDatum(RelationGetRelid(relation)));
|
||||
|
||||
scan = heap_beginscan(catalogRelation,
|
||||
false,
|
||||
|
@ -972,10 +971,10 @@ RelationRemoveIndexes(Relation relation)
|
|||
ScanKeyData entry;
|
||||
|
||||
indexRelation = heap_openr(IndexRelationName);
|
||||
|
||||
|
||||
ScanKeyEntryInitialize(&entry, 0x0, Anum_pg_index_indrelid,
|
||||
F_OIDEQ,
|
||||
ObjectIdGetDatum(RelationGetRelid(relation)));
|
||||
ObjectIdGetDatum(RelationGetRelid(relation)));
|
||||
|
||||
scan = heap_beginscan(indexRelation,
|
||||
false,
|
||||
|
@ -1008,8 +1007,8 @@ DeletePgRelationTuple(Relation rel)
|
|||
pg_class_desc = heap_openr(RelationRelationName);
|
||||
|
||||
tup = SearchSysCacheTupleCopy(RELOID,
|
||||
ObjectIdGetDatum(rel->rd_att->attrs[0]->attrelid),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(rel->rd_att->attrs[0]->attrelid),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tup))
|
||||
{
|
||||
heap_close(pg_class_desc);
|
||||
|
@ -1023,7 +1022,7 @@ DeletePgRelationTuple(Relation rel)
|
|||
*/
|
||||
heap_delete(pg_class_desc, &tup->t_ctid);
|
||||
pfree(tup);
|
||||
|
||||
|
||||
heap_close(pg_class_desc);
|
||||
}
|
||||
|
||||
|
@ -1038,7 +1037,7 @@ DeletePgAttributeTuples(Relation rel)
|
|||
Relation pg_attribute_desc;
|
||||
HeapTuple tup;
|
||||
int2 attnum;
|
||||
|
||||
|
||||
/* ----------------
|
||||
* open pg_attribute
|
||||
* ----------------
|
||||
|
@ -1052,19 +1051,19 @@ DeletePgAttributeTuples(Relation rel)
|
|||
RelationSetLockForWrite(pg_attribute_desc);
|
||||
|
||||
for (attnum = FirstLowInvalidHeapAttributeNumber + 1;
|
||||
attnum <= rel->rd_att->natts;
|
||||
attnum++)
|
||||
attnum <= rel->rd_att->natts;
|
||||
attnum++)
|
||||
{
|
||||
if (HeapTupleIsValid(tup = SearchSysCacheTupleCopy(ATTNUM,
|
||||
ObjectIdGetDatum(RelationGetRelid(rel)),
|
||||
Int16GetDatum(attnum),
|
||||
0, 0)))
|
||||
ObjectIdGetDatum(RelationGetRelid(rel)),
|
||||
Int16GetDatum(attnum),
|
||||
0, 0)))
|
||||
{
|
||||
heap_delete(pg_attribute_desc, &tup->t_ctid);
|
||||
pfree(tup);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------
|
||||
* Release the write lock
|
||||
* ----------------
|
||||
|
@ -1107,9 +1106,9 @@ DeletePgTypeTuple(Relation rel)
|
|||
* ----------------
|
||||
*/
|
||||
ScanKeyEntryInitialize(&key, 0,
|
||||
Anum_pg_type_typrelid,
|
||||
F_OIDEQ,
|
||||
ObjectIdGetDatum(RelationGetRelid(rel)));
|
||||
Anum_pg_type_typrelid,
|
||||
F_OIDEQ,
|
||||
ObjectIdGetDatum(RelationGetRelid(rel)));
|
||||
|
||||
pg_type_scan = heap_beginscan(pg_type_desc,
|
||||
0,
|
||||
|
@ -1470,7 +1469,7 @@ start:;
|
|||
}
|
||||
}
|
||||
else if ((exprType(expr) != atp->atttypid)
|
||||
&& !IS_BINARY_COMPATIBLE(exprType(expr), atp->atttypid))
|
||||
&& !IS_BINARY_COMPATIBLE(exprType(expr), atp->atttypid))
|
||||
elog(ERROR, "DEFAULT: type mismatched");
|
||||
|
||||
adbin = nodeToString(expr);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.59 1998/09/01 03:21:43 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.60 1998/09/01 04:27:31 momjian Exp $
|
||||
*
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
|
@ -65,32 +65,28 @@
|
|||
|
||||
/* non-export function prototypes */
|
||||
static Oid
|
||||
RelationNameGetObjectId(char *relationName, Relation pg_class);
|
||||
RelationNameGetObjectId(char *relationName, Relation pg_class);
|
||||
static Oid GetHeapRelationOid(char *heapRelationName, char *indexRelationName);
|
||||
static TupleDesc BuildFuncTupleDesc(FuncIndexInfo *funcInfo);
|
||||
static TupleDesc
|
||||
ConstructTupleDescriptor(Oid heapoid, Relation heapRelation,
|
||||
static TupleDesc ConstructTupleDescriptor(Oid heapoid, Relation heapRelation,
|
||||
List *attributeList,
|
||||
int numatts, AttrNumber *attNums);
|
||||
|
||||
static void ConstructIndexReldesc(Relation indexRelation, Oid amoid);
|
||||
static Oid UpdateRelationRelation(Relation indexRelation);
|
||||
static void
|
||||
InitializeAttributeOids(Relation indexRelation,
|
||||
static void InitializeAttributeOids(Relation indexRelation,
|
||||
int numatts,
|
||||
Oid indexoid);
|
||||
static void
|
||||
AppendAttributeTuples(Relation indexRelation, int numatts);
|
||||
static void
|
||||
UpdateIndexRelation(Oid indexoid, Oid heapoid,
|
||||
static void UpdateIndexRelation(Oid indexoid, Oid heapoid,
|
||||
FuncIndexInfo *funcInfo, int natts,
|
||||
AttrNumber *attNums, Oid *classOids, Node *predicate,
|
||||
AttrNumber *attNums, Oid *classOids, Node *predicate,
|
||||
List *attributeList, bool islossy, bool unique);
|
||||
static void
|
||||
DefaultBuild(Relation heapRelation, Relation indexRelation,
|
||||
static void DefaultBuild(Relation heapRelation, Relation indexRelation,
|
||||
int numberOfAttributes, AttrNumber *attributeNumber,
|
||||
IndexStrategy indexStrategy, uint16 parameterCount,
|
||||
Datum *parameter, FuncIndexInfoPtr funcInfo, PredInfo *predInfo);
|
||||
Datum *parameter, FuncIndexInfoPtr funcInfo, PredInfo *predInfo);
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* sysatts is a structure containing attribute tuple forms
|
||||
|
@ -147,12 +143,12 @@ RelationNameGetObjectId(char *relationName,
|
|||
|
||||
if (!IsBootstrapProcessingMode())
|
||||
{
|
||||
HeapTuple tuple;
|
||||
|
||||
HeapTuple tuple;
|
||||
|
||||
tuple = SearchSysCacheTuple(RELNAME,
|
||||
PointerGetDatum(relationName),
|
||||
0, 0, 0);
|
||||
|
||||
|
||||
if (HeapTupleIsValid(tuple))
|
||||
return tuple->t_oid;
|
||||
else
|
||||
|
@ -614,7 +610,9 @@ static void
|
|||
AppendAttributeTuples(Relation indexRelation, int numatts)
|
||||
{
|
||||
Relation pg_attribute;
|
||||
HeapTuple init_tuple, cur_tuple = NULL, new_tuple;
|
||||
HeapTuple init_tuple,
|
||||
cur_tuple = NULL,
|
||||
new_tuple;
|
||||
bool hasind;
|
||||
Relation idescs[Num_pg_attr_indices];
|
||||
|
||||
|
@ -651,8 +649,8 @@ AppendAttributeTuples(Relation indexRelation, int numatts)
|
|||
value[Anum_pg_attribute_attcacheoff - 1] = Int32GetDatum(-1);
|
||||
|
||||
init_tuple = heap_addheader(Natts_pg_attribute,
|
||||
sizeof *(indexRelation->rd_att->attrs[0]),
|
||||
(char *) (indexRelation->rd_att->attrs[0]));
|
||||
sizeof *(indexRelation->rd_att->attrs[0]),
|
||||
(char *) (indexRelation->rd_att->attrs[0]));
|
||||
|
||||
hasind = false;
|
||||
if (!IsBootstrapProcessingMode() && pg_attribute->rd_rel->relhasindex)
|
||||
|
@ -666,12 +664,12 @@ AppendAttributeTuples(Relation indexRelation, int numatts)
|
|||
* ----------------
|
||||
*/
|
||||
cur_tuple = heap_modifytuple(init_tuple,
|
||||
pg_attribute,
|
||||
value,
|
||||
nullv,
|
||||
replace);
|
||||
pg_attribute,
|
||||
value,
|
||||
nullv,
|
||||
replace);
|
||||
pfree(init_tuple);
|
||||
|
||||
|
||||
heap_insert(pg_attribute, cur_tuple);
|
||||
if (hasind)
|
||||
CatalogIndexInsert(idescs, Num_pg_attr_indices, pg_attribute, cur_tuple);
|
||||
|
@ -696,13 +694,13 @@ AppendAttributeTuples(Relation indexRelation, int numatts)
|
|||
value[Anum_pg_attribute_attnum - 1] = Int16GetDatum(i + 1);
|
||||
|
||||
new_tuple = heap_modifytuple(cur_tuple,
|
||||
pg_attribute,
|
||||
value,
|
||||
nullv,
|
||||
replace);
|
||||
pg_attribute,
|
||||
value,
|
||||
nullv,
|
||||
replace);
|
||||
pfree(cur_tuple);
|
||||
|
||||
heap_insert(pg_attribute,new_tuple);
|
||||
heap_insert(pg_attribute, new_tuple);
|
||||
if (hasind)
|
||||
CatalogIndexInsert(idescs, Num_pg_attr_indices, pg_attribute, new_tuple);
|
||||
|
||||
|
@ -711,7 +709,7 @@ AppendAttributeTuples(Relation indexRelation, int numatts)
|
|||
* so we free the original and use the copy..
|
||||
* ----------------
|
||||
*/
|
||||
cur_tuple = new_tuple;
|
||||
cur_tuple = new_tuple;
|
||||
}
|
||||
|
||||
if (cur_tuple)
|
||||
|
@ -898,10 +896,10 @@ UpdateIndexPredicate(Oid indexoid, Node *oldPred, Node *predicate)
|
|||
pg_index = heap_openr(IndexRelationName);
|
||||
|
||||
tuple = SearchSysCacheTuple(INDEXRELID,
|
||||
ObjectIdGetDatum(indexoid),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(indexoid),
|
||||
0, 0, 0);
|
||||
Assert(HeapTupleIsValid(tuple));
|
||||
|
||||
|
||||
for (i = 0; i < Natts_pg_index; i++)
|
||||
{
|
||||
nulls[i] = heap_attisnull(tuple, i + 1) ? 'n' : ' ';
|
||||
|
@ -1103,7 +1101,7 @@ index_create(char *heapRelationName,
|
|||
if (!HeapTupleIsValid(proc_tup))
|
||||
{
|
||||
func_error("index_create", FIgetname(funcInfo),
|
||||
FIgetnArgs(funcInfo), FIgetArglist(funcInfo), NULL);
|
||||
FIgetnArgs(funcInfo), FIgetArglist(funcInfo), NULL);
|
||||
}
|
||||
FIgetProcOid(funcInfo) = proc_tup->t_oid;
|
||||
}
|
||||
|
@ -1178,7 +1176,7 @@ index_destroy(Oid indexId)
|
|||
Relation attributeRelation;
|
||||
HeapTuple tuple;
|
||||
int16 attnum;
|
||||
|
||||
|
||||
Assert(OidIsValid(indexId));
|
||||
|
||||
/* why open it here? bjm 1998/08/20 */
|
||||
|
@ -1206,12 +1204,12 @@ index_destroy(Oid indexId)
|
|||
*/
|
||||
attributeRelation = heap_openr(AttributeRelationName);
|
||||
|
||||
attnum = 1; /* indexes start at 1 */
|
||||
attnum = 1; /* indexes start at 1 */
|
||||
|
||||
while (HeapTupleIsValid(tuple = SearchSysCacheTupleCopy(ATTNUM,
|
||||
ObjectIdGetDatum(indexId),
|
||||
Int16GetDatum(attnum),
|
||||
0, 0)))
|
||||
ObjectIdGetDatum(indexId),
|
||||
Int16GetDatum(attnum),
|
||||
0, 0)))
|
||||
{
|
||||
heap_delete(attributeRelation, &tuple->t_ctid);
|
||||
pfree(tuple);
|
||||
|
@ -1224,15 +1222,15 @@ index_destroy(Oid indexId)
|
|||
* ----------------
|
||||
*/
|
||||
tuple = SearchSysCacheTupleCopy(INDEXRELID,
|
||||
ObjectIdGetDatum(indexId),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(indexId),
|
||||
0, 0, 0);
|
||||
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(NOTICE, "IndexRelationDestroy: %s's INDEX tuple missing",
|
||||
RelationGetRelationName(userindexRelation));
|
||||
|
||||
indexRelation = heap_openr(IndexRelationName);
|
||||
|
||||
|
||||
heap_delete(indexRelation, &tuple->t_ctid);
|
||||
pfree(tuple);
|
||||
heap_close(indexRelation);
|
||||
|
@ -1281,12 +1279,12 @@ FormIndexDatum(int numberOfAttributes,
|
|||
{
|
||||
offset = AttrNumberGetAttrOffset(i);
|
||||
|
||||
datum[offset] = PointerGetDatum(GetIndexValue(heapTuple,
|
||||
heapDescriptor,
|
||||
offset,
|
||||
attributeNumber,
|
||||
fInfo,
|
||||
&isNull));
|
||||
datum[offset] = PointerGetDatum(GetIndexValue(heapTuple,
|
||||
heapDescriptor,
|
||||
offset,
|
||||
attributeNumber,
|
||||
fInfo,
|
||||
&isNull));
|
||||
|
||||
nullv[offset] = (isNull) ? 'n' : ' ';
|
||||
}
|
||||
|
@ -1311,7 +1309,7 @@ UpdateStats(Oid relid, long reltuples, bool hasindex)
|
|||
Datum values[Natts_pg_class];
|
||||
char nulls[Natts_pg_class];
|
||||
char replace[Natts_pg_class];
|
||||
HeapScanDesc pg_class_scan = NULL;
|
||||
HeapScanDesc pg_class_scan = NULL;
|
||||
|
||||
/* ----------------
|
||||
* This routine handles updates for both the heap and index relation
|
||||
|
@ -1356,14 +1354,14 @@ UpdateStats(Oid relid, long reltuples, bool hasindex)
|
|||
ScanKeyData key[1];
|
||||
|
||||
ScanKeyEntryInitialize(&key[0], 0,
|
||||
ObjectIdAttributeNumber,
|
||||
F_OIDEQ,
|
||||
ObjectIdGetDatum(relid));
|
||||
ObjectIdAttributeNumber,
|
||||
F_OIDEQ,
|
||||
ObjectIdGetDatum(relid));
|
||||
|
||||
pg_class_scan = heap_beginscan(pg_class, 0, SnapshotNow, 1, key);
|
||||
tuple = heap_getnext(pg_class_scan, 0);
|
||||
}
|
||||
|
||||
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
{
|
||||
if (IsBootstrapProcessingMode())
|
||||
|
@ -1436,7 +1434,7 @@ UpdateStats(Oid relid, long reltuples, bool hasindex)
|
|||
pfree(tuple);
|
||||
else
|
||||
heap_endscan(pg_class_scan);
|
||||
|
||||
|
||||
heap_close(pg_class);
|
||||
heap_close(whichRel);
|
||||
}
|
||||
|
@ -1478,7 +1476,7 @@ DefaultBuild(Relation heapRelation,
|
|||
AttrNumber *attributeNumber,
|
||||
IndexStrategy indexStrategy, /* not used */
|
||||
uint16 parameterCount, /* not used */
|
||||
Datum *parameter, /* not used */
|
||||
Datum *parameter, /* not used */
|
||||
FuncIndexInfoPtr funcInfo,
|
||||
PredInfo *predInfo)
|
||||
{
|
||||
|
@ -1543,7 +1541,7 @@ DefaultBuild(Relation heapRelation,
|
|||
tupleTable = ExecCreateTupleTable(1);
|
||||
slot = ExecAllocTableSlot(tupleTable);
|
||||
econtext = makeNode(ExprContext);
|
||||
/* last parameter was junk being sent bjm 1998/08/17 */
|
||||
/* last parameter was junk being sent bjm 1998/08/17 */
|
||||
FillDummyExprContext(econtext, slot, heapDescriptor, InvalidBuffer);
|
||||
}
|
||||
else
|
||||
|
@ -1552,7 +1550,7 @@ DefaultBuild(Relation heapRelation,
|
|||
tupleTable = 0;
|
||||
slot = NULL;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
|
||||
/* ----------------
|
||||
* Ok, begin our scan of the base relation.
|
||||
|
@ -1560,7 +1558,7 @@ DefaultBuild(Relation heapRelation,
|
|||
*/
|
||||
scan = heap_beginscan(heapRelation, /* relation */
|
||||
0, /* start at end */
|
||||
SnapshotNow,/* seeself */
|
||||
SnapshotNow, /* seeself */
|
||||
0, /* number of keys */
|
||||
(ScanKey) NULL); /* scan key */
|
||||
|
||||
|
@ -1591,7 +1589,7 @@ DefaultBuild(Relation heapRelation,
|
|||
indtuples++;
|
||||
continue;
|
||||
}
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -1605,7 +1603,7 @@ DefaultBuild(Relation heapRelation,
|
|||
slot->val = heapTuple;
|
||||
if (ExecQual((List *) predicate, econtext) == false)
|
||||
continue;
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
indtuples++;
|
||||
|
@ -1643,7 +1641,7 @@ DefaultBuild(Relation heapRelation,
|
|||
{
|
||||
#ifndef OMIT_PARTIAL_INDEX
|
||||
ExecDestroyTupleTable(tupleTable, false);
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
|
||||
pfree(nullv);
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.25 1998/09/01 03:21:44 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.26 1998/09/01 04:27:33 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -126,8 +126,8 @@ CatalogIndexInsert(Relation *idescs,
|
|||
|
||||
indexDescriptor = RelationGetDescr(idescs[i]);
|
||||
pgIndexTup = SearchSysCacheTupleCopy(INDEXRELID,
|
||||
ObjectIdGetDatum(idescs[i]->rd_id),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(idescs[i]->rd_id),
|
||||
0, 0, 0);
|
||||
Assert(pgIndexTup);
|
||||
pgIndexP = (Form_pg_index) GETSTRUCT(pgIndexTup);
|
||||
|
||||
|
@ -228,7 +228,7 @@ CatalogIndexFetchTuple(Relation heapRelation,
|
|||
RetrieveIndexResult indexRes;
|
||||
HeapTuple tuple = NULL;
|
||||
Buffer buffer;
|
||||
|
||||
|
||||
sd = index_beginscan(idesc, false, num_keys, skey);
|
||||
while ((indexRes = index_getnext(sd, ForwardScanDirection)))
|
||||
{
|
||||
|
@ -239,7 +239,7 @@ CatalogIndexFetchTuple(Relation heapRelation,
|
|||
pfree(indexRes);
|
||||
if (HeapTupleIsValid(tuple))
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (HeapTupleIsValid(tuple))
|
||||
{
|
||||
|
@ -270,13 +270,13 @@ AttributeNameIndexScan(Relation heapRelation,
|
|||
ScanKeyEntryInitialize(&skey[0],
|
||||
(bits16) 0x0,
|
||||
(AttrNumber) 1,
|
||||
(RegProcedure)F_OIDEQ,
|
||||
(RegProcedure) F_OIDEQ,
|
||||
ObjectIdGetDatum(relid));
|
||||
|
||||
ScanKeyEntryInitialize(&skey[1],
|
||||
(bits16) 0x0,
|
||||
(AttrNumber) 2,
|
||||
(RegProcedure)F_NAMEEQ,
|
||||
(RegProcedure) F_NAMEEQ,
|
||||
NameGetDatum(attname));
|
||||
|
||||
idesc = index_openr(AttributeNameIndex);
|
||||
|
@ -299,13 +299,13 @@ AttributeNumIndexScan(Relation heapRelation,
|
|||
ScanKeyEntryInitialize(&skey[0],
|
||||
(bits16) 0x0,
|
||||
(AttrNumber) 1,
|
||||
(RegProcedure)F_OIDEQ,
|
||||
(RegProcedure) F_OIDEQ,
|
||||
ObjectIdGetDatum(relid));
|
||||
|
||||
ScanKeyEntryInitialize(&skey[1],
|
||||
(bits16) 0x0,
|
||||
(AttrNumber) 2,
|
||||
(RegProcedure)F_INT2EQ,
|
||||
(RegProcedure) F_INT2EQ,
|
||||
Int16GetDatum(attnum));
|
||||
|
||||
idesc = index_openr(AttributeNumIndex);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.16 1998/09/01 03:21:45 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.17 1998/09/01 04:27:34 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -78,7 +78,7 @@ AggregateCreate(char *aggName,
|
|||
Oid xret2 = InvalidOid;
|
||||
Oid fret = InvalidOid;
|
||||
Oid fnArgs[8];
|
||||
NameData aname;
|
||||
NameData aname;
|
||||
TupleDesc tupDesc;
|
||||
|
||||
MemSet(fnArgs, 0, 8 * sizeof(Oid));
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.28 1998/09/01 03:21:47 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.29 1998/09/01 04:27:36 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* these routines moved here from commands/define.c and somewhat cleaned up.
|
||||
|
@ -35,28 +35,23 @@
|
|||
#include <string.h>
|
||||
#endif
|
||||
|
||||
static Oid
|
||||
OperatorGetWithOpenRelation(Relation pg_operator_desc,
|
||||
static Oid OperatorGetWithOpenRelation(Relation pg_operator_desc,
|
||||
const char *operatorName,
|
||||
Oid leftObjectId,
|
||||
Oid rightObjectId);
|
||||
static Oid
|
||||
OperatorGet(char *operatorName,
|
||||
static Oid OperatorGet(char *operatorName,
|
||||
char *leftTypeName,
|
||||
char *rightTypeName);
|
||||
|
||||
static Oid
|
||||
OperatorShellMakeWithOpenRelation(Relation pg_operator_desc,
|
||||
static Oid OperatorShellMakeWithOpenRelation(Relation pg_operator_desc,
|
||||
char *operatorName,
|
||||
Oid leftObjectId,
|
||||
Oid rightObjectId);
|
||||
static Oid
|
||||
OperatorShellMake(char *operatorName,
|
||||
static Oid OperatorShellMake(char *operatorName,
|
||||
char *leftTypeName,
|
||||
char *rightTypeName);
|
||||
|
||||
static void
|
||||
OperatorDef(char *operatorName,
|
||||
static void OperatorDef(char *operatorName,
|
||||
int definedOK,
|
||||
char *leftTypeName,
|
||||
char *rightTypeName,
|
||||
|
@ -120,7 +115,7 @@ OperatorGetWithOpenRelation(Relation pg_operator_desc,
|
|||
*/
|
||||
pg_operator_scan = heap_beginscan(pg_operator_desc,
|
||||
0,
|
||||
SnapshotSelf, /* no cache? */
|
||||
SnapshotSelf, /* no cache? */
|
||||
3,
|
||||
opKey);
|
||||
|
||||
|
@ -475,7 +470,7 @@ OperatorDef(char *operatorName,
|
|||
char *name[4];
|
||||
Oid typeId[8];
|
||||
int nargs;
|
||||
NameData oname;
|
||||
NameData oname;
|
||||
TupleDesc tupDesc;
|
||||
|
||||
static ScanKeyData opKey[3] = {
|
||||
|
@ -796,7 +791,7 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
|
|||
|
||||
pg_operator_scan = heap_beginscan(pg_operator_desc,
|
||||
0,
|
||||
SnapshotSelf, /* no cache? */
|
||||
SnapshotSelf, /* no cache? */
|
||||
1,
|
||||
opKey);
|
||||
|
||||
|
@ -872,7 +867,7 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
|
|||
|
||||
pg_operator_scan = heap_beginscan(pg_operator_desc,
|
||||
0,
|
||||
SnapshotSelf, /* no cache? */
|
||||
SnapshotSelf, /* no cache? */
|
||||
1,
|
||||
opKey);
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.22 1998/09/01 03:21:48 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.23 1998/09/01 04:27:37 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -129,6 +129,7 @@ ProcedureCreate(char *procedureName,
|
|||
|
||||
if (!strcmp(languageName, "sql"))
|
||||
{
|
||||
|
||||
/*
|
||||
* If this call is defining a set, check if the set is already
|
||||
* defined by looking to see whether this call's function text
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.29 1998/09/01 03:21:49 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.30 1998/09/01 04:27:39 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -33,8 +33,7 @@
|
|||
#include <string.h>
|
||||
#endif
|
||||
|
||||
static Oid
|
||||
TypeShellMakeWithOpenRelation(Relation pg_type_desc,
|
||||
static Oid TypeShellMakeWithOpenRelation(Relation pg_type_desc,
|
||||
char *typeName);
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
|
@ -178,7 +177,7 @@ TypeShellMakeWithOpenRelation(Relation pg_type_desc, char *typeName)
|
|||
*/
|
||||
i = 0;
|
||||
namestrcpy(&name, typeName);
|
||||
values[i++] = NameGetDatum(&name); /* 1 */
|
||||
values[i++] = NameGetDatum(&name); /* 1 */
|
||||
values[i++] = (Datum) InvalidOid; /* 2 */
|
||||
values[i++] = (Datum) (int16) 0; /* 3 */
|
||||
values[i++] = (Datum) (int16) 0; /* 4 */
|
||||
|
@ -379,17 +378,17 @@ TypeCreate(char *typeName,
|
|||
* ----------------
|
||||
*/
|
||||
i = 0;
|
||||
namestrcpy(&name,typeName);
|
||||
namestrcpy(&name, typeName);
|
||||
values[i++] = NameGetDatum(&name); /* 1 */
|
||||
values[i++] = (Datum) GetUserId(); /* 2 */
|
||||
values[i++] = (Datum) internalSize; /* 3 */
|
||||
values[i++] = (Datum) externalSize; /* 4 */
|
||||
values[i++] = (Datum) passedByValue;/* 5 */
|
||||
values[i++] = (Datum) passedByValue; /* 5 */
|
||||
values[i++] = (Datum) typeType; /* 6 */
|
||||
values[i++] = (Datum) (bool) 1; /* 7 */
|
||||
values[i++] = (Datum) typDelim; /* 8 */
|
||||
values[i++] = (Datum) (typeType == 'c' ? relationOid : InvalidOid); /* 9 */
|
||||
values[i++] = (Datum) elementObjectId;/* 10 */
|
||||
values[i++] = (Datum) elementObjectId; /* 10 */
|
||||
|
||||
/*
|
||||
* arguments to type input and output functions must be 0
|
||||
|
@ -431,7 +430,7 @@ TypeCreate(char *typeName,
|
|||
func_error("TypeCreate", procname, 1, argList, NULL);
|
||||
}
|
||||
|
||||
values[i++] = (Datum) tup->t_oid; /* 11 - 14 */
|
||||
values[i++] = (Datum) tup->t_oid; /* 11 - 14 */
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
|
@ -444,7 +443,7 @@ TypeCreate(char *typeName,
|
|||
* initialize the default value for this type.
|
||||
* ----------------
|
||||
*/
|
||||
values[i] = (Datum) fmgr(F_TEXTIN, /* 16 */
|
||||
values[i] = (Datum) fmgr(F_TEXTIN, /* 16 */
|
||||
PointerIsValid(defaultTypeValue)
|
||||
? defaultTypeValue : "-"); /* XXX default
|
||||
* typdefault */
|
||||
|
@ -534,8 +533,9 @@ TypeRename(char *oldTypeName, char *newTypeName)
|
|||
{
|
||||
Relation pg_type_desc;
|
||||
Relation idescs[Num_pg_type_indices];
|
||||
HeapTuple oldtup, newtup;
|
||||
|
||||
HeapTuple oldtup,
|
||||
newtup;
|
||||
|
||||
pg_type_desc = heap_openr(TypeRelationName);
|
||||
|
||||
oldtup = SearchSysCacheTupleCopy(TYPNAME,
|
||||
|
@ -547,7 +547,7 @@ TypeRename(char *oldTypeName, char *newTypeName)
|
|||
heap_close(pg_type_desc);
|
||||
elog(ERROR, "TypeRename: type %s not defined", oldTypeName);
|
||||
}
|
||||
|
||||
|
||||
newtup = SearchSysCacheTuple(TYPNAME,
|
||||
PointerGetDatum(newTypeName),
|
||||
0, 0, 0);
|
||||
|
@ -557,7 +557,7 @@ TypeRename(char *oldTypeName, char *newTypeName)
|
|||
heap_close(pg_type_desc);
|
||||
elog(ERROR, "TypeRename: type %s already defined", newTypeName);
|
||||
}
|
||||
|
||||
|
||||
namestrcpy(&(((Form_pg_type) GETSTRUCT(oldtup))->typname), newTypeName);
|
||||
|
||||
setheapoverride(true);
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/version.c,v 1.14 1998/08/19 02:01:58 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/version.c,v 1.15 1998/09/01 04:28:09 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* At the point the version is defined, 2 physical relations are created
|
||||
|
@ -303,7 +303,7 @@ VersionDelete(char *vname, char *bname, char *snapshot)
|
|||
vname, vname, vname, bname, bname, snapshot, bname);
|
||||
|
||||
eval_as_new_xact(rule_buf);
|
||||
#endif /* OLD_REWRITE */
|
||||
#endif /* OLD_REWRITE */
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -355,7 +355,7 @@ VersionReplace(char *vname, char *bname, char *snapshot)
|
|||
vname, vname, vname, attr_list, bname, bname, snapshot, vname, bname);
|
||||
|
||||
eval_as_new_xact(rule_buf);
|
||||
#endif /* OLD_REWRITE */
|
||||
#endif /* OLD_REWRITE */
|
||||
/* printf("%s\n",rule_buf); */
|
||||
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.39 1998/09/01 03:21:50 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.40 1998/09/01 04:27:42 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -64,10 +64,10 @@
|
|||
#include <utils/ps_status.h>
|
||||
|
||||
#define NotifyUnlock pg_options[OPT_NOTIFYUNLOCK]
|
||||
#define NotifyHack pg_options[OPT_NOTIFYHACK]
|
||||
#define NotifyHack pg_options[OPT_NOTIFYHACK]
|
||||
|
||||
extern TransactionState CurrentTransactionState;
|
||||
extern CommandDest whereToSendOutput;
|
||||
extern CommandDest whereToSendOutput;
|
||||
|
||||
GlobalMemory notifyContext = NULL;
|
||||
|
||||
|
@ -119,7 +119,7 @@ Async_NotifyHandler(SIGNAL_ARGS)
|
|||
else
|
||||
{
|
||||
TPRINTF(TRACE_NOTIFY, "Async_NotifyHandler: "
|
||||
"process in middle of transaction, state=%d, blockstate=%d",
|
||||
"process in middle of transaction, state=%d, blockstate=%d",
|
||||
CurrentTransactionState->state,
|
||||
CurrentTransactionState->blockState);
|
||||
notifyFrontEndPending = 1;
|
||||
|
@ -213,13 +213,12 @@ Async_Notify(char *relname)
|
|||
heap_endscan(sRel);
|
||||
|
||||
/*
|
||||
* Note: if the write lock is unset we can get multiple tuples
|
||||
* with same oid if other backends notify the same relation.
|
||||
* Use this option at your own risk.
|
||||
* Note: if the write lock is unset we can get multiple tuples with
|
||||
* same oid if other backends notify the same relation. Use this
|
||||
* option at your own risk.
|
||||
*/
|
||||
if (NotifyUnlock) {
|
||||
if (NotifyUnlock)
|
||||
RelationUnsetLockForWrite(lRel);
|
||||
}
|
||||
|
||||
heap_close(lRel);
|
||||
|
||||
|
@ -318,12 +317,13 @@ Async_NotifyAtCommit()
|
|||
heap_close(lRel);
|
||||
|
||||
/*
|
||||
* Notify the frontend inside the current transaction while
|
||||
* we still have a valid write lock on pg_listeners. This
|
||||
* avoid waiting until all other backends have finished
|
||||
* with pg_listener.
|
||||
* Notify the frontend inside the current transaction while we
|
||||
* still have a valid write lock on pg_listeners. This avoid
|
||||
* waiting until all other backends have finished with
|
||||
* pg_listener.
|
||||
*/
|
||||
if (notifyFrontEndPending) {
|
||||
if (notifyFrontEndPending)
|
||||
{
|
||||
/* The aux version is called inside transaction */
|
||||
Async_NotifyFrontEnd_Aux();
|
||||
}
|
||||
|
@ -333,14 +333,14 @@ Async_NotifyAtCommit()
|
|||
}
|
||||
else
|
||||
{
|
||||
|
||||
/*
|
||||
* No notifies issued by us. If notifyFrontEndPending has been set
|
||||
* by Async_NotifyHandler notify the frontend of pending notifies
|
||||
* from other backends.
|
||||
* No notifies issued by us. If notifyFrontEndPending has been
|
||||
* set by Async_NotifyHandler notify the frontend of pending
|
||||
* notifies from other backends.
|
||||
*/
|
||||
if (notifyFrontEndPending) {
|
||||
if (notifyFrontEndPending)
|
||||
Async_NotifyFrontEnd();
|
||||
}
|
||||
}
|
||||
|
||||
ClearPendingNotify();
|
||||
|
@ -368,7 +368,8 @@ Async_NotifyAtCommit()
|
|||
void
|
||||
Async_NotifyAtAbort()
|
||||
{
|
||||
if (pendingNotifies) {
|
||||
if (pendingNotifies)
|
||||
{
|
||||
ClearPendingNotify();
|
||||
DLFreeList(pendingNotifies);
|
||||
}
|
||||
|
@ -380,9 +381,7 @@ Async_NotifyAtAbort()
|
|||
{
|
||||
/* don't forget to notify front end */
|
||||
if (notifyFrontEndPending)
|
||||
{
|
||||
Async_NotifyFrontEnd();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -423,7 +422,8 @@ Async_Listen(char *relname, int pid)
|
|||
char *relnamei;
|
||||
TupleDesc tupDesc;
|
||||
|
||||
if (whereToSendOutput != Remote) {
|
||||
if (whereToSendOutput != Remote)
|
||||
{
|
||||
elog(NOTICE, "Async_Listen: "
|
||||
"listen not available on interactive sessions");
|
||||
return;
|
||||
|
@ -459,7 +459,8 @@ Async_Listen(char *relname, int pid)
|
|||
if (pid == MyProcPid)
|
||||
alreadyListener = 1;
|
||||
}
|
||||
if (alreadyListener) {
|
||||
if (alreadyListener)
|
||||
{
|
||||
/* No need to scan the rest of the table */
|
||||
break;
|
||||
}
|
||||
|
@ -521,7 +522,8 @@ Async_Unlisten(char *relname, int pid)
|
|||
HeapTuple lTuple;
|
||||
|
||||
/* Handle specially the `unlisten "*"' command */
|
||||
if ((!relname) || (*relname == '\0') || (strcmp(relname,"*")==0)) {
|
||||
if ((!relname) || (*relname == '\0') || (strcmp(relname, "*") == 0))
|
||||
{
|
||||
Async_UnlistenAll();
|
||||
return;
|
||||
}
|
||||
|
@ -575,15 +577,13 @@ Async_UnlistenAll()
|
|||
sRel = heap_beginscan(lRel, 0, SnapshotNow, 1, key);
|
||||
|
||||
while (HeapTupleIsValid(lTuple = heap_getnext(sRel, 0)))
|
||||
{
|
||||
heap_delete(lRel, &lTuple->t_ctid);
|
||||
}
|
||||
heap_endscan(sRel);
|
||||
RelationUnsetLockForWrite(lRel);
|
||||
heap_close(lRel);
|
||||
TPRINTF(TRACE_NOTIFY, "Async_UnlistenAll: done");
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* --------------------------------------------------------------
|
||||
* Async_UnlistenOnExit --
|
||||
|
@ -654,7 +654,7 @@ Async_NotifyFrontEnd_Aux()
|
|||
|
||||
#define MAX_DONE 64
|
||||
|
||||
char *done[MAX_DONE];
|
||||
char *done[MAX_DONE];
|
||||
int ndone = 0;
|
||||
int i;
|
||||
|
||||
|
@ -687,13 +687,16 @@ Async_NotifyFrontEnd_Aux()
|
|||
&isnull);
|
||||
|
||||
/*
|
||||
* This hack deletes duplicate tuples which can be left
|
||||
* in the table if the NotifyUnlock option is set.
|
||||
* I'm further investigating this. -- dz
|
||||
* This hack deletes duplicate tuples which can be left in the
|
||||
* table if the NotifyUnlock option is set. I'm further
|
||||
* investigating this. -- dz
|
||||
*/
|
||||
if (NotifyHack) {
|
||||
for (i=0; i<ndone; i++) {
|
||||
if (strcmp(DatumGetName(d)->data, done[i]) == 0) {
|
||||
if (NotifyHack)
|
||||
{
|
||||
for (i = 0; i < ndone; i++)
|
||||
{
|
||||
if (strcmp(DatumGetName(d)->data, done[i]) == 0)
|
||||
{
|
||||
TPRINTF(TRACE_NOTIFY,
|
||||
"Async_NotifyFrontEnd: duplicate %s",
|
||||
DatumGetName(d)->data);
|
||||
|
@ -701,9 +704,8 @@ Async_NotifyFrontEnd_Aux()
|
|||
continue;
|
||||
}
|
||||
}
|
||||
if (ndone < MAX_DONE) {
|
||||
if (ndone < MAX_DONE)
|
||||
done[ndone++] = pstrdup(DatumGetName(d)->data);
|
||||
}
|
||||
}
|
||||
|
||||
rTuple = heap_modifytuple(lTuple, lRel, value, nulls, repl);
|
||||
|
|
|
@ -14,7 +14,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.30 1998/09/01 03:21:52 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.31 1998/09/01 04:27:44 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -47,7 +47,7 @@
|
|||
#include <optimizer/internal.h>
|
||||
#ifndef NO_SECURITY
|
||||
#include <utils/acl.h>
|
||||
#endif /* !NO_SECURITY */
|
||||
#endif /* !NO_SECURITY */
|
||||
|
||||
static Relation copy_heap(Oid OIDOldHeap);
|
||||
static void copy_index(Oid OIDOldIndex, Oid OIDNewHeap);
|
||||
|
@ -128,7 +128,8 @@ cluster(char *oldrelname, char *oldindexname)
|
|||
elog(ERROR, "cluster: unknown relation: \"%s\"",
|
||||
oldrelname);
|
||||
}
|
||||
OIDOldHeap = RelationGetRelid(OldHeap);/* Get OID for the index scan */
|
||||
OIDOldHeap = RelationGetRelid(OldHeap); /* Get OID for the index
|
||||
* scan */
|
||||
|
||||
OldIndex = index_openr(oldindexname); /* Open old index relation */
|
||||
if (!RelationIsValid(OldIndex))
|
||||
|
@ -136,7 +137,7 @@ cluster(char *oldrelname, char *oldindexname)
|
|||
elog(ERROR, "cluster: unknown index: \"%s\"",
|
||||
oldindexname);
|
||||
}
|
||||
OIDOldIndex = RelationGetRelid(OldIndex); /* OID for the index scan */
|
||||
OIDOldIndex = RelationGetRelid(OldIndex); /* OID for the index scan */
|
||||
|
||||
heap_close(OldHeap);
|
||||
index_close(OldIndex);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.31 1998/09/01 03:21:53 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.32 1998/09/01 04:27:46 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* The PortalExecutorHeapMemory crap needs to be eliminated
|
||||
|
@ -422,16 +422,16 @@ PerformAddAttribute(char *relationName,
|
|||
int attnelems;
|
||||
|
||||
tup = SearchSysCacheTuple(ATTNAME,
|
||||
ObjectIdGetDatum(reltup->t_oid),
|
||||
PointerGetDatum(colDef->colname),
|
||||
0, 0);
|
||||
ObjectIdGetDatum(reltup->t_oid),
|
||||
PointerGetDatum(colDef->colname),
|
||||
0, 0);
|
||||
|
||||
if (HeapTupleIsValid(tup))
|
||||
{
|
||||
heap_close(attrdesc);
|
||||
heap_close(rel);
|
||||
elog(ERROR, "PerformAddAttribute: attribute \"%s\" already exists in class \"%s\"",
|
||||
colDef->colname, relationName);
|
||||
colDef->colname, relationName);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.58 1998/09/01 03:21:55 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.59 1998/09/01 04:27:47 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -52,8 +52,7 @@ static Oid GetOutputFunction(Oid type);
|
|||
static Oid GetTypeElement(Oid type);
|
||||
static Oid GetInputFunction(Oid type);
|
||||
static Oid IsTypeByVal(Oid type);
|
||||
static void
|
||||
GetIndexRelations(Oid main_relation_oid,
|
||||
static void GetIndexRelations(Oid main_relation_oid,
|
||||
int *n_indices,
|
||||
Relation **index_rels);
|
||||
|
||||
|
@ -108,17 +107,17 @@ DoCopy(char *relname, bool binary, bool oids, bool from, bool pipe,
|
|||
the class.
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
static FILE *fp; /* static for cleanup */
|
||||
static bool file_opened = false; /* static for cleanup */
|
||||
static FILE *fp; /* static for cleanup */
|
||||
static bool file_opened = false; /* static for cleanup */
|
||||
Relation rel;
|
||||
extern char *UserName; /* defined in global.c */
|
||||
const AclMode required_access = from ? ACL_WR : ACL_RD;
|
||||
int result;
|
||||
|
||||
/*
|
||||
* Close previous file opened for COPY but failed with elog().
|
||||
* There should be a better way, but would not be modular.
|
||||
* Prevents file descriptor leak. bjm 1998/08/29
|
||||
* Close previous file opened for COPY but failed with elog(). There
|
||||
* should be a better way, but would not be modular. Prevents file
|
||||
* descriptor leak. bjm 1998/08/29
|
||||
*/
|
||||
if (file_opened)
|
||||
FreeFile(fp);
|
||||
|
@ -449,7 +448,7 @@ CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim)
|
|||
itupdescArr[i] = RelationGetDescr(index_rels[i]);
|
||||
pgIndexTup =
|
||||
SearchSysCacheTuple(INDEXRELID,
|
||||
ObjectIdGetDatum(RelationGetRelid(index_rels[i])),
|
||||
ObjectIdGetDatum(RelationGetRelid(index_rels[i])),
|
||||
0, 0, 0);
|
||||
Assert(pgIndexTup);
|
||||
pgIndexP[i] = (Form_pg_index) GETSTRUCT(pgIndexTup);
|
||||
|
@ -500,7 +499,7 @@ CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim)
|
|||
/* SetSlotShouldFree(slot, false); */
|
||||
slot->ttc_buffer = (Buffer) NULL;
|
||||
slot->ttc_shouldFree = false;
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
}
|
||||
else
|
||||
|
@ -766,7 +765,7 @@ CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim)
|
|||
/* SetSlotContents(slot, tuple); */
|
||||
if (ExecQual((List *) indexPred[i], econtext) == false)
|
||||
continue;
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
}
|
||||
FormIndexDatum(indexNatts[i],
|
||||
(AttrNumber *) &(pgIndexP[i]->indkey[0]),
|
||||
|
@ -1022,11 +1021,13 @@ CopyReadAttribute(FILE *fp, bool *isnull, char *delim)
|
|||
char c;
|
||||
int done = 0;
|
||||
int i = 0;
|
||||
|
||||
#ifdef MULTIBYTE
|
||||
int mblen;
|
||||
int encoding;
|
||||
unsigned char s[2];
|
||||
int j;
|
||||
int mblen;
|
||||
int encoding;
|
||||
unsigned char s[2];
|
||||
int j;
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef MULTIBYTE
|
||||
|
@ -1136,22 +1137,23 @@ CopyReadAttribute(FILE *fp, bool *isnull, char *delim)
|
|||
if (!done)
|
||||
attribute[i++] = c;
|
||||
#ifdef MULTIBYTE
|
||||
s[0] = c;
|
||||
mblen = pg_encoding_mblen(encoding, s);
|
||||
mblen--;
|
||||
for(j=0;j<mblen;j++) {
|
||||
c = getc(fp);
|
||||
if (feof(fp))
|
||||
return NULL;
|
||||
attribute[i++] = c;
|
||||
}
|
||||
s[0] = c;
|
||||
mblen = pg_encoding_mblen(encoding, s);
|
||||
mblen--;
|
||||
for (j = 0; j < mblen; j++)
|
||||
{
|
||||
c = getc(fp);
|
||||
if (feof(fp))
|
||||
return NULL;
|
||||
attribute[i++] = c;
|
||||
}
|
||||
#endif
|
||||
if (i == EXT_ATTLEN - 1)
|
||||
elog(ERROR, "CopyReadAttribute - attribute length too long. line: %d", lineno);
|
||||
}
|
||||
attribute[i] = '\0';
|
||||
#ifdef MULTIBYTE
|
||||
return(pg_client_to_server((unsigned char*)attribute, strlen(attribute)));
|
||||
return (pg_client_to_server((unsigned char *) attribute, strlen(attribute)));
|
||||
#else
|
||||
return &attribute[0];
|
||||
#endif
|
||||
|
@ -1160,13 +1162,14 @@ CopyReadAttribute(FILE *fp, bool *isnull, char *delim)
|
|||
static void
|
||||
CopyAttributeOut(FILE *fp, char *server_string, char *delim, int is_array)
|
||||
{
|
||||
char *string;
|
||||
char *string;
|
||||
char c;
|
||||
|
||||
#ifdef MULTIBYTE
|
||||
int mblen;
|
||||
int encoding;
|
||||
int i;
|
||||
int mblen;
|
||||
int encoding;
|
||||
int i;
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef MULTIBYTE
|
||||
|
@ -1178,7 +1181,7 @@ CopyAttributeOut(FILE *fp, char *server_string, char *delim, int is_array)
|
|||
|
||||
#ifdef MULTIBYTE
|
||||
for (; (mblen = pg_encoding_mblen(encoding, string)) &&
|
||||
((c = *string) != '\0'); string += mblen)
|
||||
((c = *string) != '\0'); string += mblen)
|
||||
#else
|
||||
for (; (c = *string) != '\0'; string++)
|
||||
#endif
|
||||
|
@ -1204,9 +1207,8 @@ CopyAttributeOut(FILE *fp, char *server_string, char *delim, int is_array)
|
|||
}
|
||||
}
|
||||
#ifdef MULTIBYTE
|
||||
for (i=0;i<mblen;i++) {
|
||||
fputc(*(string+i), fp);
|
||||
}
|
||||
for (i = 0; i < mblen; i++)
|
||||
fputc(*(string + i), fp);
|
||||
#else
|
||||
fputc(*string, fp);
|
||||
#endif
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.33 1998/09/01 03:21:56 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.34 1998/09/01 04:27:49 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -33,8 +33,7 @@
|
|||
* ----------------
|
||||
*/
|
||||
|
||||
static int
|
||||
checkAttrExists(char *attributeName,
|
||||
static int checkAttrExists(char *attributeName,
|
||||
char *attributeType, List *schema);
|
||||
static List *MergeAttributes(List *schema, List *supers, List **supconstr);
|
||||
static void StoreCatalogInheritance(Oid relationId, List *supers);
|
||||
|
@ -404,7 +403,7 @@ StoreCatalogInheritance(Oid relationId, List *supers)
|
|||
char nullarr[Natts_pg_inherits];
|
||||
|
||||
tuple = SearchSysCacheTuple(RELNAME,
|
||||
PointerGetDatum(strVal(lfirst(entry))),
|
||||
PointerGetDatum(strVal(lfirst(entry))),
|
||||
0, 0, 0);
|
||||
AssertArg(HeapTupleIsValid(tuple));
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.23 1998/09/01 03:21:57 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.24 1998/09/01 04:27:51 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -36,8 +36,7 @@
|
|||
|
||||
|
||||
/* non-export function prototypes */
|
||||
static void
|
||||
check_permissions(char *command, char *dbpath, char *dbname,
|
||||
static void check_permissions(char *command, char *dbpath, char *dbname,
|
||||
Oid *dbIdP, int4 *userIdP);
|
||||
static HeapTuple get_pg_dbtup(char *command, char *dbname, Relation dbrel);
|
||||
static void stop_vacuum(char *dbpath, char *dbname);
|
||||
|
@ -46,7 +45,7 @@ void
|
|||
createdb(char *dbname, char *dbpath, int encoding)
|
||||
{
|
||||
Oid db_id;
|
||||
int4 user_id;
|
||||
int4 user_id;
|
||||
char buf[512];
|
||||
char *lp,
|
||||
loc[512];
|
||||
|
@ -100,7 +99,7 @@ createdb(char *dbname, char *dbpath, int encoding)
|
|||
void
|
||||
destroydb(char *dbname)
|
||||
{
|
||||
int4 user_id;
|
||||
int4 user_id;
|
||||
Oid db_id;
|
||||
char *path;
|
||||
char dbpath[MAXPGPATH + 1];
|
||||
|
@ -203,8 +202,8 @@ check_permissions(char *command,
|
|||
|
||||
userName = GetPgUserName();
|
||||
utup = SearchSysCacheTuple(USENAME,
|
||||
PointerGetDatum(userName),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(userName),
|
||||
0, 0, 0);
|
||||
*userIdP = ((Form_pg_shadow) GETSTRUCT(utup))->usesysid;
|
||||
use_super = ((Form_pg_shadow) GETSTRUCT(utup))->usesuper;
|
||||
use_createdb = ((Form_pg_shadow) GETSTRUCT(utup))->usecreatedb;
|
||||
|
@ -249,9 +248,9 @@ check_permissions(char *command,
|
|||
if (dbfound)
|
||||
{
|
||||
dbowner = (int4) heap_getattr(dbtup,
|
||||
Anum_pg_database_datdba,
|
||||
RelationGetDescr(dbrel),
|
||||
(char *) NULL);
|
||||
Anum_pg_database_datdba,
|
||||
RelationGetDescr(dbrel),
|
||||
(char *) NULL);
|
||||
*dbIdP = dbtup->t_oid;
|
||||
dbtext = (text *) heap_getattr(dbtup,
|
||||
Anum_pg_database_datpath,
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/defind.c,v 1.25 1998/09/01 03:21:58 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/defind.c,v 1.26 1998/09/01 04:27:52 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -41,16 +41,13 @@
|
|||
|
||||
/* non-export function prototypes */
|
||||
static void CheckPredicate(List *predList, List *rangeTable, Oid baseRelOid);
|
||||
static void
|
||||
CheckPredExpr(Node *predicate, List *rangeTable,
|
||||
static void CheckPredExpr(Node *predicate, List *rangeTable,
|
||||
Oid baseRelOid);
|
||||
static void
|
||||
CheckPredClause(Expr *predicate, List *rangeTable, Oid baseRelOid);
|
||||
static void
|
||||
FuncIndexArgs(IndexElem *funcIndex, AttrNumber *attNumP,
|
||||
static void FuncIndexArgs(IndexElem *funcIndex, AttrNumber *attNumP,
|
||||
Oid *argTypes, Oid *opOidP, Oid relId);
|
||||
static void
|
||||
NormIndexAttrs(List *attList, AttrNumber *attNumP,
|
||||
static void NormIndexAttrs(List *attList, AttrNumber *attNumP,
|
||||
Oid *opOidP, Oid relId);
|
||||
static char *GetDefaultOpClass(Oid atttypid);
|
||||
|
||||
|
@ -197,7 +194,7 @@ DefineIndex(char *heapRelationName,
|
|||
else
|
||||
{
|
||||
attributeNumberA = (AttrNumber *) palloc(numberOfAttributes *
|
||||
sizeof attributeNumberA[0]);
|
||||
sizeof attributeNumberA[0]);
|
||||
|
||||
classObjectId =
|
||||
(Oid *) palloc(numberOfAttributes * sizeof classObjectId[0]);
|
||||
|
@ -468,7 +465,8 @@ NormIndexAttrs(List *attList, /* list of IndexElem's */
|
|||
Oid relId)
|
||||
{
|
||||
List *rest;
|
||||
HeapTuple atttuple, tuple;
|
||||
HeapTuple atttuple,
|
||||
tuple;
|
||||
|
||||
/*
|
||||
* process attributeList
|
||||
|
@ -485,9 +483,9 @@ NormIndexAttrs(List *attList, /* list of IndexElem's */
|
|||
elog(ERROR, "missing attribute for define index");
|
||||
|
||||
atttuple = SearchSysCacheTupleCopy(ATTNAME,
|
||||
ObjectIdGetDatum(relId),
|
||||
PointerGetDatum(attribute->name),
|
||||
0, 0);
|
||||
ObjectIdGetDatum(relId),
|
||||
PointerGetDatum(attribute->name),
|
||||
0, 0);
|
||||
if (!HeapTupleIsValid(atttuple))
|
||||
{
|
||||
elog(ERROR,
|
||||
|
@ -502,8 +500,8 @@ NormIndexAttrs(List *attList, /* list of IndexElem's */
|
|||
if (attribute->typename == NULL)
|
||||
{
|
||||
tuple = SearchSysCacheTuple(TYPOID,
|
||||
ObjectIdGetDatum(attform->atttypid),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(attform->atttypid),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "create index: type for attribute '%s' undefined",
|
||||
attribute->name);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.23 1998/08/04 16:43:54 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.24 1998/09/01 04:27:53 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -83,7 +83,7 @@ ExplainQuery(Query *query, bool verbose, CommandDest dest)
|
|||
|
||||
if (es->printNodes)
|
||||
s = nodeToString(plan);
|
||||
|
||||
|
||||
if (es->printCost)
|
||||
{
|
||||
s2 = Explain_PlanToString(plan, es);
|
||||
|
@ -107,7 +107,7 @@ ExplainQuery(Query *query, bool verbose, CommandDest dest)
|
|||
len -= ELOG_MAXLEN - 64;
|
||||
}
|
||||
if (es->printNodes)
|
||||
pprint(plan); /* display in postmaster log file */
|
||||
pprint(plan); /* display in postmaster log file */
|
||||
|
||||
pfree(es);
|
||||
}
|
||||
|
@ -123,7 +123,7 @@ ExplainQuery(Query *query, bool verbose, CommandDest dest)
|
|||
static void
|
||||
explain_outNode(StringInfo str, Plan *plan, int indent, ExplainState *es)
|
||||
{
|
||||
List *l;
|
||||
List *l;
|
||||
Relation relation;
|
||||
char *pname;
|
||||
char buf[1000];
|
||||
|
@ -280,11 +280,11 @@ explain_outNode(StringInfo str, Plan *plan, int indent, ExplainState *es)
|
|||
List *saved_rtable = es->rtable;
|
||||
List *lst;
|
||||
int whichplan = 0;
|
||||
Append *appendplan = (Append *)plan;
|
||||
Append *appendplan = (Append *) plan;
|
||||
|
||||
foreach(lst, appendplan->appendplans)
|
||||
{
|
||||
Plan *subnode = (Plan *)lfirst(lst);
|
||||
Plan *subnode = (Plan *) lfirst(lst);
|
||||
|
||||
if (appendplan->inheritrelid > 0)
|
||||
{
|
||||
|
|
|
@ -162,8 +162,8 @@ DropProceduralLanguage(DropPLangStmt *stmt)
|
|||
case_translate_language_name(stmt->plname, languageName);
|
||||
|
||||
langTup = SearchSysCacheTupleCopy(LANNAME,
|
||||
PointerGetDatum(languageName),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(languageName),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(langTup))
|
||||
elog(ERROR, "Language %s doesn't exist", languageName);
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/recipe.c,v 1.23 1998/09/01 03:22:01 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/recipe.c,v 1.24 1998/09/01 04:27:56 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -64,39 +64,31 @@ typedef struct _teeInfo
|
|||
QueryTreeList *appendQlist(QueryTreeList *q1, QueryTreeList *q2);
|
||||
void OffsetVarAttno(Node *node, int varno, int offset);
|
||||
|
||||
static void
|
||||
appendTeeQuery(TeeInfo * teeInfo,
|
||||
static void appendTeeQuery(TeeInfo * teeInfo,
|
||||
QueryTreeList *q,
|
||||
char *teeNodeName);
|
||||
|
||||
static Plan *
|
||||
replaceTeeScans(Plan *plan,
|
||||
static Plan *replaceTeeScans(Plan *plan,
|
||||
Query *parsetree,
|
||||
TeeInfo * teeInfo);
|
||||
static void
|
||||
replaceSeqScan(Plan *plan,
|
||||
static void replaceSeqScan(Plan *plan,
|
||||
Plan *parent,
|
||||
int rt_ind,
|
||||
Plan *tplan);
|
||||
|
||||
static void
|
||||
tg_rewriteQuery(TgRecipe * r, TgNode * n,
|
||||
static void tg_rewriteQuery(TgRecipe * r, TgNode * n,
|
||||
QueryTreeList *q,
|
||||
QueryTreeList *inputQlist);
|
||||
static Node *
|
||||
tg_replaceNumberedParam(Node *expression,
|
||||
static Node *tg_replaceNumberedParam(Node *expression,
|
||||
int pnum,
|
||||
int rt_ind,
|
||||
char *teeRelName);
|
||||
static Node *
|
||||
tg_rewriteParamsInExpr(Node *expression,
|
||||
static Node *tg_rewriteParamsInExpr(Node *expression,
|
||||
QueryTreeList *inputQlist);
|
||||
static QueryTreeList *
|
||||
tg_parseSubQuery(TgRecipe * r,
|
||||
static QueryTreeList *tg_parseSubQuery(TgRecipe * r,
|
||||
TgNode * n,
|
||||
TeeInfo * teeInfo);
|
||||
static QueryTreeList *
|
||||
tg_parseTeeNode(TgRecipe * r,
|
||||
static QueryTreeList *tg_parseTeeNode(TgRecipe * r,
|
||||
TgNode * n,
|
||||
int i,
|
||||
QueryTreeList *qList,
|
||||
|
@ -193,7 +185,7 @@ beginRecipe(RecipeStmt *stmt)
|
|||
|
||||
#ifdef DEBUG_RECIPE
|
||||
elog(NOTICE, "beginRecipe: eyes[%d] = %s\n", i, e->nodeName);
|
||||
#endif /* DEBUG_RECIPE */
|
||||
#endif /* DEBUG_RECIPE */
|
||||
|
||||
qList = tg_parseSubQuery(r, e->inNodes->val[0], teeInfo);
|
||||
|
||||
|
@ -851,7 +843,7 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
|
|||
|
||||
#ifdef DEBUG_RECIPE
|
||||
elog(NOTICE, "calling parser with %s", elem->src);
|
||||
#endif /* DEBUG_RECIPE */
|
||||
#endif /* DEBUG_RECIPE */
|
||||
|
||||
parameterCount = getParamTypes(elem, typev);
|
||||
|
||||
|
@ -894,7 +886,7 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
|
|||
|
||||
#ifdef DEBUG_RECIPE
|
||||
elog(NOTICE, "calling parser with %s", newquery);
|
||||
#endif /* DEBUG_RECIPE */
|
||||
#endif /* DEBUG_RECIPE */
|
||||
|
||||
qList = parser(newquery, typev, parameterCount);
|
||||
if (qList->len > 1)
|
||||
|
@ -1032,8 +1024,8 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
|
|||
tupdesc = rel->rd_att;
|
||||
|
||||
relid = heap_create_with_catalog(
|
||||
child->nodeElem->outTypes->val[0],
|
||||
tupdesc, RELKIND_RELATION);
|
||||
child->nodeElem->outTypes->val[0],
|
||||
tupdesc, RELKIND_RELATION);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -1056,8 +1048,8 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
|
|||
else
|
||||
{
|
||||
relid = heap_create_with_catalog(
|
||||
child->nodeElem->outTypes->val[0],
|
||||
tupdesc, RELKIND_RELATION);
|
||||
child->nodeElem->outTypes->val[0],
|
||||
tupdesc, RELKIND_RELATION);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1338,4 +1330,4 @@ replaceTeeScans(Plan *plan, Query *parsetree, TeeInfo * teeInfo)
|
|||
|
||||
|
||||
|
||||
#endif /* TIOGA */
|
||||
#endif /* TIOGA */
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.28 1998/09/01 03:22:02 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.29 1998/09/01 04:27:57 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -57,7 +57,7 @@ RemoveOperator(char *operatorName, /* operator name */
|
|||
bool defined;
|
||||
char *userName;
|
||||
char oprtype;
|
||||
|
||||
|
||||
if (typeName1)
|
||||
{
|
||||
typeId1 = TypeGet(typeName1, &defined);
|
||||
|
@ -86,11 +86,11 @@ RemoveOperator(char *operatorName, /* operator name */
|
|||
oprtype = 'r';
|
||||
|
||||
tup = SearchSysCacheTupleCopy(OPRNAME,
|
||||
PointerGetDatum(operatorName),
|
||||
ObjectIdGetDatum(typeId1),
|
||||
ObjectIdGetDatum(typeId2),
|
||||
CharGetDatum(oprtype));
|
||||
|
||||
PointerGetDatum(operatorName),
|
||||
ObjectIdGetDatum(typeId1),
|
||||
ObjectIdGetDatum(typeId2),
|
||||
CharGetDatum(oprtype));
|
||||
|
||||
relation = heap_openr(OperatorRelationName);
|
||||
if (HeapTupleIsValid(tup))
|
||||
{
|
||||
|
@ -150,7 +150,7 @@ SingleOpOperatorRemove(Oid typeOid)
|
|||
int i;
|
||||
|
||||
ScanKeyEntryInitialize(&key[0],
|
||||
0, 0, F_OIDEQ, (Datum) typeOid);
|
||||
0, 0, F_OIDEQ, (Datum) typeOid);
|
||||
rel = heap_openr(OperatorRelationName);
|
||||
for (i = 0; i < 3; ++i)
|
||||
{
|
||||
|
@ -192,7 +192,7 @@ AttributeAndRelationRemove(Oid typeOid)
|
|||
*/
|
||||
|
||||
ScanKeyEntryInitialize(&key[0],
|
||||
0, 3, F_OIDEQ, (Datum) typeOid);
|
||||
0, 3, F_OIDEQ, (Datum) typeOid);
|
||||
|
||||
oidptr = (struct oidlist *) palloc(sizeof(*oidptr));
|
||||
oidptr->next = NULL;
|
||||
|
@ -232,7 +232,7 @@ AttributeAndRelationRemove(Oid typeOid)
|
|||
heap_close(rel);
|
||||
}
|
||||
|
||||
#endif /* NOTYET */
|
||||
#endif /* NOTYET */
|
||||
|
||||
/*
|
||||
* TypeRemove
|
||||
|
@ -257,15 +257,15 @@ RemoveType(char *typeName) /* type name to be removed */
|
|||
|
||||
relation = heap_openr(TypeRelationName);
|
||||
tup = SearchSysCacheTuple(TYPNAME,
|
||||
PointerGetDatum(typeName),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(typeName),
|
||||
0, 0, 0);
|
||||
|
||||
if (!HeapTupleIsValid(tup))
|
||||
{
|
||||
heap_close(relation);
|
||||
elog(ERROR, "RemoveType: type '%s' does not exist", typeName);
|
||||
}
|
||||
|
||||
|
||||
relation = heap_openr(TypeRelationName);
|
||||
typeOid = tup->t_oid;
|
||||
heap_delete(relation, &tup->t_ctid);
|
||||
|
@ -273,8 +273,8 @@ RemoveType(char *typeName) /* type name to be removed */
|
|||
/* Now, Delete the "array of" that type */
|
||||
shadow_type = makeArrayTypeName(typeName);
|
||||
tup = SearchSysCacheTuple(TYPNAME,
|
||||
PointerGetDatum(shadow_type),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(shadow_type),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tup))
|
||||
{
|
||||
heap_close(relation);
|
||||
|
@ -308,7 +308,7 @@ RemoveFunction(char *functionName, /* function name to be removed */
|
|||
char *typename;
|
||||
int i;
|
||||
|
||||
|
||||
|
||||
MemSet(argList, 0, 8 * sizeof(Oid));
|
||||
for (i = 0; i < nargs; i++)
|
||||
{
|
||||
|
@ -340,10 +340,10 @@ RemoveFunction(char *functionName, /* function name to be removed */
|
|||
|
||||
relation = heap_openr(ProcedureRelationName);
|
||||
tup = SearchSysCacheTuple(PRONAME,
|
||||
PointerGetDatum(functionName),
|
||||
Int32GetDatum(nargs),
|
||||
PointerGetDatum(argList),
|
||||
0);
|
||||
PointerGetDatum(functionName),
|
||||
Int32GetDatum(nargs),
|
||||
PointerGetDatum(argList),
|
||||
0);
|
||||
|
||||
if (!HeapTupleIsValid(tup))
|
||||
{
|
||||
|
@ -353,8 +353,8 @@ RemoveFunction(char *functionName, /* function name to be removed */
|
|||
|
||||
if ((((Form_pg_proc) GETSTRUCT(tup))->prolang) == INTERNALlanguageId)
|
||||
{
|
||||
heap_close(relation);
|
||||
elog(ERROR, "RemoveFunction: function \"%s\" is built-in",functionName);
|
||||
heap_close(relation);
|
||||
elog(ERROR, "RemoveFunction: function \"%s\" is built-in", functionName);
|
||||
}
|
||||
|
||||
heap_delete(relation, &tup->t_ctid);
|
||||
|
@ -410,9 +410,9 @@ RemoveAggregate(char *aggName, char *aggType)
|
|||
|
||||
relation = heap_openr(AggregateRelationName);
|
||||
tup = SearchSysCacheTuple(AGGNAME,
|
||||
PointerGetDatum(aggName),
|
||||
ObjectIdGetDatum(basetypeID),
|
||||
0, 0);
|
||||
PointerGetDatum(aggName),
|
||||
ObjectIdGetDatum(basetypeID),
|
||||
0, 0);
|
||||
|
||||
if (!HeapTupleIsValid(tup))
|
||||
{
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.16 1998/09/01 03:22:04 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.17 1998/09/01 04:27:59 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -36,7 +36,7 @@
|
|||
#include <optimizer/prep.h> /* for find_all_inheritors */
|
||||
#ifndef NO_SECURITY
|
||||
#include <utils/acl.h>
|
||||
#endif /* !NO_SECURITY */
|
||||
#endif /* !NO_SECURITY */
|
||||
#ifndef HAVE_MEMMOVE
|
||||
#include <regex/utils.h>
|
||||
#else
|
||||
|
@ -73,7 +73,7 @@ renameatt(char *relname,
|
|||
newatttup;
|
||||
Relation irelations[Num_pg_attr_indices];
|
||||
Oid relid;
|
||||
|
||||
|
||||
/*
|
||||
* permissions checking. this would normally be done in utility.c,
|
||||
* but this particular routine is recursive.
|
||||
|
@ -111,12 +111,10 @@ renameatt(char *relname,
|
|||
0, 0, 0);
|
||||
|
||||
if (!HeapTupleIsValid(reltup))
|
||||
{
|
||||
elog(ERROR, "renameatt: unknown relation: \"%s\"", relname);
|
||||
}
|
||||
|
||||
myrelid = reltup->t_oid;
|
||||
|
||||
|
||||
/* this routine is actually in the planner */
|
||||
children = find_all_inheritors(lconsi(myrelid, NIL), NIL);
|
||||
|
||||
|
@ -127,7 +125,7 @@ renameatt(char *relname,
|
|||
*/
|
||||
foreach(child, children)
|
||||
{
|
||||
char childname[NAMEDATALEN];
|
||||
char childname[NAMEDATALEN];
|
||||
|
||||
childrelid = lfirsti(child);
|
||||
if (childrelid == myrelid)
|
||||
|
@ -142,10 +140,10 @@ renameatt(char *relname,
|
|||
}
|
||||
/* make copy of cache value, could disappear in call */
|
||||
StrNCpy(childname,
|
||||
((Form_pg_class) GETSTRUCT(reltup))->relname.data,
|
||||
NAMEDATALEN);
|
||||
((Form_pg_class) GETSTRUCT(reltup))->relname.data,
|
||||
NAMEDATALEN);
|
||||
/* no more recursion! */
|
||||
renameatt(childname, oldattname, newattname, userName, 0);
|
||||
renameatt(childname, oldattname, newattname, userName, 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -158,9 +156,9 @@ renameatt(char *relname,
|
|||
relid = reltup->t_oid;
|
||||
|
||||
oldatttup = SearchSysCacheTupleCopy(ATTNAME,
|
||||
ObjectIdGetDatum(relid),
|
||||
PointerGetDatum(oldattname),
|
||||
0, 0);
|
||||
ObjectIdGetDatum(relid),
|
||||
PointerGetDatum(oldattname),
|
||||
0, 0);
|
||||
if (!HeapTupleIsValid(oldatttup))
|
||||
elog(ERROR, "renameatt: attribute \"%s\" nonexistent", oldattname);
|
||||
|
||||
|
@ -168,9 +166,9 @@ renameatt(char *relname,
|
|||
elog(ERROR, "renameatt: system attribute \"%s\" not renamed", oldattname);
|
||||
|
||||
newatttup = SearchSysCacheTuple(ATTNAME,
|
||||
ObjectIdGetDatum(relid),
|
||||
PointerGetDatum(newattname),
|
||||
0, 0);
|
||||
ObjectIdGetDatum(relid),
|
||||
PointerGetDatum(newattname),
|
||||
0, 0);
|
||||
/* should not already exist */
|
||||
if (HeapTupleIsValid(newatttup))
|
||||
{
|
||||
|
@ -179,7 +177,7 @@ renameatt(char *relname,
|
|||
}
|
||||
|
||||
StrNCpy((((Form_pg_attribute) (GETSTRUCT(oldatttup)))->attname.data),
|
||||
newattname, NAMEDATALEN);
|
||||
newattname, NAMEDATALEN);
|
||||
|
||||
attrelation = heap_openr(AttributeRelationName);
|
||||
heap_replace(attrelation, &oldatttup->t_ctid, oldatttup);
|
||||
|
@ -212,13 +210,13 @@ renameatt(char *relname,
|
|||
void
|
||||
renamerel(char *oldrelname, char *newrelname)
|
||||
{
|
||||
Relation relrelation; /* for RELATION relation */
|
||||
Relation relrelation; /* for RELATION relation */
|
||||
HeapTuple oldreltup,
|
||||
newreltup;
|
||||
char oldpath[MAXPGPATH],
|
||||
newpath[MAXPGPATH];
|
||||
Relation irelations[Num_pg_class_indices];
|
||||
|
||||
|
||||
if (IsSystemRelationName(oldrelname))
|
||||
elog(ERROR, "renamerel: system relation \"%s\" not renamed",
|
||||
oldrelname);
|
||||
|
@ -228,14 +226,14 @@ renamerel(char *oldrelname, char *newrelname)
|
|||
newrelname);
|
||||
|
||||
oldreltup = SearchSysCacheTupleCopy(RELNAME,
|
||||
PointerGetDatum(oldrelname),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(oldrelname),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(oldreltup))
|
||||
elog(ERROR, "renamerel: relation \"%s\" does not exist", oldrelname);
|
||||
|
||||
newreltup = SearchSysCacheTuple(RELNAME,
|
||||
PointerGetDatum(newrelname),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(newrelname),
|
||||
0, 0, 0);
|
||||
if (HeapTupleIsValid(newreltup))
|
||||
elog(ERROR, "renamerel: relation \"%s\" exists", newrelname);
|
||||
|
||||
|
@ -246,7 +244,7 @@ renamerel(char *oldrelname, char *newrelname)
|
|||
elog(ERROR, "renamerel: unable to rename file: %s", oldpath);
|
||||
|
||||
StrNCpy((((Form_pg_class) GETSTRUCT(oldreltup))->relname.data),
|
||||
newrelname, NAMEDATALEN);
|
||||
newrelname, NAMEDATALEN);
|
||||
|
||||
/* insert fixed rel tuple */
|
||||
relrelation = heap_openr(RelationRelationName);
|
||||
|
|
|
@ -316,9 +316,9 @@ currval(struct varlena * seqin)
|
|||
int4
|
||||
setval(struct varlena * seqin, int4 next)
|
||||
{
|
||||
char *seqname = textout(seqin);
|
||||
char *seqname = textout(seqin);
|
||||
SeqTable elm;
|
||||
Buffer buf;
|
||||
Buffer buf;
|
||||
Form_pg_sequence seq;
|
||||
ItemPointerData iptr;
|
||||
|
||||
|
@ -329,17 +329,20 @@ setval(struct varlena * seqin, int4 next)
|
|||
#endif
|
||||
|
||||
/* open and WIntentLock sequence */
|
||||
elm = init_sequence ("setval", seqname);
|
||||
seq = read_info ("setval", elm, &buf); /* lock page and read tuple */
|
||||
elm = init_sequence("setval", seqname);
|
||||
seq = read_info("setval", elm, &buf); /* lock page and read
|
||||
* tuple */
|
||||
|
||||
if ( seq->cache_value != 1 ) {
|
||||
elog (ERROR, "%s.setval: can't set value of sequence %s, cache != 1",
|
||||
seqname, seqname);
|
||||
if (seq->cache_value != 1)
|
||||
{
|
||||
elog(ERROR, "%s.setval: can't set value of sequence %s, cache != 1",
|
||||
seqname, seqname);
|
||||
}
|
||||
|
||||
if ((next < seq->min_value) || (next > seq->max_value)) {
|
||||
elog (ERROR, "%s.setval: value %d is of of bounds (%d,%d)",
|
||||
seqname, next, seq->min_value, seq->max_value);
|
||||
if ((next < seq->min_value) || (next > seq->max_value))
|
||||
{
|
||||
elog(ERROR, "%s.setval: value %d is of of bounds (%d,%d)",
|
||||
seqname, next, seq->min_value, seq->max_value);
|
||||
}
|
||||
|
||||
/* save info in local cache */
|
||||
|
@ -350,11 +353,11 @@ setval(struct varlena * seqin, int4 next)
|
|||
seq->last_value = next; /* last fetched number */
|
||||
seq->is_called = 't';
|
||||
|
||||
if ( WriteBuffer (buf) == STATUS_ERROR )
|
||||
elog (ERROR, "%s.settval: WriteBuffer failed", seqname);
|
||||
if (WriteBuffer(buf) == STATUS_ERROR)
|
||||
elog(ERROR, "%s.settval: WriteBuffer failed", seqname);
|
||||
|
||||
ItemPointerSet(&iptr, 0, FirstOffsetNumber);
|
||||
RelationUnsetSingleWLockPage (elm->rel, &iptr);
|
||||
RelationUnsetSingleWLockPage(elm->rel, &iptr);
|
||||
|
||||
return next;
|
||||
}
|
||||
|
|
|
@ -40,8 +40,7 @@ void RelationBuildTriggers(Relation relation);
|
|||
void FreeTriggerDesc(Relation relation);
|
||||
|
||||
static void DescribeTrigger(TriggerDesc *trigdesc, Trigger *trigger);
|
||||
static HeapTuple
|
||||
GetTupleForTrigger(Relation relation, ItemPointer tid,
|
||||
static HeapTuple GetTupleForTrigger(Relation relation, ItemPointer tid,
|
||||
bool before);
|
||||
|
||||
extern GlobalMemory CacheCxt;
|
||||
|
@ -220,8 +219,8 @@ CreateTrigger(CreateTrigStmt *stmt)
|
|||
|
||||
/* update pg_class */
|
||||
tuple = SearchSysCacheTupleCopy(RELNAME,
|
||||
PointerGetDatum(stmt->relname),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(stmt->relname),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "CreateTrigger: relation %s not found in pg_class", stmt->relname);
|
||||
|
||||
|
@ -258,7 +257,7 @@ DropTrigger(DropTrigStmt *stmt)
|
|||
MemoryContext oldcxt;
|
||||
int found = 0;
|
||||
int tgfound = 0;
|
||||
|
||||
|
||||
#ifndef NO_SECURITY
|
||||
if (!pg_ownercheck(GetPgUserName(), stmt->relname, RELNAME))
|
||||
elog(ERROR, "%s: %s", stmt->relname, aclcheck_error_strings[ACLCHECK_NOT_OWNER]);
|
||||
|
@ -298,8 +297,8 @@ DropTrigger(DropTrigStmt *stmt)
|
|||
heap_close(tgrel);
|
||||
|
||||
tuple = SearchSysCacheTupleCopy(RELNAME,
|
||||
PointerGetDatum(stmt->relname),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(stmt->relname),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "DropTrigger: relation %s not found in pg_class", stmt->relname);
|
||||
|
||||
|
|
|
@ -263,7 +263,7 @@ AlterUser(AlterUserStmt *stmt)
|
|||
{
|
||||
RelationUnsetLockForWrite(pg_shadow_rel);
|
||||
heap_close(pg_shadow_rel);
|
||||
UserAbortTransactionBlock(); /* needed? */
|
||||
UserAbortTransactionBlock(); /* needed? */
|
||||
elog(ERROR, "alterUser: user \"%s\" does not exist", stmt->user);
|
||||
return;
|
||||
}
|
||||
|
@ -430,8 +430,8 @@ RemoveUser(char *user)
|
|||
* tables, views, etc owned by the user.
|
||||
*
|
||||
* The second option would be to create a means of deleting tables, view,
|
||||
* etc. owned by the user from other databases. pg_shadow is global and
|
||||
* so this must be done at some point.
|
||||
* etc. owned by the user from other databases. pg_shadow is global
|
||||
* and so this must be done at some point.
|
||||
*
|
||||
* Let us not forget that the user should be removed from the pg_groups
|
||||
* also.
|
||||
|
@ -466,8 +466,8 @@ CheckPgUserAclNotNull()
|
|||
HeapTuple htup;
|
||||
|
||||
htup = SearchSysCacheTuple(RELNAME,
|
||||
PointerGetDatum(ShadowRelationName),
|
||||
0, 0, 0);
|
||||
PointerGetDatum(ShadowRelationName),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(htup))
|
||||
{
|
||||
elog(ERROR, "IsPgUserAclNull: class \"%s\" not found",
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.79 1998/09/01 03:22:08 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.80 1998/09/01 04:28:05 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -288,7 +288,7 @@ vc_getrels(NameData *VacRelP)
|
|||
else
|
||||
{
|
||||
ScanKeyEntryInitialize(&key, 0x0, Anum_pg_class_relkind,
|
||||
F_CHAREQ, CharGetDatum('r'));
|
||||
F_CHAREQ, CharGetDatum('r'));
|
||||
}
|
||||
|
||||
portalmem = PortalGetVariableMemory(vc_portal);
|
||||
|
@ -377,16 +377,16 @@ vc_vacone(Oid relid, bool analyze, List *va_cols)
|
|||
HeapTuple tuple,
|
||||
typetuple;
|
||||
Relation onerel;
|
||||
VPageListData vacuum_pages; /* List of pages to vacuum and/or clean
|
||||
VPageListData vacuum_pages; /* List of pages to vacuum and/or clean
|
||||
* indices */
|
||||
VPageListData fraged_pages; /* List of pages with space enough for
|
||||
VPageListData fraged_pages; /* List of pages with space enough for
|
||||
* re-using */
|
||||
VPageDescr *vpp;
|
||||
Relation *Irel;
|
||||
int32 nindices,
|
||||
i;
|
||||
VRelStats *vacrelstats;
|
||||
|
||||
|
||||
StartTransactionCommand();
|
||||
|
||||
rel = heap_openr(RelationRelationName);
|
||||
|
@ -397,8 +397,8 @@ vc_vacone(Oid relid, bool analyze, List *va_cols)
|
|||
* last time we saw it, we don't need to vacuum it.
|
||||
*/
|
||||
tuple = SearchSysCacheTuple(RELOID,
|
||||
ObjectIdGetDatum(relid),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(relid),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
{
|
||||
heap_close(rel);
|
||||
|
@ -499,8 +499,8 @@ vc_vacone(Oid relid, bool analyze, List *va_cols)
|
|||
stats->f_cmpgt.fn_addr = NULL;
|
||||
|
||||
typetuple = SearchSysCacheTuple(TYPOID,
|
||||
ObjectIdGetDatum(stats->attr->atttypid),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(stats->attr->atttypid),
|
||||
0, 0, 0);
|
||||
if (HeapTupleIsValid(typetuple))
|
||||
stats->outfunc = ((Form_pg_type) GETSTRUCT(typetuple))->typoutput;
|
||||
else
|
||||
|
@ -549,13 +549,14 @@ vc_vacone(Oid relid, bool analyze, List *va_cols)
|
|||
}
|
||||
}
|
||||
|
||||
if (fraged_pages.vpl_num_pages > 0) /* Try to shrink heap */
|
||||
if (fraged_pages.vpl_num_pages > 0) /* Try to shrink heap */
|
||||
vc_rpfheap(vacrelstats, onerel, &vacuum_pages, &fraged_pages, nindices, Irel);
|
||||
else
|
||||
{
|
||||
if (Irel != (Relation *) NULL)
|
||||
vc_clsindices(nindices, Irel);
|
||||
if (vacuum_pages.vpl_num_pages > 0)/* Clean pages from vacuum_pages list */
|
||||
if (vacuum_pages.vpl_num_pages > 0) /* Clean pages from
|
||||
* vacuum_pages list */
|
||||
vc_vacheap(vacrelstats, onerel, &vacuum_pages);
|
||||
}
|
||||
|
||||
|
@ -644,7 +645,7 @@ vc_scanheap(VRelStats *vacrelstats, Relation onerel,
|
|||
vpc->vpd_offsets_used = 0;
|
||||
|
||||
elog(MESSAGE_LEVEL, "--Relation %s--", relname);
|
||||
|
||||
|
||||
for (blkno = 0; blkno < nblocks; blkno++)
|
||||
{
|
||||
buf = ReadBuffer(onerel, blkno);
|
||||
|
@ -875,8 +876,8 @@ vc_scanheap(VRelStats *vacrelstats, Relation onerel,
|
|||
fraged_pages->vpl_empty_end_pages = empty_end_pages;
|
||||
|
||||
/*
|
||||
* Try to make fraged_pages keeping in mind that we can't use free space of
|
||||
* "empty" end-pages and last page if it reapped.
|
||||
* Try to make fraged_pages keeping in mind that we can't use free
|
||||
* space of "empty" end-pages and last page if it reapped.
|
||||
*/
|
||||
if (do_shrinking && vacuum_pages->vpl_num_pages - empty_end_pages > 0)
|
||||
{
|
||||
|
@ -1010,9 +1011,9 @@ vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
|
|||
isempty = PageIsEmpty(page);
|
||||
|
||||
dowrite = false;
|
||||
if (blkno == last_vacuum_block) /* it's reapped page */
|
||||
if (blkno == last_vacuum_block) /* it's reapped page */
|
||||
{
|
||||
if (last_vacuum_page->vpd_offsets_free > 0) /* there are dead tuples */
|
||||
if (last_vacuum_page->vpd_offsets_free > 0) /* there are dead tuples */
|
||||
{ /* on this page - clean */
|
||||
Assert(!isempty);
|
||||
vc_vacpage(page, last_vacuum_page);
|
||||
|
@ -1025,7 +1026,8 @@ vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
|
|||
/* get prev reapped page from vacuum_pages */
|
||||
last_vacuum_page = vacuum_pages->vpl_pagedesc[vacuumed_pages - 1];
|
||||
last_vacuum_block = last_vacuum_page->vpd_blkno;
|
||||
if (blkno == last_fraged_block) /* this page in fraged_pages too */
|
||||
if (blkno == last_fraged_block) /* this page in
|
||||
* fraged_pages too */
|
||||
{
|
||||
--num_fraged_pages;
|
||||
Assert(num_fraged_pages > 0);
|
||||
|
@ -1080,7 +1082,7 @@ vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
|
|||
Assert(num_fraged_pages > cur_item + 1);
|
||||
memmove(fraged_pages->vpl_pagedesc + cur_item,
|
||||
fraged_pages->vpl_pagedesc + cur_item + 1,
|
||||
sizeof(VPageDescr *) * (num_fraged_pages - cur_item - 1));
|
||||
sizeof(VPageDescr *) * (num_fraged_pages - cur_item - 1));
|
||||
num_fraged_pages--;
|
||||
Assert(last_fraged_page == fraged_pages->vpl_pagedesc[num_fraged_pages - 1]);
|
||||
}
|
||||
|
@ -1121,7 +1123,7 @@ vc_rpfheap(VRelStats *vacrelstats, Relation onerel,
|
|||
elog(ERROR, "\
|
||||
failed to add item with len = %u to page %u (free space %u, nusd %u, noff %u)",
|
||||
tuple_len, cur_page->vpd_blkno, cur_page->vpd_free,
|
||||
cur_page->vpd_offsets_used, cur_page->vpd_offsets_free);
|
||||
cur_page->vpd_offsets_used, cur_page->vpd_offsets_free);
|
||||
}
|
||||
newitemid = PageGetItemId(ToPage, newoff);
|
||||
pfree(newtup);
|
||||
|
@ -1145,7 +1147,7 @@ failed to add item with len = %u to page %u (free space %u, nusd %u, noff %u)",
|
|||
for (i = 0, idcur = Idesc; i < nindices; i++, idcur++)
|
||||
{
|
||||
FormIndexDatum(idcur->natts,
|
||||
(AttrNumber *) &(idcur->tform->indkey[0]),
|
||||
(AttrNumber *) &(idcur->tform->indkey[0]),
|
||||
newtup,
|
||||
tupdesc,
|
||||
idatum,
|
||||
|
@ -1201,8 +1203,8 @@ failed to add item with len = %u to page %u (free space %u, nusd %u, noff %u)",
|
|||
}
|
||||
|
||||
/*
|
||||
* Clean uncleaned reapped pages from vacuum_pages list and set xmin committed
|
||||
* for inserted tuples
|
||||
* Clean uncleaned reapped pages from vacuum_pages list and set xmin
|
||||
* committed for inserted tuples
|
||||
*/
|
||||
checked_moved = 0;
|
||||
for (i = 0, vpp = vacuum_pages->vpl_pagedesc; i < vacuumed_pages; i++, vpp++)
|
||||
|
@ -1320,7 +1322,7 @@ Elapsed %u/%u sec.",
|
|||
elog(FATAL, "VACUUM (vc_rpfheap): BlowawayRelationBuffers returned %d", i);
|
||||
blkno = smgrtruncate(DEFAULT_SMGR, onerel, blkno);
|
||||
Assert(blkno >= 0);
|
||||
vacrelstats->num_pages = blkno; /* set new number of blocks */
|
||||
vacrelstats->num_pages = blkno; /* set new number of blocks */
|
||||
}
|
||||
|
||||
if (Irel != (Relation *) NULL) /* pfree index' allocations */
|
||||
|
@ -1351,7 +1353,8 @@ vc_vacheap(VRelStats *vacrelstats, Relation onerel, VPageList vacuum_pages)
|
|||
int i;
|
||||
|
||||
nblocks = vacuum_pages->vpl_num_pages;
|
||||
nblocks -= vacuum_pages->vpl_empty_end_pages;/* nothing to do with them */
|
||||
nblocks -= vacuum_pages->vpl_empty_end_pages; /* nothing to do with
|
||||
* them */
|
||||
|
||||
for (i = 0, vpp = vacuum_pages->vpl_pagedesc; i < nblocks; i++, vpp++)
|
||||
{
|
||||
|
@ -1385,7 +1388,8 @@ vc_vacheap(VRelStats *vacrelstats, Relation onerel, VPageList vacuum_pages)
|
|||
|
||||
nblocks = smgrtruncate(DEFAULT_SMGR, onerel, nblocks);
|
||||
Assert(nblocks >= 0);
|
||||
vacrelstats->num_pages = nblocks; /* set new number of blocks */
|
||||
vacrelstats->num_pages = nblocks; /* set new number of
|
||||
* blocks */
|
||||
}
|
||||
|
||||
} /* vc_vacheap */
|
||||
|
@ -1555,7 +1559,7 @@ vc_tidreapped(ItemPointer itemptr, VPageList vpl)
|
|||
|
||||
vp = &vpd;
|
||||
vpp = (VPageDescr *) vc_find_eq((char *) (vpl->vpl_pagedesc),
|
||||
vpl->vpl_num_pages, sizeof(VPageDescr), (char *) &vp,
|
||||
vpl->vpl_num_pages, sizeof(VPageDescr), (char *) &vp,
|
||||
vc_cmp_blk);
|
||||
|
||||
if (vpp == (VPageDescr *) NULL)
|
||||
|
@ -1570,7 +1574,7 @@ vc_tidreapped(ItemPointer itemptr, VPageList vpl)
|
|||
}
|
||||
|
||||
voff = (OffsetNumber *) vc_find_eq((char *) (vp->vpd_offsets),
|
||||
vp->vpd_offsets_free, sizeof(OffsetNumber), (char *) &ioffno,
|
||||
vp->vpd_offsets_free, sizeof(OffsetNumber), (char *) &ioffno,
|
||||
vc_cmp_offno);
|
||||
|
||||
if (voff == (OffsetNumber *) NULL)
|
||||
|
@ -1746,16 +1750,16 @@ vc_updstats(Oid relid, int num_pages, int num_tuples, bool hasindex, VRelStats *
|
|||
ScanKeyData askey;
|
||||
Form_pg_attribute attp;
|
||||
Buffer buffer;
|
||||
|
||||
|
||||
/*
|
||||
* update number of tuples and number of pages in pg_class
|
||||
*/
|
||||
rtup = SearchSysCacheTuple(RELOID,
|
||||
ObjectIdGetDatum(relid),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(relid),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(rtup))
|
||||
elog(ERROR, "pg_class entry for relid %d vanished during vacuuming",
|
||||
relid);
|
||||
relid);
|
||||
|
||||
rd = heap_openr(RelationRelationName);
|
||||
|
||||
|
@ -2207,16 +2211,20 @@ vc_mkindesc(Relation onerel, int nindices, Relation *Irel, IndDesc **Idesc)
|
|||
AttrNumber *attnumP;
|
||||
int natts;
|
||||
int i;
|
||||
|
||||
|
||||
*Idesc = (IndDesc *) palloc(nindices * sizeof(IndDesc));
|
||||
|
||||
for (i = 0, idcur = *Idesc; i < nindices; i++, idcur++)
|
||||
{
|
||||
cachetuple = SearchSysCacheTupleCopy(INDEXRELID,
|
||||
ObjectIdGetDatum(RelationGetRelid(Irel[i])),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(RelationGetRelid(Irel[i])),
|
||||
0, 0, 0);
|
||||
Assert(cachetuple);
|
||||
/* we never free the copy we make, because Idesc needs it for later */
|
||||
|
||||
/*
|
||||
* we never free the copy we make, because Idesc needs it for
|
||||
* later
|
||||
*/
|
||||
idcur->tform = (Form_pg_index) GETSTRUCT(cachetuple);
|
||||
for (attnumP = &(idcur->tform->indkey[0]), natts = 0;
|
||||
*attnumP != InvalidAttrNumber && natts != INDEX_MAX_KEYS;
|
||||
|
@ -2247,7 +2255,8 @@ vc_enough_space(VPageDescr vpd, Size len)
|
|||
if (len > vpd->vpd_free)
|
||||
return false;
|
||||
|
||||
if (vpd->vpd_offsets_used < vpd->vpd_offsets_free) /* there are free itemid(s) */
|
||||
if (vpd->vpd_offsets_used < vpd->vpd_offsets_free) /* there are free
|
||||
* itemid(s) */
|
||||
return true; /* and len <= free_space */
|
||||
|
||||
/* ok. noff_usd >= noff_free and so we'll have to allocate new itemid */
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
* Routines for handling of 'SET var TO',
|
||||
* 'SHOW var' and 'RESET var' statements.
|
||||
*
|
||||
* $Id: variable.c,v 1.11 1998/09/01 03:22:10 momjian Exp $
|
||||
* $Id: variable.c,v 1.12 1998/09/01 04:28:07 momjian Exp $
|
||||
*
|
||||
*/
|
||||
|
||||
|
@ -554,7 +554,7 @@ struct VariableParsers
|
|||
{
|
||||
"client_encoding", parse_client_encoding, show_client_encoding, reset_client_encoding
|
||||
},
|
||||
{
|
||||
{
|
||||
"server_encoding", parse_server_encoding, show_server_encoding, reset_server_encoding
|
||||
},
|
||||
#endif
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/view.c,v 1.24 1998/08/06 05:12:30 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/commands/view.c,v 1.25 1998/09/01 04:28:10 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -223,7 +223,7 @@ UpdateRangeTableOfViewParse(char *viewName, Query *viewParse)
|
|||
OffsetVarNodes(viewParse->qual, 2);
|
||||
|
||||
OffsetVarNodes(viewParse->havingQual, 2);
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* find the old range table...
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.24 1998/07/27 19:37:54 vadim Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.25 1998/09/01 04:28:13 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -54,8 +54,7 @@
|
|||
#include "access/heapam.h"
|
||||
#include "catalog/heap.h"
|
||||
|
||||
static Pointer
|
||||
ExecBeginScan(Relation relation, int nkeys, ScanKey skeys,
|
||||
static Pointer ExecBeginScan(Relation relation, int nkeys, ScanKey skeys,
|
||||
bool isindex, ScanDirection dir, Snapshot snapshot);
|
||||
static Relation ExecOpenR(Oid relationOid, bool isindex);
|
||||
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/Attic/execFlatten.c,v 1.6 1998/09/01 03:22:11 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/Attic/execFlatten.c,v 1.7 1998/09/01 04:28:14 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -33,8 +33,7 @@
|
|||
#include "executor/execFlatten.h"
|
||||
|
||||
#ifdef SETS_FIXED
|
||||
static bool
|
||||
FjoinBumpOuterNodes(TargetEntry *tlist, ExprContext *econtext,
|
||||
static bool FjoinBumpOuterNodes(TargetEntry *tlist, ExprContext *econtext,
|
||||
DatumPtr results, char *nulls);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -26,7 +26,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.54 1998/09/01 03:22:14 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.55 1998/09/01 04:28:16 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -54,31 +54,25 @@
|
|||
#include "catalog/heap.h"
|
||||
#include "commands/trigger.h"
|
||||
|
||||
void
|
||||
ExecCheckPerms(CmdType operation, int resultRelation, List *rangeTable,
|
||||
void ExecCheckPerms(CmdType operation, int resultRelation, List *rangeTable,
|
||||
Query *parseTree);
|
||||
|
||||
|
||||
/* decls for local routines only used within this module */
|
||||
static TupleDesc
|
||||
InitPlan(CmdType operation, Query *parseTree,
|
||||
static TupleDesc InitPlan(CmdType operation, Query *parseTree,
|
||||
Plan *plan, EState *estate);
|
||||
static void EndPlan(Plan *plan, EState *estate);
|
||||
static TupleTableSlot *
|
||||
ExecutePlan(EState *estate, Plan *plan,
|
||||
static TupleTableSlot *ExecutePlan(EState *estate, Plan *plan,
|
||||
Query *parseTree, CmdType operation,
|
||||
int numberTuples, ScanDirection direction,
|
||||
void (*printfunc) ());
|
||||
static void ExecRetrieve(TupleTableSlot *slot, void (*printfunc) (),
|
||||
EState *estate);
|
||||
static void
|
||||
ExecAppend(TupleTableSlot *slot, ItemPointer tupleid,
|
||||
static void ExecAppend(TupleTableSlot *slot, ItemPointer tupleid,
|
||||
EState *estate);
|
||||
static void
|
||||
ExecDelete(TupleTableSlot *slot, ItemPointer tupleid,
|
||||
static void ExecDelete(TupleTableSlot *slot, ItemPointer tupleid,
|
||||
EState *estate);
|
||||
static void
|
||||
ExecReplace(TupleTableSlot *slot, ItemPointer tupleid,
|
||||
static void ExecReplace(TupleTableSlot *slot, ItemPointer tupleid,
|
||||
EState *estate, Query *parseTree);
|
||||
|
||||
/* end of local decls */
|
||||
|
@ -124,7 +118,7 @@ ExecutorStart(QueryDesc *queryDesc, EState *estate)
|
|||
palloc(queryDesc->plantree->nParamExec * sizeof(ParamExecData));
|
||||
memset(estate->es_param_exec_vals, 0, queryDesc->plantree->nParamExec * sizeof(ParamExecData));
|
||||
}
|
||||
|
||||
|
||||
estate->es_snapshot = SnapshotNow;
|
||||
|
||||
result = InitPlan(queryDesc->operation,
|
||||
|
@ -315,8 +309,8 @@ ExecCheckPerms(CmdType operation,
|
|||
|
||||
relid = rte->relid;
|
||||
htup = SearchSysCacheTuple(RELOID,
|
||||
ObjectIdGetDatum(relid),
|
||||
0, 0, 0);
|
||||
ObjectIdGetDatum(relid),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(htup))
|
||||
elog(ERROR, "ExecCheckPerms: bogus RT relid: %d",
|
||||
relid);
|
||||
|
@ -521,19 +515,19 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
|
|||
* NOTE: in the future we might want to initialize the junk
|
||||
* filter for all queries.
|
||||
* ----------------
|
||||
* SELECT added by daveh@insightdist.com 5/20/98 to allow
|
||||
* ORDER/GROUP BY have an identifier missing from the target.
|
||||
* SELECT added by daveh@insightdist.com 5/20/98 to allow
|
||||
* ORDER/GROUP BY have an identifier missing from the target.
|
||||
*/
|
||||
{
|
||||
bool junk_filter_needed = false;
|
||||
List *tlist;
|
||||
|
||||
bool junk_filter_needed = false;
|
||||
List *tlist;
|
||||
|
||||
if (operation == CMD_SELECT)
|
||||
{
|
||||
foreach(tlist, targetList)
|
||||
{
|
||||
TargetEntry *tle = lfirst(tlist);
|
||||
|
||||
TargetEntry *tle = lfirst(tlist);
|
||||
|
||||
if (tle->resdom->resjunk)
|
||||
{
|
||||
junk_filter_needed = true;
|
||||
|
@ -547,6 +541,7 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
|
|||
(operation == CMD_SELECT && junk_filter_needed))
|
||||
{
|
||||
JunkFilter *j = (JunkFilter *) ExecInitJunkFilter(targetList);
|
||||
|
||||
estate->es_junkFilter = j;
|
||||
|
||||
if (operation == CMD_SELECT)
|
||||
|
@ -555,7 +550,7 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
|
|||
else
|
||||
estate->es_junkFilter = NULL;
|
||||
}
|
||||
|
||||
|
||||
/* ----------------
|
||||
* initialize the "into" relation
|
||||
* ----------------
|
||||
|
@ -588,7 +583,7 @@ InitPlan(CmdType operation, Query *parseTree, Plan *plan, EState *estate)
|
|||
tupdesc = CreateTupleDescCopy(tupType);
|
||||
|
||||
intoRelationId = heap_create_with_catalog(intoName,
|
||||
tupdesc, RELKIND_RELATION);
|
||||
tupdesc, RELKIND_RELATION);
|
||||
|
||||
FreeTupleDesc(tupdesc);
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.35 1998/09/01 03:22:18 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.36 1998/09/01 04:28:18 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -68,24 +68,19 @@ int execConstLen;
|
|||
|
||||
/* static functions decls */
|
||||
static Datum ExecEvalAggreg(Aggreg *agg, ExprContext *econtext, bool *isNull);
|
||||
static Datum
|
||||
ExecEvalArrayRef(ArrayRef *arrayRef, ExprContext *econtext,
|
||||
static Datum ExecEvalArrayRef(ArrayRef *arrayRef, ExprContext *econtext,
|
||||
bool *isNull, bool *isDone);
|
||||
static Datum ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull);
|
||||
static Datum
|
||||
ExecEvalFunc(Expr *funcClause, ExprContext *econtext,
|
||||
static Datum ExecEvalFunc(Expr *funcClause, ExprContext *econtext,
|
||||
bool *isNull, bool *isDone);
|
||||
static void
|
||||
ExecEvalFuncArgs(FunctionCachePtr fcache, ExprContext *econtext,
|
||||
static void ExecEvalFuncArgs(FunctionCachePtr fcache, ExprContext *econtext,
|
||||
List *argList, Datum argV[], bool *argIsDone);
|
||||
static Datum ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull);
|
||||
static Datum
|
||||
ExecEvalOper(Expr *opClause, ExprContext *econtext,
|
||||
static Datum ExecEvalOper(Expr *opClause, ExprContext *econtext,
|
||||
bool *isNull);
|
||||
static Datum ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull);
|
||||
static Datum ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull);
|
||||
static Datum
|
||||
ExecMakeFunctionResult(Node *node, List *arguments,
|
||||
static Datum ExecMakeFunctionResult(Node *node, List *arguments,
|
||||
ExprContext *econtext, bool *isNull, bool *isDone);
|
||||
static bool ExecQualClause(Node *clause, ExprContext *econtext);
|
||||
|
||||
|
@ -200,7 +195,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef,
|
|||
static Datum
|
||||
ExecEvalAggreg(Aggreg *agg, ExprContext *econtext, bool *isNull)
|
||||
{
|
||||
*isNull = econtext->ecxt_nulls[agg->aggno];
|
||||
*isNull = econtext->ecxt_nulls[agg->aggno];
|
||||
return econtext->ecxt_values[agg->aggno];
|
||||
}
|
||||
|
||||
|
|
|
@ -11,7 +11,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.7 1998/02/26 12:13:09 vadim Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.8 1998/09/01 04:28:20 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -106,9 +106,9 @@ ExecScan(Scan *node,
|
|||
* NULL, then it means there is nothing more to scan
|
||||
* so we just return the empty slot...
|
||||
*
|
||||
* ... with invalid TupleDesc (not the same as in
|
||||
* projInfo->pi_slot) and break upper MergeJoin node.
|
||||
* New code below do what ExecProject() does. - vadim 02/26/98
|
||||
* ... with invalid TupleDesc (not the same as in
|
||||
* projInfo->pi_slot) and break upper MergeJoin node.
|
||||
* New code below do what ExecProject() does. - vadim 02/26/98
|
||||
* ----------------
|
||||
*/
|
||||
if (TupIsNull(slot))
|
||||
|
@ -116,10 +116,10 @@ ExecScan(Scan *node,
|
|||
scanstate->cstate.cs_TupFromTlist = false;
|
||||
resultSlot = scanstate->cstate.cs_ProjInfo->pi_slot;
|
||||
return (TupleTableSlot *)
|
||||
ExecStoreTuple (NULL,
|
||||
resultSlot,
|
||||
InvalidBuffer,
|
||||
true);
|
||||
ExecStoreTuple(NULL,
|
||||
resultSlot,
|
||||
InvalidBuffer,
|
||||
true);
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.37 1998/09/01 03:22:21 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.38 1998/09/01 04:28:22 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -57,8 +57,7 @@
|
|||
#include "utils/lsyscache.h"
|
||||
#include "utils/mcxt.h"
|
||||
|
||||
static void
|
||||
ExecGetIndexKeyInfo(Form_pg_index indexTuple, int *numAttsOutP,
|
||||
static void ExecGetIndexKeyInfo(Form_pg_index indexTuple, int *numAttsOutP,
|
||||
AttrNumber **attsOutP, FuncIndexInfoPtr fInfoP);
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
|
@ -750,7 +749,7 @@ ExecOpenIndices(Oid resultRelationOid,
|
|||
*/
|
||||
indexSd = heap_beginscan(indexRd, /* scan desc */
|
||||
false, /* scan backward flag */
|
||||
SnapshotNow, /* NOW snapshot */
|
||||
SnapshotNow, /* NOW snapshot */
|
||||
1, /* number scan keys */
|
||||
&key); /* scan keys */
|
||||
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.19 1998/09/01 03:22:22 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.20 1998/09/01 04:28:23 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -57,16 +57,13 @@ typedef struct local_es
|
|||
|
||||
/* non-export function prototypes */
|
||||
static TupleDesc postquel_start(execution_state *es);
|
||||
static execution_state *
|
||||
init_execution_state(FunctionCachePtr fcache,
|
||||
static execution_state *init_execution_state(FunctionCachePtr fcache,
|
||||
char *args[]);
|
||||
static TupleTableSlot *postquel_getnext(execution_state *es);
|
||||
static void postquel_end(execution_state *es);
|
||||
static void
|
||||
postquel_sub_params(execution_state *es, int nargs,
|
||||
static void postquel_sub_params(execution_state *es, int nargs,
|
||||
char *args[], bool *nullV);
|
||||
static Datum
|
||||
postquel_execute(execution_state *es, FunctionCachePtr fcache,
|
||||
static Datum postquel_execute(execution_state *es, FunctionCachePtr fcache,
|
||||
List *fTlist, char **args, bool *isNull);
|
||||
|
||||
|
||||
|
|
|
@ -109,388 +109,397 @@ ExecAgg(Agg *node)
|
|||
bool isNull = FALSE,
|
||||
isNull1 = FALSE,
|
||||
isNull2 = FALSE;
|
||||
bool qual_result;
|
||||
|
||||
bool qual_result;
|
||||
|
||||
|
||||
/* ---------------------
|
||||
* get state info from node
|
||||
* ---------------------
|
||||
*/
|
||||
|
||||
/* We loop retrieving groups until we find one matching node->plan.qual */
|
||||
do {
|
||||
|
||||
aggstate = node->aggstate;
|
||||
if (aggstate->agg_done)
|
||||
return NULL;
|
||||
|
||||
estate = node->plan.state;
|
||||
econtext = aggstate->csstate.cstate.cs_ExprContext;
|
||||
|
||||
nagg = length(node->aggs);
|
||||
|
||||
aggregates = (Aggreg **) palloc(sizeof(Aggreg *) * nagg);
|
||||
|
||||
/* take List* and make it an array that can be quickly indexed */
|
||||
alist = node->aggs;
|
||||
for (i = 0; i < nagg; i++)
|
||||
{
|
||||
aggregates[i] = lfirst(alist);
|
||||
aggregates[i]->aggno = i;
|
||||
alist = lnext(alist);
|
||||
}
|
||||
|
||||
value1 = node->aggstate->csstate.cstate.cs_ExprContext->ecxt_values;
|
||||
nulls = node->aggstate->csstate.cstate.cs_ExprContext->ecxt_nulls;
|
||||
|
||||
value2 = (Datum *) palloc(sizeof(Datum) * nagg);
|
||||
MemSet(value2, 0, sizeof(Datum) * nagg);
|
||||
|
||||
aggFuncInfo = (AggFuncInfo *) palloc(sizeof(AggFuncInfo) * nagg);
|
||||
MemSet(aggFuncInfo, 0, sizeof(AggFuncInfo) * nagg);
|
||||
|
||||
noInitValue = (int *) palloc(sizeof(int) * nagg);
|
||||
MemSet(noInitValue, 0, sizeof(noInitValue) * nagg);
|
||||
|
||||
outerPlan = outerPlan(node);
|
||||
oneTuple = NULL;
|
||||
|
||||
projInfo = aggstate->csstate.cstate.cs_ProjInfo;
|
||||
|
||||
for (i = 0; i < nagg; i++)
|
||||
{
|
||||
Aggreg *agg;
|
||||
char *aggname;
|
||||
HeapTuple aggTuple;
|
||||
Form_pg_aggregate aggp;
|
||||
Oid xfn1_oid,
|
||||
xfn2_oid,
|
||||
finalfn_oid;
|
||||
|
||||
agg = aggregates[i];
|
||||
|
||||
/* ---------------------
|
||||
* find transfer functions of all the aggregates and initialize
|
||||
* their initial values
|
||||
* ---------------------
|
||||
*/
|
||||
aggname = agg->aggname;
|
||||
aggTuple = SearchSysCacheTuple(AGGNAME,
|
||||
PointerGetDatum(aggname),
|
||||
ObjectIdGetDatum(agg->basetype),
|
||||
0, 0);
|
||||
if (!HeapTupleIsValid(aggTuple))
|
||||
elog(ERROR, "ExecAgg: cache lookup failed for aggregate \"%s\"(%s)",
|
||||
aggname,
|
||||
typeidTypeName(agg->basetype));
|
||||
aggp = (Form_pg_aggregate) GETSTRUCT(aggTuple);
|
||||
|
||||
xfn1_oid = aggp->aggtransfn1;
|
||||
xfn2_oid = aggp->aggtransfn2;
|
||||
finalfn_oid = aggp->aggfinalfn;
|
||||
|
||||
if (OidIsValid(finalfn_oid))
|
||||
{
|
||||
fmgr_info(finalfn_oid, &aggFuncInfo[i].finalfn);
|
||||
aggFuncInfo[i].finalfn_oid = finalfn_oid;
|
||||
}
|
||||
|
||||
if (OidIsValid(xfn2_oid))
|
||||
{
|
||||
fmgr_info(xfn2_oid, &aggFuncInfo[i].xfn2);
|
||||
aggFuncInfo[i].xfn2_oid = xfn2_oid;
|
||||
value2[i] = (Datum) AggNameGetInitVal((char *) aggname,
|
||||
aggp->aggbasetype,
|
||||
2,
|
||||
&isNull2);
|
||||
/* ------------------------------------------
|
||||
* If there is a second transition function, its initial
|
||||
* value must exist -- as it does not depend on data values,
|
||||
* we have no other way of determining an initial value.
|
||||
* ------------------------------------------
|
||||
*/
|
||||
if (isNull2)
|
||||
elog(ERROR, "ExecAgg: agginitval2 is null");
|
||||
}
|
||||
|
||||
if (OidIsValid(xfn1_oid))
|
||||
{
|
||||
fmgr_info(xfn1_oid, &aggFuncInfo[i].xfn1);
|
||||
aggFuncInfo[i].xfn1_oid = xfn1_oid;
|
||||
value1[i] = (Datum) AggNameGetInitVal((char *) aggname,
|
||||
aggp->aggbasetype,
|
||||
1,
|
||||
&isNull1);
|
||||
|
||||
/* ------------------------------------------
|
||||
* If the initial value for the first transition function
|
||||
* doesn't exist in the pg_aggregate table then we let
|
||||
* the first value returned from the outer procNode become
|
||||
* the initial value. (This is useful for aggregates like
|
||||
* max{} and min{}.)
|
||||
* ------------------------------------------
|
||||
*/
|
||||
if (isNull1)
|
||||
{
|
||||
noInitValue[i] = 1;
|
||||
nulls[i] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------
|
||||
* for each tuple from the the outer plan, apply all the aggregates
|
||||
* ----------------
|
||||
/*
|
||||
* We loop retrieving groups until we find one matching
|
||||
* node->plan.qual
|
||||
*/
|
||||
for (;;)
|
||||
do
|
||||
{
|
||||
HeapTuple outerTuple = NULL;
|
||||
TupleTableSlot *outerslot;
|
||||
|
||||
isNull = isNull1 = isNull2 = 0;
|
||||
outerslot = ExecProcNode(outerPlan, (Plan *) node);
|
||||
if (outerslot)
|
||||
outerTuple = outerslot->val;
|
||||
if (!HeapTupleIsValid(outerTuple))
|
||||
aggstate = node->aggstate;
|
||||
if (aggstate->agg_done)
|
||||
return NULL;
|
||||
|
||||
estate = node->plan.state;
|
||||
econtext = aggstate->csstate.cstate.cs_ExprContext;
|
||||
|
||||
nagg = length(node->aggs);
|
||||
|
||||
aggregates = (Aggreg **) palloc(sizeof(Aggreg *) * nagg);
|
||||
|
||||
/* take List* and make it an array that can be quickly indexed */
|
||||
alist = node->aggs;
|
||||
for (i = 0; i < nagg; i++)
|
||||
{
|
||||
|
||||
/*
|
||||
* when the outerplan doesn't return a single tuple, create a
|
||||
* dummy heaptuple anyway because we still need to return a
|
||||
* valid aggregate value. The value returned will be the
|
||||
* initial values of the transition functions
|
||||
*/
|
||||
if (nTuplesAgged == 0)
|
||||
{
|
||||
TupleDesc tupType;
|
||||
Datum *tupValue;
|
||||
char *null_array;
|
||||
|
||||
tupType = aggstate->csstate.css_ScanTupleSlot->ttc_tupleDescriptor;
|
||||
tupValue = projInfo->pi_tupValue;
|
||||
|
||||
/* initially, set all the values to NULL */
|
||||
null_array = palloc(tupType->natts);
|
||||
for (i = 0; i < tupType->natts; i++)
|
||||
null_array[i] = 'n';
|
||||
oneTuple = heap_formtuple(tupType, tupValue, null_array);
|
||||
pfree(null_array);
|
||||
}
|
||||
break;
|
||||
aggregates[i] = lfirst(alist);
|
||||
aggregates[i]->aggno = i;
|
||||
alist = lnext(alist);
|
||||
}
|
||||
|
||||
value1 = node->aggstate->csstate.cstate.cs_ExprContext->ecxt_values;
|
||||
nulls = node->aggstate->csstate.cstate.cs_ExprContext->ecxt_nulls;
|
||||
|
||||
value2 = (Datum *) palloc(sizeof(Datum) * nagg);
|
||||
MemSet(value2, 0, sizeof(Datum) * nagg);
|
||||
|
||||
aggFuncInfo = (AggFuncInfo *) palloc(sizeof(AggFuncInfo) * nagg);
|
||||
MemSet(aggFuncInfo, 0, sizeof(AggFuncInfo) * nagg);
|
||||
|
||||
noInitValue = (int *) palloc(sizeof(int) * nagg);
|
||||
MemSet(noInitValue, 0, sizeof(noInitValue) * nagg);
|
||||
|
||||
outerPlan = outerPlan(node);
|
||||
oneTuple = NULL;
|
||||
|
||||
projInfo = aggstate->csstate.cstate.cs_ProjInfo;
|
||||
|
||||
for (i = 0; i < nagg; i++)
|
||||
{
|
||||
AttrNumber attnum;
|
||||
int2 attlen = 0;
|
||||
Datum newVal = (Datum) NULL;
|
||||
AggFuncInfo *aggfns = &aggFuncInfo[i];
|
||||
Datum args[2];
|
||||
Node *tagnode = NULL;
|
||||
Aggreg *agg;
|
||||
char *aggname;
|
||||
HeapTuple aggTuple;
|
||||
Form_pg_aggregate aggp;
|
||||
Oid xfn1_oid,
|
||||
xfn2_oid,
|
||||
finalfn_oid;
|
||||
|
||||
switch (nodeTag(aggregates[i]->target))
|
||||
agg = aggregates[i];
|
||||
|
||||
/* ---------------------
|
||||
* find transfer functions of all the aggregates and initialize
|
||||
* their initial values
|
||||
* ---------------------
|
||||
*/
|
||||
aggname = agg->aggname;
|
||||
aggTuple = SearchSysCacheTuple(AGGNAME,
|
||||
PointerGetDatum(aggname),
|
||||
ObjectIdGetDatum(agg->basetype),
|
||||
0, 0);
|
||||
if (!HeapTupleIsValid(aggTuple))
|
||||
elog(ERROR, "ExecAgg: cache lookup failed for aggregate \"%s\"(%s)",
|
||||
aggname,
|
||||
typeidTypeName(agg->basetype));
|
||||
aggp = (Form_pg_aggregate) GETSTRUCT(aggTuple);
|
||||
|
||||
xfn1_oid = aggp->aggtransfn1;
|
||||
xfn2_oid = aggp->aggtransfn2;
|
||||
finalfn_oid = aggp->aggfinalfn;
|
||||
|
||||
if (OidIsValid(finalfn_oid))
|
||||
{
|
||||
case T_Var:
|
||||
tagnode = NULL;
|
||||
newVal = aggGetAttr(outerslot,
|
||||
aggregates[i],
|
||||
&isNull);
|
||||
break;
|
||||
case T_Expr:
|
||||
tagnode = ((Expr *) aggregates[i]->target)->oper;
|
||||
econtext->ecxt_scantuple = outerslot;
|
||||
newVal = ExecEvalExpr(aggregates[i]->target, econtext,
|
||||
&isNull, &isDone);
|
||||
break;
|
||||
case T_Const:
|
||||
tagnode = NULL;
|
||||
econtext->ecxt_scantuple = outerslot;
|
||||
newVal = ExecEvalExpr(aggregates[i]->target, econtext,
|
||||
&isNull, &isDone);
|
||||
break;
|
||||
default:
|
||||
elog(ERROR, "ExecAgg: Bad Agg->Target for Agg %d", i);
|
||||
fmgr_info(finalfn_oid, &aggFuncInfo[i].finalfn);
|
||||
aggFuncInfo[i].finalfn_oid = finalfn_oid;
|
||||
}
|
||||
|
||||
if (isNull && !aggregates[i]->usenulls)
|
||||
continue; /* ignore this tuple for this agg */
|
||||
|
||||
if (aggfns->xfn1.fn_addr != NULL)
|
||||
if (OidIsValid(xfn2_oid))
|
||||
{
|
||||
if (noInitValue[i])
|
||||
fmgr_info(xfn2_oid, &aggFuncInfo[i].xfn2);
|
||||
aggFuncInfo[i].xfn2_oid = xfn2_oid;
|
||||
value2[i] = (Datum) AggNameGetInitVal((char *) aggname,
|
||||
aggp->aggbasetype,
|
||||
2,
|
||||
&isNull2);
|
||||
/* ------------------------------------------
|
||||
* If there is a second transition function, its initial
|
||||
* value must exist -- as it does not depend on data values,
|
||||
* we have no other way of determining an initial value.
|
||||
* ------------------------------------------
|
||||
*/
|
||||
if (isNull2)
|
||||
elog(ERROR, "ExecAgg: agginitval2 is null");
|
||||
}
|
||||
|
||||
if (OidIsValid(xfn1_oid))
|
||||
{
|
||||
fmgr_info(xfn1_oid, &aggFuncInfo[i].xfn1);
|
||||
aggFuncInfo[i].xfn1_oid = xfn1_oid;
|
||||
value1[i] = (Datum) AggNameGetInitVal((char *) aggname,
|
||||
aggp->aggbasetype,
|
||||
1,
|
||||
&isNull1);
|
||||
|
||||
/* ------------------------------------------
|
||||
* If the initial value for the first transition function
|
||||
* doesn't exist in the pg_aggregate table then we let
|
||||
* the first value returned from the outer procNode become
|
||||
* the initial value. (This is useful for aggregates like
|
||||
* max{} and min{}.)
|
||||
* ------------------------------------------
|
||||
*/
|
||||
if (isNull1)
|
||||
{
|
||||
int byVal = 0;
|
||||
noInitValue[i] = 1;
|
||||
nulls[i] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* value1 and value2 has not been initialized. This is
|
||||
* the first non-NULL value. We use it as the initial
|
||||
* value.
|
||||
*/
|
||||
/* ----------------
|
||||
* for each tuple from the the outer plan, apply all the aggregates
|
||||
* ----------------
|
||||
*/
|
||||
for (;;)
|
||||
{
|
||||
HeapTuple outerTuple = NULL;
|
||||
TupleTableSlot *outerslot;
|
||||
|
||||
/*
|
||||
* but we can't just use it straight, we have to make
|
||||
* a copy of it since the tuple from which it came
|
||||
* will be freed on the next iteration of the scan
|
||||
*/
|
||||
switch (nodeTag(aggregates[i]->target))
|
||||
isNull = isNull1 = isNull2 = 0;
|
||||
outerslot = ExecProcNode(outerPlan, (Plan *) node);
|
||||
if (outerslot)
|
||||
outerTuple = outerslot->val;
|
||||
if (!HeapTupleIsValid(outerTuple))
|
||||
{
|
||||
|
||||
/*
|
||||
* when the outerplan doesn't return a single tuple,
|
||||
* create a dummy heaptuple anyway because we still need
|
||||
* to return a valid aggregate value. The value returned
|
||||
* will be the initial values of the transition functions
|
||||
*/
|
||||
if (nTuplesAgged == 0)
|
||||
{
|
||||
TupleDesc tupType;
|
||||
Datum *tupValue;
|
||||
char *null_array;
|
||||
|
||||
tupType = aggstate->csstate.css_ScanTupleSlot->ttc_tupleDescriptor;
|
||||
tupValue = projInfo->pi_tupValue;
|
||||
|
||||
/* initially, set all the values to NULL */
|
||||
null_array = palloc(tupType->natts);
|
||||
for (i = 0; i < tupType->natts; i++)
|
||||
null_array[i] = 'n';
|
||||
oneTuple = heap_formtuple(tupType, tupValue, null_array);
|
||||
pfree(null_array);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
for (i = 0; i < nagg; i++)
|
||||
{
|
||||
AttrNumber attnum;
|
||||
int2 attlen = 0;
|
||||
Datum newVal = (Datum) NULL;
|
||||
AggFuncInfo *aggfns = &aggFuncInfo[i];
|
||||
Datum args[2];
|
||||
Node *tagnode = NULL;
|
||||
|
||||
switch (nodeTag(aggregates[i]->target))
|
||||
{
|
||||
case T_Var:
|
||||
tagnode = NULL;
|
||||
newVal = aggGetAttr(outerslot,
|
||||
aggregates[i],
|
||||
&isNull);
|
||||
break;
|
||||
case T_Expr:
|
||||
tagnode = ((Expr *) aggregates[i]->target)->oper;
|
||||
econtext->ecxt_scantuple = outerslot;
|
||||
newVal = ExecEvalExpr(aggregates[i]->target, econtext,
|
||||
&isNull, &isDone);
|
||||
break;
|
||||
case T_Const:
|
||||
tagnode = NULL;
|
||||
econtext->ecxt_scantuple = outerslot;
|
||||
newVal = ExecEvalExpr(aggregates[i]->target, econtext,
|
||||
&isNull, &isDone);
|
||||
break;
|
||||
default:
|
||||
elog(ERROR, "ExecAgg: Bad Agg->Target for Agg %d", i);
|
||||
}
|
||||
|
||||
if (isNull && !aggregates[i]->usenulls)
|
||||
continue; /* ignore this tuple for this agg */
|
||||
|
||||
if (aggfns->xfn1.fn_addr != NULL)
|
||||
{
|
||||
if (noInitValue[i])
|
||||
{
|
||||
case T_Var:
|
||||
attnum = ((Var *) aggregates[i]->target)->varattno;
|
||||
attlen = outerslot->ttc_tupleDescriptor->attrs[attnum - 1]->attlen;
|
||||
byVal = outerslot->ttc_tupleDescriptor->attrs[attnum - 1]->attbyval;
|
||||
int byVal = 0;
|
||||
|
||||
break;
|
||||
case T_Expr:
|
||||
{
|
||||
FunctionCachePtr fcache_ptr;
|
||||
/*
|
||||
* value1 and value2 has not been initialized.
|
||||
* This is the first non-NULL value. We use it as
|
||||
* the initial value.
|
||||
*/
|
||||
|
||||
if (nodeTag(tagnode) == T_Func)
|
||||
fcache_ptr = ((Func *) tagnode)->func_fcache;
|
||||
else
|
||||
fcache_ptr = ((Oper *) tagnode)->op_fcache;
|
||||
attlen = fcache_ptr->typlen;
|
||||
byVal = fcache_ptr->typbyval;
|
||||
/*
|
||||
* but we can't just use it straight, we have to
|
||||
* make a copy of it since the tuple from which it
|
||||
* came will be freed on the next iteration of the
|
||||
* scan
|
||||
*/
|
||||
switch (nodeTag(aggregates[i]->target))
|
||||
{
|
||||
case T_Var:
|
||||
attnum = ((Var *) aggregates[i]->target)->varattno;
|
||||
attlen = outerslot->ttc_tupleDescriptor->attrs[attnum - 1]->attlen;
|
||||
byVal = outerslot->ttc_tupleDescriptor->attrs[attnum - 1]->attbyval;
|
||||
|
||||
break;
|
||||
}
|
||||
case T_Const:
|
||||
attlen = ((Const *) aggregates[i]->target)->constlen;
|
||||
byVal = ((Const *) aggregates[i]->target)->constbyval;
|
||||
case T_Expr:
|
||||
{
|
||||
FunctionCachePtr fcache_ptr;
|
||||
|
||||
break;
|
||||
default:
|
||||
elog(ERROR, "ExecAgg: Bad Agg->Target for Agg %d", i);
|
||||
if (nodeTag(tagnode) == T_Func)
|
||||
fcache_ptr = ((Func *) tagnode)->func_fcache;
|
||||
else
|
||||
fcache_ptr = ((Oper *) tagnode)->op_fcache;
|
||||
attlen = fcache_ptr->typlen;
|
||||
byVal = fcache_ptr->typbyval;
|
||||
|
||||
break;
|
||||
}
|
||||
case T_Const:
|
||||
attlen = ((Const *) aggregates[i]->target)->constlen;
|
||||
byVal = ((Const *) aggregates[i]->target)->constbyval;
|
||||
|
||||
break;
|
||||
default:
|
||||
elog(ERROR, "ExecAgg: Bad Agg->Target for Agg %d", i);
|
||||
}
|
||||
if (attlen == -1)
|
||||
{
|
||||
/* variable length */
|
||||
attlen = VARSIZE((struct varlena *) newVal);
|
||||
}
|
||||
value1[i] = (Datum) palloc(attlen);
|
||||
if (byVal)
|
||||
value1[i] = newVal;
|
||||
else
|
||||
memmove((char *) (value1[i]), (char *) newVal, attlen);
|
||||
noInitValue[i] = 0;
|
||||
nulls[i] = 0;
|
||||
}
|
||||
if (attlen == -1)
|
||||
{
|
||||
/* variable length */
|
||||
attlen = VARSIZE((struct varlena *) newVal);
|
||||
}
|
||||
value1[i] = (Datum) palloc(attlen);
|
||||
if (byVal)
|
||||
value1[i] = newVal;
|
||||
else
|
||||
memmove((char *) (value1[i]), (char *) newVal, attlen);
|
||||
noInitValue[i] = 0;
|
||||
nulls[i] = 0;
|
||||
{
|
||||
|
||||
/*
|
||||
* apply the transition functions.
|
||||
*/
|
||||
args[0] = value1[i];
|
||||
args[1] = newVal;
|
||||
value1[i] =
|
||||
(Datum) fmgr_c(&aggfns->xfn1,
|
||||
(FmgrValues *) args,
|
||||
&isNull1);
|
||||
Assert(!isNull1);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
if (aggfns->xfn2.fn_addr != NULL)
|
||||
{
|
||||
Datum xfn2_val = value2[i];
|
||||
|
||||
/*
|
||||
* apply the transition functions.
|
||||
*/
|
||||
args[0] = value1[i];
|
||||
args[1] = newVal;
|
||||
value1[i] =
|
||||
(Datum) fmgr_c(&aggfns->xfn1,
|
||||
(FmgrValues *) args,
|
||||
&isNull1);
|
||||
Assert(!isNull1);
|
||||
value2[i] =
|
||||
(Datum) fmgr_c(&aggfns->xfn2,
|
||||
(FmgrValues *) &xfn2_val, &isNull2);
|
||||
Assert(!isNull2);
|
||||
}
|
||||
}
|
||||
|
||||
if (aggfns->xfn2.fn_addr != NULL)
|
||||
{
|
||||
Datum xfn2_val = value2[i];
|
||||
/*
|
||||
* keep this for the projection (we only need one of these -
|
||||
* all the tuples we aggregate over share the same group
|
||||
* column)
|
||||
*/
|
||||
if (!oneTuple)
|
||||
oneTuple = heap_copytuple(outerslot->val);
|
||||
|
||||
value2[i] =
|
||||
(Datum) fmgr_c(&aggfns->xfn2,
|
||||
(FmgrValues *) &xfn2_val, &isNull2);
|
||||
Assert(!isNull2);
|
||||
nTuplesAgged++;
|
||||
}
|
||||
|
||||
/* --------------
|
||||
* finalize the aggregate (if necessary), and get the resultant value
|
||||
* --------------
|
||||
*/
|
||||
for (i = 0; i < nagg; i++)
|
||||
{
|
||||
char *args[2];
|
||||
AggFuncInfo *aggfns = &aggFuncInfo[i];
|
||||
|
||||
if (noInitValue[i])
|
||||
{
|
||||
|
||||
/*
|
||||
* No values found for this agg; return current state.
|
||||
* This seems to fix behavior for avg() aggregate. -tgl
|
||||
* 12/96
|
||||
*/
|
||||
}
|
||||
else if (aggfns->finalfn.fn_addr != NULL && nTuplesAgged > 0)
|
||||
{
|
||||
if (aggfns->finalfn.fn_nargs > 1)
|
||||
{
|
||||
args[0] = (char *) value1[i];
|
||||
args[1] = (char *) value2[i];
|
||||
}
|
||||
else if (aggfns->xfn1.fn_addr != NULL)
|
||||
args[0] = (char *) value1[i];
|
||||
else if (aggfns->xfn2.fn_addr != NULL)
|
||||
args[0] = (char *) value2[i];
|
||||
else
|
||||
elog(NOTICE, "ExecAgg: no valid transition functions??");
|
||||
value1[i] = (Datum) fmgr_c(&aggfns->finalfn,
|
||||
(FmgrValues *) args, &(nulls[i]));
|
||||
}
|
||||
else if (aggfns->xfn1.fn_addr != NULL)
|
||||
{
|
||||
|
||||
/*
|
||||
* value in the right place, ignore. (If you remove this
|
||||
* case, fix the else part. -ay 2/95)
|
||||
*/
|
||||
}
|
||||
else if (aggfns->xfn2.fn_addr != NULL)
|
||||
value1[i] = value2[i];
|
||||
else
|
||||
elog(ERROR, "ExecAgg: no valid transition functions??");
|
||||
}
|
||||
|
||||
/*
|
||||
* keep this for the projection (we only need one of these - all
|
||||
* the tuples we aggregate over share the same group column)
|
||||
* whether the aggregation is done depends on whether we are doing
|
||||
* aggregation over groups or the entire table
|
||||
*/
|
||||
if (!oneTuple)
|
||||
oneTuple = heap_copytuple(outerslot->val);
|
||||
|
||||
nTuplesAgged++;
|
||||
}
|
||||
|
||||
/* --------------
|
||||
* finalize the aggregate (if necessary), and get the resultant value
|
||||
* --------------
|
||||
*/
|
||||
for (i = 0; i < nagg; i++)
|
||||
{
|
||||
char *args[2];
|
||||
AggFuncInfo *aggfns = &aggFuncInfo[i];
|
||||
|
||||
if (noInitValue[i])
|
||||
if (nodeTag(outerPlan) == T_Group)
|
||||
{
|
||||
|
||||
/*
|
||||
* No values found for this agg; return current state. This
|
||||
* seems to fix behavior for avg() aggregate. -tgl 12/96
|
||||
*/
|
||||
/* aggregation over groups */
|
||||
aggstate->agg_done = ((Group *) outerPlan)->grpstate->grp_done;
|
||||
}
|
||||
else if (aggfns->finalfn.fn_addr != NULL && nTuplesAgged > 0)
|
||||
{
|
||||
if (aggfns->finalfn.fn_nargs > 1)
|
||||
{
|
||||
args[0] = (char *) value1[i];
|
||||
args[1] = (char *) value2[i];
|
||||
}
|
||||
else if (aggfns->xfn1.fn_addr != NULL)
|
||||
args[0] = (char *) value1[i];
|
||||
else if (aggfns->xfn2.fn_addr != NULL)
|
||||
args[0] = (char *) value2[i];
|
||||
else
|
||||
elog(NOTICE, "ExecAgg: no valid transition functions??");
|
||||
value1[i] = (Datum) fmgr_c(&aggfns->finalfn,
|
||||
(FmgrValues *) args, &(nulls[i]));
|
||||
}
|
||||
else if (aggfns->xfn1.fn_addr != NULL)
|
||||
{
|
||||
|
||||
/*
|
||||
* value in the right place, ignore. (If you remove this case,
|
||||
* fix the else part. -ay 2/95)
|
||||
*/
|
||||
}
|
||||
else if (aggfns->xfn2.fn_addr != NULL)
|
||||
value1[i] = value2[i];
|
||||
else
|
||||
elog(ERROR, "ExecAgg: no valid transition functions??");
|
||||
aggstate->agg_done = TRUE;
|
||||
|
||||
/* ----------------
|
||||
* form a projection tuple, store it in the result tuple
|
||||
* slot and return it.
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
ExecStoreTuple(oneTuple,
|
||||
aggstate->csstate.css_ScanTupleSlot,
|
||||
InvalidBuffer,
|
||||
false);
|
||||
econtext->ecxt_scantuple = aggstate->csstate.css_ScanTupleSlot;
|
||||
|
||||
resultSlot = ExecProject(projInfo, &isDone);
|
||||
|
||||
/*
|
||||
* As long as the retrieved group does not match the
|
||||
* qualifications it is ignored and the next group is fetched
|
||||
*/
|
||||
qual_result = ExecQual(fix_opids(node->plan.qual), econtext);
|
||||
if (oneTuple)
|
||||
pfree(oneTuple);
|
||||
}
|
||||
|
||||
/*
|
||||
* whether the aggregation is done depends on whether we are doing
|
||||
* aggregation over groups or the entire table
|
||||
*/
|
||||
if (nodeTag(outerPlan) == T_Group)
|
||||
{
|
||||
/* aggregation over groups */
|
||||
aggstate->agg_done = ((Group *) outerPlan)->grpstate->grp_done;
|
||||
}
|
||||
else
|
||||
aggstate->agg_done = TRUE;
|
||||
|
||||
/* ----------------
|
||||
* form a projection tuple, store it in the result tuple
|
||||
* slot and return it.
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
ExecStoreTuple(oneTuple,
|
||||
aggstate->csstate.css_ScanTupleSlot,
|
||||
InvalidBuffer,
|
||||
false);
|
||||
econtext->ecxt_scantuple = aggstate->csstate.css_ScanTupleSlot;
|
||||
|
||||
resultSlot = ExecProject(projInfo, &isDone);
|
||||
|
||||
/* As long as the retrieved group does not match the qualifications it is ignored and
|
||||
* the next group is fetched */
|
||||
qual_result=ExecQual(fix_opids(node->plan.qual),econtext);
|
||||
if (oneTuple)
|
||||
pfree(oneTuple);
|
||||
}
|
||||
while((node->plan.qual!=NULL) && (qual_result!=true));
|
||||
while ((node->plan.qual != NULL) && (qual_result != true));
|
||||
|
||||
return resultSlot;
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeAppend.c,v 1.14 1998/07/15 22:16:18 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeAppend.c,v 1.15 1998/09/01 04:28:26 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -158,7 +158,7 @@ exec_append_initialize_next(Append *node)
|
|||
{
|
||||
estate->es_result_relation_info =
|
||||
(RelationInfo *) nth(whichplan,
|
||||
appendstate->as_result_relation_info_list);
|
||||
appendstate->as_result_relation_info_list);
|
||||
}
|
||||
result_slot->ttc_whichplan = whichplan;
|
||||
|
||||
|
@ -505,8 +505,8 @@ void
|
|||
ExecReScanAppend(Append *node, ExprContext *exprCtxt, Plan *parent)
|
||||
{
|
||||
AppendState *appendstate = node->appendstate;
|
||||
int nplans = length(node->appendplans);
|
||||
int i;
|
||||
int nplans = length(node->appendplans);
|
||||
int i;
|
||||
|
||||
for (i = 0; i < nplans; i++)
|
||||
{
|
||||
|
@ -517,7 +517,7 @@ ExecReScanAppend(Append *node, ExprContext *exprCtxt, Plan *parent)
|
|||
if (rescanNode->chgParam == NULL)
|
||||
{
|
||||
exec_append_initialize_next(node);
|
||||
ExecReScan((Plan *)rescanNode, exprCtxt, (Plan *) node);
|
||||
ExecReScan((Plan *) rescanNode, exprCtxt, (Plan *) node);
|
||||
}
|
||||
}
|
||||
appendstate->as_whichplan = 0;
|
||||
|
|
|
@ -13,7 +13,7 @@
|
|||
* columns. (ie. tuples from the same group are consecutive)
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.21 1998/07/16 02:58:09 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.22 1998/09/01 04:28:28 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -30,8 +30,7 @@
|
|||
|
||||
static TupleTableSlot *ExecGroupEveryTuple(Group *node);
|
||||
static TupleTableSlot *ExecGroupOneTuple(Group *node);
|
||||
static bool
|
||||
sameGroup(HeapTuple oldslot, HeapTuple newslot,
|
||||
static bool sameGroup(HeapTuple oldslot, HeapTuple newslot,
|
||||
int numCols, AttrNumber *grpColIdx, TupleDesc tupdesc);
|
||||
|
||||
/* ---------------------------------------
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.22 1998/09/01 03:22:23 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.23 1998/09/01 04:28:29 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -45,8 +45,7 @@ static void mk_hj_temp(char *tempname);
|
|||
static int hashFunc(char *key, int len);
|
||||
static int ExecHashPartition(Hash *node);
|
||||
static RelativeAddr hashTableAlloc(int size, HashJoinTable hashtable);
|
||||
static void
|
||||
ExecHashOverflowInsert(HashJoinTable hashtable,
|
||||
static void ExecHashOverflowInsert(HashJoinTable hashtable,
|
||||
HashBucket bucket,
|
||||
HeapTuple heapTuple);
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.12 1998/09/01 03:22:25 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.13 1998/09/01 04:28:31 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -28,12 +28,10 @@
|
|||
static TupleTableSlot *
|
||||
ExecHashJoinOuterGetTuple(Plan *node, Plan *parent, HashJoinState *hjstate);
|
||||
|
||||
static TupleTableSlot *
|
||||
ExecHashJoinGetSavedTuple(HashJoinState *hjstate, char *buffer,
|
||||
static TupleTableSlot *ExecHashJoinGetSavedTuple(HashJoinState *hjstate, char *buffer,
|
||||
File file, TupleTableSlot *tupleSlot, int *block, char **position);
|
||||
|
||||
static int
|
||||
ExecHashJoinGetBatch(int bucketno, HashJoinTable hashtable,
|
||||
static int ExecHashJoinGetBatch(int bucketno, HashJoinTable hashtable,
|
||||
int nbatch);
|
||||
|
||||
static int ExecHashJoinNewBatch(HashJoinState *hjstate);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.26 1998/09/01 03:22:26 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.27 1998/09/01 04:28:32 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -85,8 +85,8 @@ IndexNext(IndexScan *node)
|
|||
EState *estate;
|
||||
CommonScanState *scanstate;
|
||||
IndexScanState *indexstate;
|
||||
ScanDirection direction;
|
||||
Snapshot snapshot;
|
||||
ScanDirection direction;
|
||||
Snapshot snapshot;
|
||||
IndexScanDescPtr scanDescs;
|
||||
IndexScanDesc scandesc;
|
||||
Relation heapRelation;
|
||||
|
@ -95,7 +95,7 @@ IndexNext(IndexScan *node)
|
|||
TupleTableSlot *slot;
|
||||
Buffer buffer = InvalidBuffer;
|
||||
int numIndices;
|
||||
|
||||
|
||||
/* ----------------
|
||||
* extract necessary information from index scan node
|
||||
* ----------------
|
||||
|
@ -122,39 +122,40 @@ IndexNext(IndexScan *node)
|
|||
while ((result = index_getnext(scandesc, direction)) != NULL)
|
||||
{
|
||||
tuple = heap_fetch(heapRelation, snapshot,
|
||||
&result->heap_iptr, &buffer);
|
||||
&result->heap_iptr, &buffer);
|
||||
pfree(result);
|
||||
|
||||
if (tuple != NULL)
|
||||
{
|
||||
bool prev_matches = false;
|
||||
int prev_index;
|
||||
|
||||
|
||||
/* ----------------
|
||||
* store the scanned tuple in the scan tuple slot of
|
||||
* the scan state. Eventually we will only do this and not
|
||||
* return a tuple. Note: we pass 'false' because tuples
|
||||
* returned by amgetnext are pointers onto disk pages and
|
||||
* were not created with palloc() and so should not be pfree()'d.
|
||||
* ----------------
|
||||
*/
|
||||
ExecStoreTuple(tuple, /* tuple to store */
|
||||
slot, /* slot to store in */
|
||||
buffer, /* buffer associated with tuple */
|
||||
false); /* don't pfree */
|
||||
* store the scanned tuple in the scan tuple slot of
|
||||
* the scan state. Eventually we will only do this and not
|
||||
* return a tuple. Note: we pass 'false' because tuples
|
||||
* returned by amgetnext are pointers onto disk pages and
|
||||
* were not created with palloc() and so should not be pfree()'d.
|
||||
* ----------------
|
||||
*/
|
||||
ExecStoreTuple(tuple, /* tuple to store */
|
||||
slot, /* slot to store in */
|
||||
buffer, /* buffer associated with tuple */
|
||||
false); /* don't pfree */
|
||||
|
||||
/*
|
||||
* We must check to see if the current tuple would have been
|
||||
* matched by an earlier index, so we don't double report it.
|
||||
* We do this by passing the tuple through ExecQual and look
|
||||
* for failure with all previous qualifications.
|
||||
* We must check to see if the current tuple would have
|
||||
* been matched by an earlier index, so we don't double
|
||||
* report it. We do this by passing the tuple through
|
||||
* ExecQual and look for failure with all previous
|
||||
* qualifications.
|
||||
*/
|
||||
for (prev_index = 0; prev_index < indexstate->iss_IndexPtr;
|
||||
prev_index++)
|
||||
prev_index++)
|
||||
{
|
||||
scanstate->cstate.cs_ExprContext->ecxt_scantuple = slot;
|
||||
if (ExecQual(nth(prev_index, node->indxqual),
|
||||
scanstate->cstate.cs_ExprContext))
|
||||
scanstate->cstate.cs_ExprContext))
|
||||
{
|
||||
prev_matches = true;
|
||||
break;
|
||||
|
@ -259,17 +260,16 @@ ExecIndexReScan(IndexScan *node, ExprContext *exprCtxt, Plan *parent)
|
|||
indxqual = node->indxqual;
|
||||
numScanKeys = indexstate->iss_NumScanKeys;
|
||||
indexstate->iss_IndexPtr = 0;
|
||||
|
||||
|
||||
/* it's possible in subselects */
|
||||
if (exprCtxt == NULL)
|
||||
exprCtxt = node->scan.scanstate->cstate.cs_ExprContext;
|
||||
|
||||
node->scan.scanstate->cstate.cs_ExprContext->ecxt_outertuple =
|
||||
exprCtxt->ecxt_outertuple;
|
||||
|
||||
|
||||
/*
|
||||
* get the index qualifications and recalculate the appropriate
|
||||
* values
|
||||
* get the index qualifications and recalculate the appropriate values
|
||||
*/
|
||||
for (i = 0; i < numIndices; i++)
|
||||
{
|
||||
|
@ -282,17 +282,19 @@ ExecIndexReScan(IndexScan *node, ExprContext *exprCtxt, Plan *parent)
|
|||
run_keys = (int *) runtimeKeyInfo[i];
|
||||
for (j = 0; j < n_keys; j++)
|
||||
{
|
||||
|
||||
/*
|
||||
* If we have a run-time key, then extract the run-time
|
||||
* expression and evaluate it with respect to the current
|
||||
* outer tuple. We then stick the result into the scan key.
|
||||
* outer tuple. We then stick the result into the scan
|
||||
* key.
|
||||
*/
|
||||
if (run_keys[j] != NO_OP)
|
||||
{
|
||||
clause = nth(j, qual);
|
||||
scanexpr = (run_keys[j] == RIGHT_OP) ?
|
||||
(Node *) get_rightop(clause) : (Node *) get_leftop(clause);
|
||||
|
||||
|
||||
/*
|
||||
* pass in isDone but ignore it. We don't iterate in
|
||||
* quals
|
||||
|
@ -333,7 +335,7 @@ ExecEndIndexScan(IndexScan *node)
|
|||
IndexScanState *indexstate;
|
||||
Pointer *runtimeKeyInfo;
|
||||
ScanKey *scanKeys;
|
||||
List *indxqual;
|
||||
List *indxqual;
|
||||
int *numScanKeys;
|
||||
int numIndices;
|
||||
int i;
|
||||
|
@ -342,7 +344,7 @@ ExecEndIndexScan(IndexScan *node)
|
|||
indexstate = node->indxstate;
|
||||
indxqual = node->indxqual;
|
||||
runtimeKeyInfo = (Pointer *) indexstate->iss_RuntimeKeyInfo;
|
||||
|
||||
|
||||
/* ----------------
|
||||
* extract information from the node
|
||||
* ----------------
|
||||
|
@ -381,7 +383,7 @@ ExecEndIndexScan(IndexScan *node)
|
|||
pfree(numScanKeys);
|
||||
|
||||
if (runtimeKeyInfo)
|
||||
{
|
||||
{
|
||||
for (i = 0; i < numIndices; i++)
|
||||
{
|
||||
List *qual;
|
||||
|
@ -394,7 +396,7 @@ ExecEndIndexScan(IndexScan *node)
|
|||
}
|
||||
pfree(runtimeKeyInfo);
|
||||
}
|
||||
|
||||
|
||||
/* ----------------
|
||||
* clear out tuple table slots
|
||||
* ----------------
|
||||
|
@ -428,7 +430,7 @@ ExecIndexMarkPos(IndexScan *node)
|
|||
#if 0
|
||||
IndexScanMarkPosition(scanDesc);
|
||||
#endif
|
||||
index_markpos (scanDesc);
|
||||
index_markpos(scanDesc);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
|
@ -457,7 +459,7 @@ ExecIndexRestrPos(IndexScan *node)
|
|||
#if 0
|
||||
IndexScanRestorePosition(scanDesc);
|
||||
#endif
|
||||
index_restrpos (scanDesc);
|
||||
index_restrpos(scanDesc);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
|
@ -504,7 +506,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate, Plan *parent)
|
|||
HeapScanDesc currentScanDesc;
|
||||
ScanDirection direction;
|
||||
int baseid;
|
||||
|
||||
|
||||
List *execParam = NULL;
|
||||
|
||||
/* ----------------
|
||||
|
@ -727,22 +729,22 @@ ExecInitIndexScan(IndexScan *node, EState *estate, Plan *parent)
|
|||
* it identifies the value to place in our scan key.
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
|
||||
/* Life was so easy before ... subselects */
|
||||
if ( ((Param *) leftop)->paramkind == PARAM_EXEC )
|
||||
if (((Param *) leftop)->paramkind == PARAM_EXEC)
|
||||
{
|
||||
have_runtime_keys = true;
|
||||
run_keys[j] = LEFT_OP;
|
||||
execParam = lappendi (execParam, ((Param*) leftop)->paramid);
|
||||
execParam = lappendi(execParam, ((Param *) leftop)->paramid);
|
||||
}
|
||||
else
|
||||
{
|
||||
scanvalue = ExecEvalParam((Param *) leftop,
|
||||
scanstate->cstate.cs_ExprContext,
|
||||
scanstate->cstate.cs_ExprContext,
|
||||
&isnull);
|
||||
if (isnull)
|
||||
flags |= SK_ISNULL;
|
||||
|
||||
|
||||
run_keys[j] = NO_OP;
|
||||
}
|
||||
}
|
||||
|
@ -820,22 +822,22 @@ ExecInitIndexScan(IndexScan *node, EState *estate, Plan *parent)
|
|||
* it identifies the value to place in our scan key.
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
|
||||
/* Life was so easy before ... subselects */
|
||||
if ( ((Param *) rightop)->paramkind == PARAM_EXEC )
|
||||
if (((Param *) rightop)->paramkind == PARAM_EXEC)
|
||||
{
|
||||
have_runtime_keys = true;
|
||||
run_keys[j] = RIGHT_OP;
|
||||
execParam = lappendi (execParam, ((Param*) rightop)->paramid);
|
||||
execParam = lappendi(execParam, ((Param *) rightop)->paramid);
|
||||
}
|
||||
else
|
||||
{
|
||||
scanvalue = ExecEvalParam((Param *) rightop,
|
||||
scanstate->cstate.cs_ExprContext,
|
||||
scanstate->cstate.cs_ExprContext,
|
||||
&isnull);
|
||||
if (isnull)
|
||||
flags |= SK_ISNULL;
|
||||
|
||||
|
||||
run_keys[j] = NO_OP;
|
||||
}
|
||||
}
|
||||
|
@ -992,13 +994,13 @@ ExecInitIndexScan(IndexScan *node, EState *estate, Plan *parent)
|
|||
indexstate->iss_ScanDescs = scanDescs;
|
||||
|
||||
indexstate->cstate.cs_TupFromTlist = false;
|
||||
|
||||
/*
|
||||
* if there are some PARAM_EXEC in skankeys then
|
||||
* force index rescan on first scan.
|
||||
|
||||
/*
|
||||
* if there are some PARAM_EXEC in skankeys then force index rescan on
|
||||
* first scan.
|
||||
*/
|
||||
((Plan*) node)->chgParam = execParam;
|
||||
|
||||
((Plan *) node)->chgParam = execParam;
|
||||
|
||||
/* ----------------
|
||||
* all done.
|
||||
* ----------------
|
||||
|
@ -1010,5 +1012,5 @@ int
|
|||
ExecCountSlotsIndexScan(IndexScan *node)
|
||||
{
|
||||
return ExecCountSlotsNode(outerPlan((Plan *) node)) +
|
||||
ExecCountSlotsNode(innerPlan((Plan *) node)) + INDEXSCAN_NSLOTS;
|
||||
ExecCountSlotsNode(innerPlan((Plan *) node)) + INDEXSCAN_NSLOTS;
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMaterial.c,v 1.16 1998/09/01 03:22:27 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMaterial.c,v 1.17 1998/09/01 04:28:34 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -173,7 +173,7 @@ ExecMaterial(Material *node)
|
|||
|
||||
return ExecStoreTuple(heapTuple, /* tuple to store */
|
||||
slot, /* slot to store in */
|
||||
currentScanDesc->rs_cbuf, /* buffer for this tuple */
|
||||
currentScanDesc->rs_cbuf, /* buffer for this tuple */
|
||||
false); /* don't pfree this pointer */
|
||||
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.18 1998/07/19 10:05:19 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.19 1998/09/01 04:28:35 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -480,8 +480,8 @@ ExecMergeJoin(MergeJoin *node)
|
|||
* means that this is the first time ExecMergeJoin() has
|
||||
* been called and so we have to initialize the inner,
|
||||
* outer and marked tuples as well as various stuff in the
|
||||
* expression context.
|
||||
* ********************************
|
||||
* expression context. ********************************
|
||||
*
|
||||
*/
|
||||
case EXEC_MJ_INITIALIZE:
|
||||
MJ_printf("ExecMergeJoin: EXEC_MJ_INITIALIZE\n");
|
||||
|
@ -514,7 +514,7 @@ ExecMergeJoin(MergeJoin *node)
|
|||
|
||||
mergestate->mj_MarkedTupleSlot->ttc_tupleDescriptor =
|
||||
innerTupleSlot->ttc_tupleDescriptor;
|
||||
|
||||
|
||||
/* ----------------
|
||||
* initialize merge join state to skip inner tuples.
|
||||
* ----------------
|
||||
|
@ -526,8 +526,8 @@ ExecMergeJoin(MergeJoin *node)
|
|||
* ******************************** EXEC_MJ_JOINMARK means
|
||||
* we have just found a new outer tuple and a possible
|
||||
* matching inner tuple. This is the case after the
|
||||
* INITIALIZE, SKIPOUTER or SKIPINNER states.
|
||||
* ********************************
|
||||
* INITIALIZE, SKIPOUTER or SKIPINNER states. ********************************
|
||||
*
|
||||
*/
|
||||
case EXEC_MJ_JOINMARK:
|
||||
MJ_printf("ExecMergeJoin: EXEC_MJ_JOINMARK\n");
|
||||
|
@ -655,8 +655,8 @@ ExecMergeJoin(MergeJoin *node)
|
|||
break;
|
||||
|
||||
/*
|
||||
* ******************************** EXEC_MJ_TESTOUTER
|
||||
* If the new outer tuple and the marked tuple satisify the
|
||||
* ******************************** EXEC_MJ_TESTOUTER If
|
||||
* the new outer tuple and the marked tuple satisify the
|
||||
* merge clause then we know we have duplicates in the
|
||||
* outer scan so we have to restore the inner scan to the
|
||||
* marked tuple and proceed to join the new outer tuples
|
||||
|
@ -680,7 +680,9 @@ ExecMergeJoin(MergeJoin *node)
|
|||
*
|
||||
* new outer tuple > marked tuple
|
||||
*
|
||||
* ****************************
|
||||
***************************
|
||||
*
|
||||
*
|
||||
*/
|
||||
case EXEC_MJ_TESTOUTER:
|
||||
MJ_printf("ExecMergeJoin: EXEC_MJ_TESTOUTER\n");
|
||||
|
@ -698,13 +700,14 @@ ExecMergeJoin(MergeJoin *node)
|
|||
|
||||
if (qualResult)
|
||||
{
|
||||
/*
|
||||
* the merge clause matched so now we juggle the slots
|
||||
* back the way they were and proceed to JOINTEST.
|
||||
|
||||
/*
|
||||
* the merge clause matched so now we juggle the slots
|
||||
* back the way they were and proceed to JOINTEST.
|
||||
*
|
||||
* I can't understand why we have to go to JOINTEST
|
||||
* and compare outer tuple with the same inner one
|
||||
* again -> go to JOINTUPLES... - vadim 02/27/98
|
||||
* I can't understand why we have to go to JOINTEST and
|
||||
* compare outer tuple with the same inner one again
|
||||
* -> go to JOINTUPLES... - vadim 02/27/98
|
||||
*/
|
||||
|
||||
ExecRestrPos(innerPlan);
|
||||
|
@ -738,7 +741,7 @@ ExecMergeJoin(MergeJoin *node)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
/* continue on to skip outer tuples */
|
||||
/* continue on to skip outer tuples */
|
||||
mergestate->mj_JoinState = EXEC_MJ_SKIPOUTER;
|
||||
}
|
||||
break;
|
||||
|
@ -756,7 +759,9 @@ ExecMergeJoin(MergeJoin *node)
|
|||
* we have to advance the outer scan until we find the outer
|
||||
* 8.
|
||||
*
|
||||
****************************
|
||||
**************************
|
||||
*
|
||||
*
|
||||
*
|
||||
*
|
||||
*
|
||||
|
@ -856,7 +861,9 @@ ExecMergeJoin(MergeJoin *node)
|
|||
* we have to advance the inner scan until we find the inner
|
||||
* 12.
|
||||
*
|
||||
****************************
|
||||
**************************
|
||||
*
|
||||
*
|
||||
*
|
||||
*
|
||||
*
|
||||
|
@ -988,10 +995,10 @@ bool
|
|||
ExecInitMergeJoin(MergeJoin *node, EState *estate, Plan *parent)
|
||||
{
|
||||
MergeJoinState *mergestate;
|
||||
List *joinclauses;
|
||||
RegProcedure rightsortop;
|
||||
RegProcedure leftsortop;
|
||||
RegProcedure sortop;
|
||||
List *joinclauses;
|
||||
RegProcedure rightsortop;
|
||||
RegProcedure leftsortop;
|
||||
RegProcedure sortop;
|
||||
TupleTableSlot *mjSlot;
|
||||
|
||||
List *OSortopI;
|
||||
|
@ -1042,7 +1049,7 @@ ExecInitMergeJoin(MergeJoin *node, EState *estate, Plan *parent)
|
|||
mjSlot->ttc_whichplan = -1;
|
||||
mjSlot->ttc_descIsNew = true;
|
||||
mergestate->mj_MarkedTupleSlot = mjSlot;
|
||||
|
||||
|
||||
/* ----------------
|
||||
* get merge sort operators.
|
||||
*
|
||||
|
@ -1166,9 +1173,9 @@ ExecEndMergeJoin(MergeJoin *node)
|
|||
*/
|
||||
ExecClearTuple(mergestate->jstate.cs_ResultTupleSlot);
|
||||
ExecClearTuple(mergestate->mj_MarkedTupleSlot);
|
||||
pfree (mergestate->mj_MarkedTupleSlot);
|
||||
pfree(mergestate->mj_MarkedTupleSlot);
|
||||
mergestate->mj_MarkedTupleSlot = NULL;
|
||||
|
||||
|
||||
MJ1_printf("ExecEndMergeJoin: %s\n",
|
||||
"node processing ended");
|
||||
}
|
||||
|
@ -1185,12 +1192,12 @@ ExecReScanMergeJoin(MergeJoin *node, ExprContext *exprCtxt, Plan *parent)
|
|||
mjSlot->ttc_tupleDescriptor = NULL;
|
||||
mjSlot->ttc_whichplan = -1;
|
||||
mjSlot->ttc_descIsNew = true;
|
||||
|
||||
|
||||
mergestate->mj_JoinState = EXEC_MJ_INITIALIZE;
|
||||
|
||||
/*
|
||||
* if chgParam of subnodes is not null then plans will be re-scanned by
|
||||
* first ExecProcNode.
|
||||
* if chgParam of subnodes is not null then plans will be re-scanned
|
||||
* by first ExecProcNode.
|
||||
*/
|
||||
if (((Plan *) node)->lefttree->chgParam == NULL)
|
||||
ExecReScan(((Plan *) node)->lefttree, exprCtxt, (Plan *) node);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.13 1998/09/01 03:22:28 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.14 1998/09/01 04:28:37 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -30,8 +30,7 @@
|
|||
#include "access/heapam.h"
|
||||
#include "parser/parsetree.h"
|
||||
|
||||
static Oid
|
||||
InitScanRelation(SeqScan *node, EState *estate,
|
||||
static Oid InitScanRelation(SeqScan *node, EState *estate,
|
||||
CommonScanState *scanstate, Plan *outerPlan);
|
||||
|
||||
static TupleTableSlot *SeqNext(SeqScan *node);
|
||||
|
@ -83,7 +82,8 @@ SeqNext(SeqScan *node)
|
|||
|
||||
slot = ExecStoreTuple(tuple,/* tuple to store */
|
||||
slot, /* slot to store in */
|
||||
scandesc->rs_cbuf,/* buffer associated with this tuple */
|
||||
scandesc->rs_cbuf, /* buffer associated with
|
||||
* this tuple */
|
||||
false); /* don't pfree this pointer */
|
||||
|
||||
/* ----------------
|
||||
|
|
|
@ -112,8 +112,8 @@ ExecInitSubPlan(SubPlan *node, EState *estate, Plan *parent)
|
|||
{
|
||||
EState *sp_estate = CreateExecutorState();
|
||||
|
||||
ExecCheckPerms (CMD_SELECT, 0, node->rtable, (Query*) NULL);
|
||||
|
||||
ExecCheckPerms(CMD_SELECT, 0, node->rtable, (Query *) NULL);
|
||||
|
||||
sp_estate->es_range_table = node->rtable;
|
||||
sp_estate->es_param_list_info = estate->es_param_list_info;
|
||||
sp_estate->es_param_exec_vals = estate->es_param_exec_vals;
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
* ExecEndTee
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/Attic/nodeTee.c,v 1.22 1998/09/01 03:22:32 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/executor/Attic/nodeTee.c,v 1.23 1998/09/01 04:28:40 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -168,8 +168,8 @@ ExecInitTee(Tee *node, EState *currentEstate, Plan *parent)
|
|||
bufferRel = heap_openr(teeState->tee_bufferRelname);
|
||||
else
|
||||
bufferRel = heap_open(
|
||||
heap_create_with_catalog(teeState->tee_bufferRelname,
|
||||
tupType, RELKIND_RELATION));
|
||||
heap_create_with_catalog(teeState->tee_bufferRelname,
|
||||
tupType, RELKIND_RELATION));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -178,8 +178,8 @@ ExecInitTee(Tee *node, EState *currentEstate, Plan *parent)
|
|||
newoid());
|
||||
/* bufferRel = ExecCreatR(len, tupType, _TEMP_RELATION_ID); */
|
||||
bufferRel = heap_open(
|
||||
heap_create_with_catalog(teeState->tee_bufferRelname,
|
||||
tupType, RELKIND_RELATION));
|
||||
heap_create_with_catalog(teeState->tee_bufferRelname,
|
||||
tupType, RELKIND_RELATION));
|
||||
}
|
||||
|
||||
teeState->tee_bufferRel = bufferRel;
|
||||
|
@ -228,11 +228,11 @@ ExecCountSlotsTee(Tee *node)
|
|||
static void
|
||||
initTeeScanDescs(Tee *node)
|
||||
{
|
||||
TeeState *teeState;
|
||||
Relation bufferRel;
|
||||
ScanDirection dir;
|
||||
Snapshot snapshot;
|
||||
MemoryContext orig;
|
||||
TeeState *teeState;
|
||||
Relation bufferRel;
|
||||
ScanDirection dir;
|
||||
Snapshot snapshot;
|
||||
MemoryContext orig;
|
||||
|
||||
teeState = node->teestate;
|
||||
if (teeState->tee_leftScanDesc && teeState->tee_rightScanDesc)
|
||||
|
@ -250,18 +250,18 @@ initTeeScanDescs(Tee *node)
|
|||
{
|
||||
teeState->tee_leftScanDesc = heap_beginscan(bufferRel,
|
||||
ScanDirectionIsBackward(dir),
|
||||
snapshot,
|
||||
0, /* num scan keys */
|
||||
NULL /* scan keys */
|
||||
snapshot,
|
||||
0, /* num scan keys */
|
||||
NULL /* scan keys */
|
||||
);
|
||||
}
|
||||
if (teeState->tee_rightScanDesc == NULL)
|
||||
{
|
||||
teeState->tee_rightScanDesc = heap_beginscan(bufferRel,
|
||||
ScanDirectionIsBackward(dir),
|
||||
snapshot,
|
||||
0, /* num scan keys */
|
||||
NULL /* scan keys */
|
||||
snapshot,
|
||||
0, /* num scan keys */
|
||||
NULL /* scan keys */
|
||||
);
|
||||
}
|
||||
|
||||
|
@ -365,7 +365,7 @@ ExecTee(Tee *node, Plan *parent)
|
|||
HeapTuple throwAway;
|
||||
|
||||
/* Buffer buffer; */
|
||||
throwAway = heap_getnext(scanDesc,ScanDirectionIsBackward(dir));
|
||||
throwAway = heap_getnext(scanDesc, ScanDirectionIsBackward(dir));
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -406,7 +406,7 @@ ExecTee(Tee *node, Plan *parent)
|
|||
|
||||
result = ExecStoreTuple(heapTuple, /* tuple to store */
|
||||
slot, /* slot to store in */
|
||||
scanDesc->rs_cbuf, /* this tuple's buffer */
|
||||
scanDesc->rs_cbuf, /* this tuple's buffer */
|
||||
false); /* don't free stuff from
|
||||
* heap_getnext */
|
||||
|
||||
|
|
|
@ -47,8 +47,7 @@ static int _SPI_pquery(QueryDesc *queryDesc, EState *state, int tcount);
|
|||
static void _SPI_fetch(FetchStmt *stmt);
|
||||
|
||||
#endif
|
||||
static int
|
||||
_SPI_execute_plan(_SPI_plan *plan,
|
||||
static int _SPI_execute_plan(_SPI_plan *plan,
|
||||
Datum *Values, char *Nulls, int tcount);
|
||||
|
||||
#define _SPI_CPLAN_CURCXT 0
|
||||
|
@ -466,7 +465,7 @@ SPI_gettype(TupleDesc tupdesc, int fnumber)
|
|||
}
|
||||
|
||||
typeTuple = SearchSysCacheTuple(TYPOID,
|
||||
ObjectIdGetDatum(tupdesc->attrs[fnumber - 1]->atttypid),
|
||||
ObjectIdGetDatum(tupdesc->attrs[fnumber - 1]->atttypid),
|
||||
0, 0, 0);
|
||||
|
||||
if (!HeapTupleIsValid(typeTuple))
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/auth.c,v 1.30 1998/09/01 03:22:41 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/auth.c,v 1.31 1998/09/01 04:28:44 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -140,7 +140,7 @@ pg_krb4_recvauth(Port *port)
|
|||
return STATUS_ERROR;
|
||||
}
|
||||
|
||||
#endif /* KRB4 */
|
||||
#endif /* KRB4 */
|
||||
|
||||
|
||||
#ifdef KRB5
|
||||
|
@ -320,7 +320,7 @@ pg_krb5_recvauth(Port *port)
|
|||
return STATUS_ERROR;
|
||||
}
|
||||
|
||||
#endif /* KRB5 */
|
||||
#endif /* KRB5 */
|
||||
|
||||
|
||||
/*
|
||||
|
@ -422,7 +422,7 @@ be_recvauth(Port *port)
|
|||
*/
|
||||
|
||||
if (hba_getauthmethod(&port->raddr, port->user, port->database,
|
||||
port->auth_arg, &port->auth_method) != STATUS_OK)
|
||||
port->auth_arg, &port->auth_method) != STATUS_OK)
|
||||
PacketSendError(&port->pktInfo, "Missing or mis-configured pg_hba.conf file");
|
||||
|
||||
else if (PG_PROTOCOL_MAJOR(port->proto) == 0)
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.25 1998/09/01 03:22:44 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.26 1998/09/01 04:28:46 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This should be moved to a more appropriate place. It is here
|
||||
|
@ -370,22 +370,23 @@ lo_export(Oid lobjId, text *filename)
|
|||
|
||||
/*
|
||||
* lo_commit -
|
||||
* prepares large objects for transaction commit [PA, 7/17/98]
|
||||
* prepares large objects for transaction commit [PA, 7/17/98]
|
||||
*/
|
||||
void
|
||||
void
|
||||
_lo_commit(void)
|
||||
{
|
||||
int i;
|
||||
int i;
|
||||
MemoryContext currentContext;
|
||||
|
||||
if (fscxt == NULL)
|
||||
return;
|
||||
|
||||
|
||||
currentContext = MemoryContextSwitchTo((MemoryContext) fscxt);
|
||||
|
||||
for (i = 0; i < MAX_LOBJ_FDS; i++)
|
||||
{
|
||||
if (cookies[i] != NULL) inv_cleanindex(cookies[i]);
|
||||
if (cookies[i] != NULL)
|
||||
inv_cleanindex(cookies[i]);
|
||||
}
|
||||
|
||||
MemoryContextSwitchTo(currentContext);
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/hba.c,v 1.34 1998/09/01 03:22:46 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/hba.c,v 1.35 1998/09/01 04:28:48 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -161,7 +161,7 @@ process_hba_record(FILE *file, SockAddr *raddr, const char *user,
|
|||
/*---------------------------------------------------------------------------
|
||||
Process the non-comment record in the config file that is next on the file.
|
||||
See if it applies to a connection to a host with IP address "*raddr"
|
||||
to a database named "*database". If so, return *matches_p true
|
||||
to a database named "*database". If so, return *matches_p true
|
||||
and *userauth_p and *auth_arg as the values from the entry.
|
||||
If not, leave *matches_p as it was. If the record has a syntax error,
|
||||
return *error_p true, after issuing a message to stderr. If no error,
|
||||
|
@ -211,7 +211,7 @@ process_hba_record(FILE *file, SockAddr *raddr, const char *user,
|
|||
*/
|
||||
|
||||
if ((strcmp(db, database) != 0 && strcmp(db, "all") != 0 &&
|
||||
(strcmp(db, "sameuser") != 0 || strcmp(database, user) != 0)) ||
|
||||
(strcmp(db, "sameuser") != 0 || strcmp(database, user) != 0)) ||
|
||||
raddr->sa.sa_family != AF_UNIX)
|
||||
return;
|
||||
}
|
||||
|
@ -271,7 +271,7 @@ process_hba_record(FILE *file, SockAddr *raddr, const char *user,
|
|||
*/
|
||||
|
||||
if ((strcmp(db, database) != 0 && strcmp(db, "all") != 0 &&
|
||||
(strcmp(db, "sameuser") != 0 || strcmp(database, user) != 0)) ||
|
||||
(strcmp(db, "sameuser") != 0 || strcmp(database, user) != 0)) ||
|
||||
raddr->sa.sa_family != AF_INET ||
|
||||
((file_ip_addr.s_addr ^ raddr->in.sin_addr.s_addr) & mask.s_addr) != 0x0000)
|
||||
return;
|
||||
|
@ -679,7 +679,7 @@ parse_map_record(FILE *file,
|
|||
return;
|
||||
}
|
||||
}
|
||||
sprintf(PQerrormsg,"Incomplete line in pg_ident: %s",file_map);
|
||||
sprintf(PQerrormsg, "Incomplete line in pg_ident: %s", file_map);
|
||||
fputs(PQerrormsg, stderr);
|
||||
pqdebug("%s", PQerrormsg);
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/Attic/portal.c,v 1.16 1998/09/01 03:22:48 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/Attic/portal.c,v 1.17 1998/09/01 04:28:50 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -481,7 +481,7 @@ PQftype(PortalBuffer *portal, int tuple_index, int field_number)
|
|||
return -1;
|
||||
|
||||
if ((gbp = PQgroup(portal, tuple_index)) &&
|
||||
in_range("PQftype: field number", field_number, 0, gbp->no_fields))
|
||||
in_range("PQftype: field number", field_number, 0, gbp->no_fields))
|
||||
return gbp->types[field_number].typid;
|
||||
return -1;
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/pqcomm.c,v 1.52 1998/09/01 03:22:50 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/pqcomm.c,v 1.53 1998/09/01 04:28:51 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -60,8 +60,8 @@
|
|||
#if defined(linux)
|
||||
#ifndef SOMAXCONN
|
||||
#define SOMAXCONN 5 /* from Linux listen(2) man page */
|
||||
#endif /* SOMAXCONN */
|
||||
#endif /* linux */
|
||||
#endif /* SOMAXCONN */
|
||||
#endif /* linux */
|
||||
|
||||
#include "miscadmin.h"
|
||||
#include "libpq/pqsignal.h"
|
||||
|
@ -184,8 +184,9 @@ pq_getstr(char *s, int maxlen)
|
|||
int c = '\0';
|
||||
|
||||
#ifdef MULTIBYTE
|
||||
unsigned char *p, *ps;
|
||||
int len;
|
||||
unsigned char *p,
|
||||
*ps;
|
||||
int len;
|
||||
|
||||
ps = s;
|
||||
len = maxlen;
|
||||
|
@ -203,11 +204,12 @@ pq_getstr(char *s, int maxlen)
|
|||
|
||||
#ifdef MULTIBYTE
|
||||
p = pg_client_to_server(ps, len);
|
||||
if (ps != p) { /* actual conversion has been done? */
|
||||
strcpy(ps, p);
|
||||
if (ps != p)
|
||||
{ /* actual conversion has been done? */
|
||||
strcpy(ps, p);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/* -----------------
|
||||
* If EOF reached let caller know.
|
||||
* (This will only happen if we hit EOF before the string
|
||||
|
@ -344,12 +346,12 @@ void
|
|||
pq_putstr(char *s)
|
||||
{
|
||||
#ifdef MULTIBYTE
|
||||
unsigned char *p;
|
||||
unsigned char *p;
|
||||
|
||||
p = pg_server_to_client(s, strlen(s));
|
||||
p = pg_server_to_client(s, strlen(s));
|
||||
if (pqPutString(p, Pfout))
|
||||
#else
|
||||
if (pqPutString(s, Pfout))
|
||||
if (pqPutString(s, Pfout))
|
||||
#endif
|
||||
{
|
||||
sprintf(PQerrormsg,
|
||||
|
@ -555,16 +557,18 @@ StreamServerPort(char *hostName, short portName, int *fdP)
|
|||
strcpy(sock_path, saddr.un.sun_path);
|
||||
|
||||
/*
|
||||
* If the socket exists but nobody has an advisory lock on it
|
||||
* we can safely delete the file.
|
||||
* If the socket exists but nobody has an advisory lock on it we
|
||||
* can safely delete the file.
|
||||
*/
|
||||
if ((lock_fd = open(sock_path, O_RDONLY|O_NONBLOCK, 0666)) >= 0) {
|
||||
if (flock(lock_fd, LOCK_EX|LOCK_NB) == 0) {
|
||||
if ((lock_fd = open(sock_path, O_RDONLY | O_NONBLOCK, 0666)) >= 0)
|
||||
{
|
||||
if (flock(lock_fd, LOCK_EX | LOCK_NB) == 0)
|
||||
{
|
||||
TPRINTF(TRACE_VERBOSE, "flock on %s, deleting", sock_path);
|
||||
unlink(sock_path);
|
||||
} else {
|
||||
TPRINTF(TRACE_VERBOSE, "flock failed for %s", sock_path);
|
||||
}
|
||||
else
|
||||
TPRINTF(TRACE_VERBOSE, "flock failed for %s", sock_path);
|
||||
close(lock_fd);
|
||||
}
|
||||
}
|
||||
|
@ -584,8 +588,8 @@ StreamServerPort(char *hostName, short portName, int *fdP)
|
|||
strcat(PQerrormsg,
|
||||
"\tIs another postmaster already running on that port?\n");
|
||||
if (family == AF_UNIX)
|
||||
sprintf(PQerrormsg+strlen(PQerrormsg),
|
||||
"\tIf not, remove socket node (%s) and retry.\n",
|
||||
sprintf(PQerrormsg + strlen(PQerrormsg),
|
||||
"\tIf not, remove socket node (%s) and retry.\n",
|
||||
sock_path);
|
||||
else
|
||||
strcat(PQerrormsg, "\tIf not, wait a few seconds and retry.\n");
|
||||
|
@ -593,17 +597,18 @@ StreamServerPort(char *hostName, short portName, int *fdP)
|
|||
return STATUS_ERROR;
|
||||
}
|
||||
|
||||
if (family == AF_UNIX) {
|
||||
if (family == AF_UNIX)
|
||||
{
|
||||
on_proc_exit(StreamDoUnlink, NULL);
|
||||
|
||||
/*
|
||||
* Open the socket file and get an advisory lock on it.
|
||||
* The lock_fd is left open to keep the lock.
|
||||
* Open the socket file and get an advisory lock on it. The
|
||||
* lock_fd is left open to keep the lock.
|
||||
*/
|
||||
if ((lock_fd = open(sock_path, O_RDONLY|O_NONBLOCK, 0666)) >= 0) {
|
||||
if (flock(lock_fd, LOCK_EX|LOCK_NB) != 0) {
|
||||
if ((lock_fd = open(sock_path, O_RDONLY | O_NONBLOCK, 0666)) >= 0)
|
||||
{
|
||||
if (flock(lock_fd, LOCK_EX | LOCK_NB) != 0)
|
||||
TPRINTF(TRACE_VERBOSE, "flock error for %s", sock_path);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -775,12 +780,13 @@ StreamOpen(char *hostName, short portName, Port *port)
|
|||
void
|
||||
pq_putncharlen(char *s, int n)
|
||||
{
|
||||
unsigned char *p;
|
||||
int len;
|
||||
unsigned char *p;
|
||||
int len;
|
||||
|
||||
p = pg_server_to_client(s, n);
|
||||
len = strlen(p);
|
||||
pq_putint(len, sizeof(int));
|
||||
pq_putnchar(p, len);
|
||||
p = pg_server_to_client(s, n);
|
||||
len = strlen(p);
|
||||
pq_putint(len, sizeof(int));
|
||||
pq_putnchar(p, len);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/Attic/pqpacket.c,v 1.17 1998/08/25 21:22:27 scrappy Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/Attic/pqpacket.c,v 1.18 1998/09/01 04:28:53 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -118,7 +118,8 @@ PacketReceiveFragment(Packet *pkt, int sock)
|
|||
* Set up a packet write for the postmaster event loop.
|
||||
*/
|
||||
|
||||
void PacketSendSetup(Packet *pkt, int nbytes, PacketDoneProc iodone, void *arg)
|
||||
void
|
||||
PacketSendSetup(Packet *pkt, int nbytes, PacketDoneProc iodone, void *arg)
|
||||
{
|
||||
pkt->len = (PacketLen) nbytes;
|
||||
pkt->nrtodo = nbytes;
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/pqsignal.c,v 1.9 1998/09/01 03:22:52 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/libpq/pqsignal.c,v 1.10 1998/09/01 04:28:55 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This shouldn't be in libpq, but the monitor and some other
|
||||
|
@ -60,5 +60,5 @@ pqsignal(int signo, pqsigfunc func)
|
|||
if (sigaction(signo, &act, &oact) < 0)
|
||||
return SIG_ERR;
|
||||
return oact.sa_handler;
|
||||
#endif /* !USE_POSIX_SIGNALS */
|
||||
#endif /* !USE_POSIX_SIGNALS */
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/main/main.c,v 1.21 1998/06/15 19:28:28 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/main/main.c,v 1.22 1998/09/01 04:28:57 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -45,11 +45,11 @@ main(int argc, char *argv[])
|
|||
#ifdef NOFIXADE
|
||||
int buffer[] = {SSIN_UACPROC, UAC_SIGBUS};
|
||||
|
||||
#endif /* NOFIXADE */
|
||||
#endif /* NOFIXADE */
|
||||
#ifdef NOPRINTADE
|
||||
int buffer[] = {SSIN_UACPROC, UAC_NOPRINT};
|
||||
|
||||
#endif /* NOPRINTADE */
|
||||
#endif /* NOPRINTADE */
|
||||
#endif
|
||||
|
||||
#ifdef USE_LOCALE
|
||||
|
@ -75,7 +75,7 @@ main(int argc, char *argv[])
|
|||
elog(NOTICE, "setsysinfo failed: %d\n", errno);
|
||||
#endif
|
||||
|
||||
#endif /* NOFIXADE || NOPRINTADE */
|
||||
#endif /* NOFIXADE || NOPRINTADE */
|
||||
|
||||
/*
|
||||
* use one executable for both postgres and postmaster, invoke one or
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.47 1998/09/01 03:22:53 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.48 1998/09/01 04:29:00 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -999,9 +999,9 @@ _copyArrayRef(ArrayRef *from)
|
|||
** -- JMH, 8/2/93
|
||||
*/
|
||||
static RelOptInfo *
|
||||
_copyRelOptInfo(RelOptInfo *from)
|
||||
_copyRelOptInfo(RelOptInfo * from)
|
||||
{
|
||||
RelOptInfo *newnode = makeNode(RelOptInfo);
|
||||
RelOptInfo *newnode = makeNode(RelOptInfo);
|
||||
int i,
|
||||
len;
|
||||
|
||||
|
@ -1320,9 +1320,9 @@ _copyMergeOrder(MergeOrder *from)
|
|||
* ----------------
|
||||
*/
|
||||
static ClauseInfo *
|
||||
_copyClauseInfo(ClauseInfo *from)
|
||||
_copyClauseInfo(ClauseInfo * from)
|
||||
{
|
||||
ClauseInfo *newnode = makeNode(ClauseInfo);
|
||||
ClauseInfo *newnode = makeNode(ClauseInfo);
|
||||
|
||||
/* ----------------
|
||||
* copy remainder of node
|
||||
|
@ -1413,9 +1413,9 @@ _copyMInfo(MInfo *from)
|
|||
* ----------------
|
||||
*/
|
||||
static JoinInfo *
|
||||
_copyJoinInfo(JoinInfo *from)
|
||||
_copyJoinInfo(JoinInfo * from)
|
||||
{
|
||||
JoinInfo *newnode = makeNode(JoinInfo);
|
||||
JoinInfo *newnode = makeNode(JoinInfo);
|
||||
|
||||
/* ----------------
|
||||
* copy remainder of node
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.19 1998/09/01 03:22:55 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.20 1998/09/01 04:29:03 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -281,7 +281,7 @@ _equalFunc(Func *a, Func *b)
|
|||
* ClauseInfo is a subclass of Node.
|
||||
*/
|
||||
static bool
|
||||
_equalClauseInfo(ClauseInfo *a, ClauseInfo *b)
|
||||
_equalClauseInfo(ClauseInfo * a, ClauseInfo * b)
|
||||
{
|
||||
Assert(IsA(a, ClauseInfo));
|
||||
Assert(IsA(b, ClauseInfo));
|
||||
|
@ -306,7 +306,7 @@ _equalClauseInfo(ClauseInfo *a, ClauseInfo *b)
|
|||
* RelOptInfo is a subclass of Node.
|
||||
*/
|
||||
static bool
|
||||
_equalRelOptInfo(RelOptInfo *a, RelOptInfo *b)
|
||||
_equalRelOptInfo(RelOptInfo * a, RelOptInfo * b)
|
||||
{
|
||||
Assert(IsA(a, RelOptInfo));
|
||||
Assert(IsA(b, RelOptInfo));
|
||||
|
@ -530,7 +530,7 @@ _equalSubPlan(SubPlan *a, SubPlan *b)
|
|||
}
|
||||
|
||||
static bool
|
||||
_equalJoinInfo(JoinInfo *a, JoinInfo *b)
|
||||
_equalJoinInfo(JoinInfo * a, JoinInfo * b)
|
||||
{
|
||||
Assert(IsA(a, JoinInfo));
|
||||
Assert(IsA(b, JoinInfo));
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.14 1998/09/01 03:22:56 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.15 1998/09/01 04:29:05 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* XXX a few of the following functions are duplicated to handle
|
||||
|
@ -105,7 +105,7 @@ nconc(List *l1, List *l2)
|
|||
;
|
||||
|
||||
lnext(temp) = l2;
|
||||
return l1; /* list1 is now list1+list2 */
|
||||
return l1; /* list1 is now list1+list2 */
|
||||
}
|
||||
|
||||
|
||||
|
@ -305,10 +305,10 @@ LispUnion(List *l1, List *l2)
|
|||
List *j = NIL;
|
||||
|
||||
if (l1 == NIL)
|
||||
return l2; /* XXX - should be copy of l2 */
|
||||
return l2; /* XXX - should be copy of l2 */
|
||||
|
||||
if (l2 == NIL)
|
||||
return l1; /* XXX - should be copy of l1 */
|
||||
return l1; /* XXX - should be copy of l1 */
|
||||
|
||||
foreach(i, l1)
|
||||
{
|
||||
|
@ -335,10 +335,10 @@ LispUnioni(List *l1, List *l2)
|
|||
List *j = NIL;
|
||||
|
||||
if (l1 == NIL)
|
||||
return l2; /* XXX - should be copy of l2 */
|
||||
return l2; /* XXX - should be copy of l2 */
|
||||
|
||||
if (l2 == NIL)
|
||||
return l1; /* XXX - should be copy of l1 */
|
||||
return l1; /* XXX - should be copy of l1 */
|
||||
|
||||
foreach(i, l1)
|
||||
{
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.45 1998/09/01 03:22:59 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.46 1998/09/01 04:29:07 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Every (plan) node in POSTGRES has an associated "out" routine which
|
||||
|
@ -129,6 +129,7 @@ _outFuncCall(StringInfo str, FuncCall *node)
|
|||
appendStringInfo(str, " :args ");
|
||||
_outNode(str, node->args);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static void
|
||||
|
@ -660,7 +661,8 @@ _outResdom(StringInfo str, Resdom *node)
|
|||
sprintf(buf, " :restypmod %d ", node->restypmod);
|
||||
appendStringInfo(str, buf);
|
||||
appendStringInfo(str, " :resname ");
|
||||
sprintf(buf,"\"%s\"", node->resname); /* fix for SELECT col AS "my name" */
|
||||
sprintf(buf, "\"%s\"", node->resname); /* fix for SELECT col AS
|
||||
* "my name" */
|
||||
appendStringInfo(str, buf);
|
||||
sprintf(buf, " :reskey %d ", node->reskey);
|
||||
appendStringInfo(str, buf);
|
||||
|
@ -990,7 +992,7 @@ _outEState(StringInfo str, EState *node)
|
|||
* Stuff from relation.h
|
||||
*/
|
||||
static void
|
||||
_outRelOptInfo(StringInfo str, RelOptInfo *node)
|
||||
_outRelOptInfo(StringInfo str, RelOptInfo * node)
|
||||
{
|
||||
char buf[500];
|
||||
|
||||
|
@ -1356,7 +1358,7 @@ _outMergeOrder(StringInfo str, MergeOrder *node)
|
|||
* ClauseInfo is a subclass of Node.
|
||||
*/
|
||||
static void
|
||||
_outClauseInfo(StringInfo str, ClauseInfo *node)
|
||||
_outClauseInfo(StringInfo str, ClauseInfo * node)
|
||||
{
|
||||
char buf[500];
|
||||
|
||||
|
@ -1424,7 +1426,7 @@ _outHInfo(StringInfo str, HInfo *node)
|
|||
* JoinInfo is a subclass of Node.
|
||||
*/
|
||||
static void
|
||||
_outJoinInfo(StringInfo str, JoinInfo *node)
|
||||
_outJoinInfo(StringInfo str, JoinInfo * node)
|
||||
{
|
||||
appendStringInfo(str, " JINFO ");
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.17 1998/08/16 05:35:35 thomas Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.18 1998/09/01 04:29:10 momjian Exp $
|
||||
*
|
||||
* HISTORY
|
||||
* AUTHOR DATE MAJOR EVENT
|
||||
|
@ -201,7 +201,7 @@ print_expr(Node *expr, List *rtable)
|
|||
|
||||
print_expr((Node *) get_leftop(e), rtable);
|
||||
opname = get_opname(((Oper *) e->oper)->opno);
|
||||
printf(" %s ", ((opname != NULL)? opname: "(invalid operator)"));
|
||||
printf(" %s ", ((opname != NULL) ? opname : "(invalid operator)"));
|
||||
print_expr((Node *) get_rightop(e), rtable);
|
||||
}
|
||||
else
|
||||
|
@ -392,13 +392,16 @@ print_plan_recursive(Plan *p, Query *parsetree, int indentLevel, char *label)
|
|||
{
|
||||
List *lst;
|
||||
int whichplan = 0;
|
||||
Append *appendplan = (Append *)p;
|
||||
|
||||
Append *appendplan = (Append *) p;
|
||||
|
||||
foreach(lst, appendplan->appendplans)
|
||||
{
|
||||
Plan *subnode = (Plan *)lfirst(lst);
|
||||
Plan *subnode = (Plan *) lfirst(lst);
|
||||
|
||||
/* I don't think we need to fiddle with the range table here, bjm */
|
||||
/*
|
||||
* I don't think we need to fiddle with the range table here,
|
||||
* bjm
|
||||
*/
|
||||
print_plan_recursive(subnode, parsetree, indentLevel + 3, "a: ");
|
||||
|
||||
whichplan++;
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.36 1998/09/01 03:23:03 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.37 1998/09/01 04:29:12 momjian Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Most of the read functions for plan nodes are tested. (In fact, they
|
||||
|
@ -326,14 +326,14 @@ _readAppend()
|
|||
local_node->appendplans = nodeRead(true); /* now read it */
|
||||
|
||||
token = lsptok(NULL, &length); /* eat :unionrtables */
|
||||
local_node->unionrtables = nodeRead(true); /* now read it */
|
||||
local_node->unionrtables = nodeRead(true); /* now read it */
|
||||
|
||||
token = lsptok(NULL, &length); /* eat :inheritrelid */
|
||||
token = lsptok(NULL, &length); /* get inheritrelid */
|
||||
local_node->inheritrelid = strtoul(token, NULL, 10);
|
||||
|
||||
token = lsptok(NULL, &length); /* eat :inheritrtable */
|
||||
local_node->inheritrtable = nodeRead(true); /* now read it */
|
||||
local_node->inheritrtable = nodeRead(true); /* now read it */
|
||||
|
||||
return local_node;
|
||||
}
|
||||
|
@ -716,7 +716,7 @@ _readResdom()
|
|||
else
|
||||
{
|
||||
local_node->resname = (char *) palloc(length + 1);
|
||||
StrNCpy(local_node->resname, token+1, length + 1 - 2);/* strip quotes */
|
||||
StrNCpy(local_node->resname, token + 1, length + 1 - 2); /* strip quotes */
|
||||
}
|
||||
|
||||
token = lsptok(NULL, &length); /* eat :reskey */
|
||||
|
@ -1224,7 +1224,7 @@ _readEState()
|
|||
static RelOptInfo *
|
||||
_readRelOptInfo()
|
||||
{
|
||||
RelOptInfo *local_node;
|
||||
RelOptInfo *local_node;
|
||||
char *token;
|
||||
int length;
|
||||
|
||||
|
@ -1769,7 +1769,7 @@ _readMergeOrder()
|
|||
static ClauseInfo *
|
||||
_readClauseInfo()
|
||||
{
|
||||
ClauseInfo *local_node;
|
||||
ClauseInfo *local_node;
|
||||
char *token;
|
||||
int length;
|
||||
|
||||
|
@ -1867,7 +1867,7 @@ _readHInfo()
|
|||
static JoinInfo *
|
||||
_readJoinInfo()
|
||||
{
|
||||
JoinInfo *local_node;
|
||||
JoinInfo *local_node;
|
||||
char *token;
|
||||
int length;
|
||||
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_eval.c,v 1.23 1998/09/01 03:23:07 momjian Exp $
|
||||
* $Id: geqo_eval.c,v 1.24 1998/09/01 04:29:16 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -50,12 +50,12 @@
|
|||
#include "optimizer/geqo_paths.h"
|
||||
|
||||
|
||||
static List *gimme_clause_joins(Query *root, RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
static RelOptInfo *gimme_clauseless_join(RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
static RelOptInfo *init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo);
|
||||
static List *gimme_clause_joins(Query *root, RelOptInfo * outer_rel, RelOptInfo * inner_rel);
|
||||
static RelOptInfo *gimme_clauseless_join(RelOptInfo * outer_rel, RelOptInfo * inner_rel);
|
||||
static RelOptInfo *init_join_rel(RelOptInfo * outer_rel, RelOptInfo * inner_rel, JoinInfo * joininfo);
|
||||
static List *new_join_tlist(List *tlist, List *other_relids, int first_resdomno);
|
||||
static List *new_joininfo_list(List *joininfo_list, List *join_relids);
|
||||
static void geqo_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel);
|
||||
static void geqo_joinrel_size(RelOptInfo * joinrel, RelOptInfo * outer_rel, RelOptInfo * inner_rel);
|
||||
static RelOptInfo *geqo_nth(int stop, List *rels);
|
||||
|
||||
/*
|
||||
|
@ -66,7 +66,7 @@ static RelOptInfo *geqo_nth(int stop, List *rels);
|
|||
Cost
|
||||
geqo_eval(Query *root, Gene *tour, int num_gene)
|
||||
{
|
||||
RelOptInfo *joinrel;
|
||||
RelOptInfo *joinrel;
|
||||
Cost fitness;
|
||||
List *temp;
|
||||
|
||||
|
@ -99,13 +99,13 @@ geqo_eval(Query *root, Gene *tour, int num_gene)
|
|||
* Returns a new join relation incorporating all joins in a left-sided tree.
|
||||
*/
|
||||
RelOptInfo *
|
||||
gimme_tree(Query *root, Gene *tour, int rel_count, int num_gene, RelOptInfo *outer_rel)
|
||||
gimme_tree(Query *root, Gene *tour, int rel_count, int num_gene, RelOptInfo * outer_rel)
|
||||
{
|
||||
RelOptInfo *inner_rel; /* current relation */
|
||||
RelOptInfo *inner_rel; /* current relation */
|
||||
int base_rel_index;
|
||||
|
||||
List *new_rels = NIL;
|
||||
RelOptInfo *new_rel = NULL;
|
||||
RelOptInfo *new_rel = NULL;
|
||||
|
||||
if (rel_count < num_gene)
|
||||
{ /* tree not yet finished */
|
||||
|
@ -189,7 +189,7 @@ gimme_tree(Query *root, Gene *tour, int rel_count, int num_gene, RelOptInfo *out
|
|||
*/
|
||||
|
||||
static List *
|
||||
gimme_clause_joins(Query *root, RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
||||
gimme_clause_joins(Query *root, RelOptInfo * outer_rel, RelOptInfo * inner_rel)
|
||||
{
|
||||
List *join_list = NIL;
|
||||
List *i = NIL;
|
||||
|
@ -197,8 +197,8 @@ gimme_clause_joins(Query *root, RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
|||
|
||||
foreach(i, joininfo_list)
|
||||
{
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(i);
|
||||
RelOptInfo *rel = NULL;
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(i);
|
||||
RelOptInfo *rel = NULL;
|
||||
|
||||
if (!joininfo->inactive)
|
||||
{
|
||||
|
@ -240,7 +240,7 @@ gimme_clause_joins(Query *root, RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
|||
*/
|
||||
|
||||
static RelOptInfo *
|
||||
gimme_clauseless_join(RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
||||
gimme_clauseless_join(RelOptInfo * outer_rel, RelOptInfo * inner_rel)
|
||||
{
|
||||
return init_join_rel(outer_rel, inner_rel, (JoinInfo *) NULL);
|
||||
}
|
||||
|
@ -257,9 +257,9 @@ gimme_clauseless_join(RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
|||
* Returns the new join relation node.
|
||||
*/
|
||||
static RelOptInfo *
|
||||
init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo)
|
||||
init_join_rel(RelOptInfo * outer_rel, RelOptInfo * inner_rel, JoinInfo * joininfo)
|
||||
{
|
||||
RelOptInfo *joinrel = makeNode(RelOptInfo);
|
||||
RelOptInfo *joinrel = makeNode(RelOptInfo);
|
||||
List *joinrel_joininfo_list = NIL;
|
||||
List *new_outer_tlist;
|
||||
List *new_inner_tlist;
|
||||
|
@ -389,13 +389,13 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
|||
{
|
||||
List *current_joininfo_list = NIL;
|
||||
List *new_otherrels = NIL;
|
||||
JoinInfo *other_joininfo = (JoinInfo *) NULL;
|
||||
JoinInfo *other_joininfo = (JoinInfo *) NULL;
|
||||
List *xjoininfo = NIL;
|
||||
|
||||
foreach(xjoininfo, joininfo_list)
|
||||
{
|
||||
List *or;
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
new_otherrels = joininfo->otherrels;
|
||||
foreach(or, new_otherrels)
|
||||
|
@ -457,16 +457,16 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
List *xrel = NIL;
|
||||
List *xjoininfo = NIL;
|
||||
|
||||
RelOptInfo *rel;
|
||||
RelOptInfo *rel;
|
||||
List *relids;
|
||||
|
||||
List *super_rels;
|
||||
List *xsuper_rel = NIL;
|
||||
JoinInfo *new_joininfo;
|
||||
JoinInfo *new_joininfo;
|
||||
|
||||
foreach(xjoinrel, joinrels)
|
||||
{
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
|
||||
|
||||
foreach(xrelid, joinrel->relids)
|
||||
{
|
||||
|
@ -477,8 +477,8 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
*/
|
||||
|
||||
/*
|
||||
* ! BUG BUG ! Relid relid = (Relid)lfirst(xrelid); RelOptInfo *rel =
|
||||
* get_join_rel(root, relid);
|
||||
* ! BUG BUG ! Relid relid = (Relid)lfirst(xrelid); RelOptInfo
|
||||
* *rel = get_join_rel(root, relid);
|
||||
*/
|
||||
|
||||
/*
|
||||
|
@ -502,11 +502,11 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
}
|
||||
foreach(xjoinrel, joinrels)
|
||||
{
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
|
||||
|
||||
foreach(xjoininfo, joinrel->joininfo)
|
||||
{
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
List *other_rels = joininfo->otherrels;
|
||||
List *clause_info = joininfo->jinfoclauseinfo;
|
||||
bool mergejoinable = joininfo->mergejoinable;
|
||||
|
@ -516,8 +516,8 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
{
|
||||
|
||||
/*
|
||||
* ! BUG BUG ! Relid relid = (Relid)lfirst(xrelid); RelOptInfo
|
||||
* *rel = get_join_rel(root, relid);
|
||||
* ! BUG BUG ! Relid relid = (Relid)lfirst(xrelid);
|
||||
* RelOptInfo *rel = get_join_rel(root, relid);
|
||||
*/
|
||||
|
||||
/*
|
||||
|
@ -549,12 +549,12 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
|
||||
foreach(xsuper_rel, super_rels)
|
||||
{
|
||||
RelOptInfo *super_rel = (RelOptInfo *) lfirst(xsuper_rel);
|
||||
RelOptInfo *super_rel = (RelOptInfo *) lfirst(xsuper_rel);
|
||||
|
||||
if (nonoverlap_rels(super_rel, joinrel))
|
||||
{
|
||||
List *new_relids = super_rel->relids;
|
||||
JoinInfo *other_joininfo =
|
||||
JoinInfo *other_joininfo =
|
||||
joininfo_member(new_relids,
|
||||
joinrel->joininfo);
|
||||
|
||||
|
@ -566,7 +566,7 @@ geqo_add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
}
|
||||
else
|
||||
{
|
||||
JoinInfo *new_joininfo = makeNode(JoinInfo);
|
||||
JoinInfo *new_joininfo = makeNode(JoinInfo);
|
||||
|
||||
new_joininfo->otherrels = new_relids;
|
||||
new_joininfo->jinfoclauseinfo = clause_info;
|
||||
|
@ -611,13 +611,13 @@ geqo_final_join_rels(List *join_rel_list)
|
|||
*/
|
||||
foreach(xrel, join_rel_list)
|
||||
{
|
||||
RelOptInfo *rel = (RelOptInfo *) lfirst(xrel);
|
||||
RelOptInfo *rel = (RelOptInfo *) lfirst(xrel);
|
||||
List *xjoininfo = NIL;
|
||||
bool final = true;
|
||||
|
||||
foreach(xjoininfo, rel->joininfo)
|
||||
{
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
if (joininfo->otherrels != NIL)
|
||||
{
|
||||
|
@ -645,7 +645,7 @@ geqo_final_join_rels(List *join_rel_list)
|
|||
* Modifies the superrels field of rel
|
||||
*/
|
||||
static void
|
||||
add_superrels(RelOptInfo *rel, RelOptInfo *super_rel)
|
||||
add_superrels(RelOptInfo * rel, RelOptInfo * super_rel)
|
||||
{
|
||||
rel->superrels = lappend(rel->superrels, super_rel);
|
||||
}
|
||||
|
@ -660,7 +660,7 @@ add_superrels(RelOptInfo *rel, RelOptInfo *super_rel)
|
|||
* Returns non-nil if rel1 and rel2 do not overlap.
|
||||
*/
|
||||
static bool
|
||||
nonoverlap_rels(RelOptInfo *rel1, RelOptInfo *rel2)
|
||||
nonoverlap_rels(RelOptInfo * rel1, RelOptInfo * rel2)
|
||||
{
|
||||
return nonoverlap_sets(rel1->relids, rel2->relids);
|
||||
}
|
||||
|
@ -680,7 +680,7 @@ nonoverlap_sets(List *s1, List *s2)
|
|||
return true;
|
||||
}
|
||||
|
||||
#endif /* NOTUSED */
|
||||
#endif /* NOTUSED */
|
||||
|
||||
/*
|
||||
* geqo_joinrel_size--
|
||||
|
@ -688,7 +688,7 @@ nonoverlap_sets(List *s1, List *s2)
|
|||
* long join queries; so get logarithm of size when MAXINT overflow;
|
||||
*/
|
||||
static void
|
||||
geqo_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel)
|
||||
geqo_joinrel_size(RelOptInfo * joinrel, RelOptInfo * outer_rel, RelOptInfo * inner_rel)
|
||||
{
|
||||
Cost temp;
|
||||
int ntuples;
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_main.c,v 1.10 1998/09/01 03:23:09 momjian Exp $
|
||||
* $Id: geqo_main.c,v 1.11 1998/09/01 04:29:18 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -98,7 +98,7 @@ geqo(Query *root)
|
|||
status_interval;
|
||||
|
||||
Gene *best_tour;
|
||||
RelOptInfo *best_rel;
|
||||
RelOptInfo *best_rel;
|
||||
|
||||
/* Plan *best_plan; */
|
||||
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_misc.c,v 1.10 1998/09/01 03:23:10 momjian Exp $
|
||||
* $Id: geqo_misc.c,v 1.11 1998/09/01 04:29:19 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -146,7 +146,7 @@ geqo_print_joinclauses(Query *root, List *clauses)
|
|||
|
||||
foreach(l, clauses)
|
||||
{
|
||||
ClauseInfo *c = lfirst(l);
|
||||
ClauseInfo *c = lfirst(l);
|
||||
|
||||
print_expr((Node *) c->clause, root->rtable);
|
||||
if (lnext(l))
|
||||
|
@ -262,7 +262,7 @@ geqo_print_path(Query *root, Path *path, int indent)
|
|||
}
|
||||
|
||||
void
|
||||
geqo_print_rel(Query *root, RelOptInfo *rel)
|
||||
geqo_print_rel(Query *root, RelOptInfo * rel)
|
||||
{
|
||||
List *l;
|
||||
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: geqo_paths.c,v 1.11 1998/09/01 03:23:12 momjian Exp $
|
||||
* $Id: geqo_paths.c,v 1.12 1998/09/01 04:29:21 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -28,8 +28,8 @@
|
|||
#include "optimizer/geqo_paths.h"
|
||||
|
||||
|
||||
static List *geqo_prune_rel(RelOptInfo *rel, List *other_rels);
|
||||
static Path *set_paths(RelOptInfo *rel, Path *unorderedpath);
|
||||
static List *geqo_prune_rel(RelOptInfo * rel, List *other_rels);
|
||||
static Path *set_paths(RelOptInfo * rel, Path *unorderedpath);
|
||||
|
||||
/*
|
||||
* geqo-prune-rels--
|
||||
|
@ -47,8 +47,8 @@ geqo_prune_rels(List *rel_list)
|
|||
if (rel_list != NIL)
|
||||
{
|
||||
temp_list = lcons(lfirst(rel_list),
|
||||
geqo_prune_rels(geqo_prune_rel((RelOptInfo *) lfirst(rel_list),
|
||||
lnext(rel_list))));
|
||||
geqo_prune_rels(geqo_prune_rel((RelOptInfo *) lfirst(rel_list),
|
||||
lnext(rel_list))));
|
||||
}
|
||||
return temp_list;
|
||||
}
|
||||
|
@ -65,12 +65,12 @@ geqo_prune_rels(List *rel_list)
|
|||
*
|
||||
*/
|
||||
static List *
|
||||
geqo_prune_rel(RelOptInfo *rel, List *other_rels)
|
||||
geqo_prune_rel(RelOptInfo * rel, List *other_rels)
|
||||
{
|
||||
List *i = NIL;
|
||||
List *t_list = NIL;
|
||||
List *temp_node = NIL;
|
||||
RelOptInfo *other_rel = (RelOptInfo *) NULL;
|
||||
RelOptInfo *other_rel = (RelOptInfo *) NULL;
|
||||
|
||||
foreach(i, other_rels)
|
||||
{
|
||||
|
@ -102,7 +102,7 @@ geqo_prune_rel(RelOptInfo *rel, List *other_rels)
|
|||
*
|
||||
*/
|
||||
void
|
||||
geqo_rel_paths(RelOptInfo *rel)
|
||||
geqo_rel_paths(RelOptInfo * rel)
|
||||
{
|
||||
List *y = NIL;
|
||||
Path *path = (Path *) NULL;
|
||||
|
@ -134,7 +134,7 @@ geqo_rel_paths(RelOptInfo *rel)
|
|||
*
|
||||
*/
|
||||
static Path *
|
||||
set_paths(RelOptInfo *rel, Path *unorderedpath)
|
||||
set_paths(RelOptInfo * rel, Path *unorderedpath)
|
||||
{
|
||||
Path *cheapest = set_cheapest(rel, rel->pathlist);
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/geqo/Attic/minspantree.c,v 1.7 1998/08/10 02:26:19 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/geqo/Attic/minspantree.c,v 1.8 1998/09/01 04:29:24 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -41,7 +41,7 @@
|
|||
*/
|
||||
|
||||
void
|
||||
minspantree(Query *root, List *join_rels, RelOptInfo *garel)
|
||||
minspantree(Query *root, List *join_rels, RelOptInfo * garel)
|
||||
{
|
||||
int number_of_rels = length(root->base_rel_list);
|
||||
int number_of_joins = length(join_rels);
|
||||
|
@ -70,8 +70,8 @@ minspantree(Query *root, List *join_rels, RelOptInfo *garel)
|
|||
id1,
|
||||
id2;
|
||||
List *r = NIL;
|
||||
RelOptInfo *joinrel = NULL;
|
||||
RelOptInfo **tmprel_array;
|
||||
RelOptInfo *joinrel = NULL;
|
||||
RelOptInfo **tmprel_array;
|
||||
|
||||
|
||||
/* allocate memory for matrix tmprel_array[x][y] */
|
||||
|
@ -111,9 +111,9 @@ minspantree(Query *root, List *join_rels, RelOptInfo *garel)
|
|||
|
||||
else if (number_of_joins == 3)
|
||||
{
|
||||
RelOptInfo *rel12 = (RelOptInfo *) &tmprel_array[1][2];
|
||||
RelOptInfo *rel13 = (RelOptInfo *) &tmprel_array[1][3];
|
||||
RelOptInfo *rel23 = (RelOptInfo *) &tmprel_array[2][3];
|
||||
RelOptInfo *rel12 = (RelOptInfo *) & tmprel_array[1][2];
|
||||
RelOptInfo *rel13 = (RelOptInfo *) & tmprel_array[1][3];
|
||||
RelOptInfo *rel23 = (RelOptInfo *) & tmprel_array[2][3];
|
||||
|
||||
if (rel12->cheapestpath->path_cost > rel13->cheapestpath->path_cost)
|
||||
{
|
||||
|
@ -159,9 +159,9 @@ minspantree(Query *root, List *join_rels, RelOptInfo *garel)
|
|||
if (connectto[tempn] != 0)
|
||||
{
|
||||
if (n > tempn)
|
||||
joinrel = (RelOptInfo *) &tmprel_array[tempn][n];
|
||||
joinrel = (RelOptInfo *) & tmprel_array[tempn][n];
|
||||
else
|
||||
joinrel = (RelOptInfo *) &tmprel_array[n][tempn];
|
||||
joinrel = (RelOptInfo *) & tmprel_array[n][tempn];
|
||||
dist = joinrel->cheapestpath->path_cost;
|
||||
|
||||
if (dist < disttoconnect[tempn])
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.22 1998/09/01 03:23:17 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.23 1998/09/01 04:29:27 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -45,8 +45,10 @@ int32 _use_geqo_rels_ = GEQO_RELS;
|
|||
|
||||
static void find_rel_paths(Query *root, List *rels);
|
||||
static List *find_join_paths(Query *root, List *outer_rels, int levels_needed);
|
||||
|
||||
#ifdef OPTIMIZER_DEBUG
|
||||
static void debug_print_rel(Query *root, RelOptInfo *rel);
|
||||
static void debug_print_rel(Query *root, RelOptInfo * rel);
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
@ -76,6 +78,7 @@ find_paths(Query *root, List *rels)
|
|||
|
||||
if (levels_needed <= 1)
|
||||
{
|
||||
|
||||
/*
|
||||
* Unsorted single relation, no more processing is required.
|
||||
*/
|
||||
|
@ -83,6 +86,7 @@ find_paths(Query *root, List *rels)
|
|||
}
|
||||
else
|
||||
{
|
||||
|
||||
/*
|
||||
* this means that joins or sorts are required. set selectivities
|
||||
* of clauses that have not been set by an index.
|
||||
|
@ -118,10 +122,10 @@ find_rel_paths(Query *root, List *rels)
|
|||
sequential_scan_list = lcons(create_seqscan_path(rel), NIL);
|
||||
|
||||
rel_index_scan_list = find_index_paths(root,
|
||||
rel,
|
||||
find_relation_indices(root, rel),
|
||||
rel->clauseinfo,
|
||||
rel->joininfo);
|
||||
rel,
|
||||
find_relation_indices(root, rel),
|
||||
rel->clauseinfo,
|
||||
rel->joininfo);
|
||||
|
||||
or_index_scan_list = create_or_index_paths(root, rel, rel->clauseinfo);
|
||||
|
||||
|
@ -180,7 +184,8 @@ find_join_paths(Query *root, List *outer_rels, int levels_needed)
|
|||
*******************************************/
|
||||
|
||||
if ((_use_geqo_) && length(root->base_rel_list) >= _use_geqo_rels_)
|
||||
return lcons(geqo(root), NIL); /* returns *one* RelOptInfo, so lcons it */
|
||||
return lcons(geqo(root), NIL); /* returns *one* RelOptInfo, so
|
||||
* lcons it */
|
||||
|
||||
/*******************************************
|
||||
* rest will be deprecated in case of GEQO *
|
||||
|
@ -280,7 +285,7 @@ print_joinclauses(Query *root, List *clauses)
|
|||
|
||||
foreach(l, clauses)
|
||||
{
|
||||
ClauseInfo *c = lfirst(l);
|
||||
ClauseInfo *c = lfirst(l);
|
||||
|
||||
print_expr((Node *) c->clause, root->rtable);
|
||||
if (lnext(l))
|
||||
|
@ -396,7 +401,7 @@ print_path(Query *root, Path *path, int indent)
|
|||
}
|
||||
|
||||
static void
|
||||
debug_print_rel(Query *root, RelOptInfo *rel)
|
||||
debug_print_rel(Query *root, RelOptInfo * rel)
|
||||
{
|
||||
List *l;
|
||||
|
||||
|
@ -412,4 +417,4 @@ debug_print_rel(Query *root, RelOptInfo *rel)
|
|||
print_path(root, rel->cheapestpath, 1);
|
||||
}
|
||||
|
||||
#endif /* OPTIMIZER_DEBUG */
|
||||
#endif /* OPTIMIZER_DEBUG */
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.12 1998/09/01 03:23:19 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.13 1998/09/01 04:29:29 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -46,7 +46,7 @@ void
|
|||
set_clause_selectivities(List *clauseinfo_list, Cost new_selectivity)
|
||||
{
|
||||
List *temp;
|
||||
ClauseInfo *clausenode;
|
||||
ClauseInfo *clausenode;
|
||||
Cost cost_clause;
|
||||
|
||||
foreach(temp, clauseinfo_list)
|
||||
|
@ -95,7 +95,7 @@ product_selec(List *clauseinfo_list)
|
|||
void
|
||||
set_rest_relselec(Query *root, List *rel_list)
|
||||
{
|
||||
RelOptInfo *rel;
|
||||
RelOptInfo *rel;
|
||||
List *x;
|
||||
|
||||
foreach(x, rel_list)
|
||||
|
@ -117,7 +117,7 @@ void
|
|||
set_rest_selec(Query *root, List *clauseinfo_list)
|
||||
{
|
||||
List *temp = NIL;
|
||||
ClauseInfo *clausenode = (ClauseInfo *) NULL;
|
||||
ClauseInfo *clausenode = (ClauseInfo *) NULL;
|
||||
Cost cost_clause;
|
||||
|
||||
foreach(temp, clauseinfo_list)
|
||||
|
@ -159,8 +159,8 @@ set_rest_selec(Query *root, List *clauseinfo_list)
|
|||
Cost
|
||||
compute_clause_selec(Query *root, Node *clause, List *or_selectivities)
|
||||
{
|
||||
if (is_opclause(clause))
|
||||
return compute_selec(root, lcons(clause,NIL), or_selectivities);
|
||||
if (is_opclause(clause))
|
||||
return compute_selec(root, lcons(clause, NIL), or_selectivities);
|
||||
else if (not_clause(clause))
|
||||
{
|
||||
|
||||
|
@ -182,9 +182,7 @@ compute_clause_selec(Query *root, Node *clause, List *or_selectivities)
|
|||
return compute_selec(root, ((Expr *) clause)->args, or_selectivities);
|
||||
}
|
||||
else
|
||||
{
|
||||
return compute_selec(root, lcons(clause, NIL), or_selectivities);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.24 1998/09/01 03:23:20 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.25 1998/09/01 04:29:30 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -360,7 +360,7 @@ cost_hashjoin(Cost outercost,
|
|||
* Returns the size.
|
||||
*/
|
||||
int
|
||||
compute_rel_size(RelOptInfo *rel)
|
||||
compute_rel_size(RelOptInfo * rel)
|
||||
{
|
||||
Cost temp;
|
||||
int temp1;
|
||||
|
@ -383,7 +383,7 @@ compute_rel_size(RelOptInfo *rel)
|
|||
* Returns the width of the tuple as a fixnum.
|
||||
*/
|
||||
int
|
||||
compute_rel_width(RelOptInfo *rel)
|
||||
compute_rel_width(RelOptInfo * rel)
|
||||
{
|
||||
return compute_targetlist_width(get_actual_tlist(rel->targetlist));
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/hashutils.c,v 1.6 1998/09/01 03:23:22 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/hashutils.c,v 1.7 1998/09/01 04:29:32 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -39,7 +39,7 @@ group_clauses_by_hashop(List *clauseinfo_list,
|
|||
int inner_relid)
|
||||
{
|
||||
List *hashinfo_list = NIL;
|
||||
ClauseInfo *clauseinfo = (ClauseInfo *) NULL;
|
||||
ClauseInfo *clauseinfo = (ClauseInfo *) NULL;
|
||||
List *i = NIL;
|
||||
Oid hashjoinop = 0;
|
||||
|
||||
|
@ -121,7 +121,7 @@ match_hashop_hashinfo(Oid hashop, List *hashinfo_list)
|
|||
key = xhashinfo->hashop;
|
||||
if (hashop == key)
|
||||
{ /* found */
|
||||
return xhashinfo; /* should be a hashinfo node ! */
|
||||
return xhashinfo; /* should be a hashinfo node ! */
|
||||
}
|
||||
}
|
||||
return (HInfo *) NIL;
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.33 1998/09/01 03:23:23 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.34 1998/09/01 04:29:33 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -41,46 +41,36 @@
|
|||
#include "parser/parsetree.h" /* for getrelid() */
|
||||
#include "parser/parse_expr.h" /* for exprType() */
|
||||
#include "parser/parse_oper.h" /* for oprid() and oper() */
|
||||
#include "parser/parse_coerce.h" /* for IS_BINARY_COMPATIBLE() */
|
||||
#include "parser/parse_coerce.h"/* for IS_BINARY_COMPATIBLE() */
|
||||
#include "utils/lsyscache.h"
|
||||
|
||||
|
||||
static void
|
||||
match_index_orclauses(RelOptInfo *rel, RelOptInfo *index, int indexkey,
|
||||
static void match_index_orclauses(RelOptInfo * rel, RelOptInfo * index, int indexkey,
|
||||
int xclass, List *clauseinfo_list);
|
||||
static bool
|
||||
match_index_to_operand(int indexkey, Expr *operand,
|
||||
RelOptInfo *rel, RelOptInfo *index);
|
||||
static List *
|
||||
match_index_orclause(RelOptInfo *rel, RelOptInfo *index, int indexkey,
|
||||
static bool match_index_to_operand(int indexkey, Expr *operand,
|
||||
RelOptInfo * rel, RelOptInfo * index);
|
||||
static List *match_index_orclause(RelOptInfo * rel, RelOptInfo * index, int indexkey,
|
||||
int xclass, List *or_clauses, List *other_matching_indices);
|
||||
static List *
|
||||
group_clauses_by_indexkey(RelOptInfo *rel, RelOptInfo *index,
|
||||
static List *group_clauses_by_indexkey(RelOptInfo * rel, RelOptInfo * index,
|
||||
int *indexkeys, Oid *classes, List *clauseinfo_list);
|
||||
static List *
|
||||
group_clauses_by_ikey_for_joins(RelOptInfo *rel, RelOptInfo *index,
|
||||
static List *group_clauses_by_ikey_for_joins(RelOptInfo * rel, RelOptInfo * index,
|
||||
int *indexkeys, Oid *classes, List *join_cinfo_list, List *restr_cinfo_list);
|
||||
static ClauseInfo *
|
||||
match_clause_to_indexkey(RelOptInfo *rel, RelOptInfo *index, int indexkey,
|
||||
int xclass, ClauseInfo *clauseInfo, bool join);
|
||||
static bool
|
||||
pred_test(List *predicate_list, List *clauseinfo_list,
|
||||
static ClauseInfo *match_clause_to_indexkey(RelOptInfo * rel, RelOptInfo * index, int indexkey,
|
||||
int xclass, ClauseInfo * clauseInfo, bool join);
|
||||
static bool pred_test(List *predicate_list, List *clauseinfo_list,
|
||||
List *joininfo_list);
|
||||
static bool one_pred_test(Expr *predicate, List *clauseinfo_list);
|
||||
static bool one_pred_clause_expr_test(Expr *predicate, Node *clause);
|
||||
static bool one_pred_clause_test(Expr *predicate, Node *clause);
|
||||
static bool clause_pred_clause_test(Expr *predicate, Node *clause);
|
||||
static List *
|
||||
indexable_joinclauses(RelOptInfo *rel, RelOptInfo *index,
|
||||
static List *indexable_joinclauses(RelOptInfo * rel, RelOptInfo * index,
|
||||
List *joininfo_list, List *clauseinfo_list);
|
||||
static List *
|
||||
index_innerjoin(Query *root, RelOptInfo *rel,
|
||||
List *clausegroup_list, RelOptInfo *index);
|
||||
static List *
|
||||
create_index_paths(Query *root, RelOptInfo *rel, RelOptInfo *index,
|
||||
static List *index_innerjoin(Query *root, RelOptInfo * rel,
|
||||
List *clausegroup_list, RelOptInfo * index);
|
||||
static List *create_index_paths(Query *root, RelOptInfo * rel, RelOptInfo * index,
|
||||
List *clausegroup_list, bool join);
|
||||
static List *add_index_paths(List *indexpaths, List *new_indexpaths);
|
||||
static bool function_index_operand(Expr *funcOpnd, RelOptInfo *rel, RelOptInfo *index);
|
||||
static bool function_index_operand(Expr *funcOpnd, RelOptInfo * rel, RelOptInfo * index);
|
||||
|
||||
|
||||
/* find_index_paths()
|
||||
|
@ -110,14 +100,14 @@ static bool function_index_operand(Expr *funcOpnd, RelOptInfo *rel, RelOptInfo *
|
|||
*/
|
||||
List *
|
||||
find_index_paths(Query *root,
|
||||
RelOptInfo *rel,
|
||||
RelOptInfo * rel,
|
||||
List *indices,
|
||||
List *clauseinfo_list,
|
||||
List *joininfo_list)
|
||||
{
|
||||
List *scanclausegroups = NIL;
|
||||
List *scanpaths = NIL;
|
||||
RelOptInfo *index = (RelOptInfo *) NULL;
|
||||
RelOptInfo *index = (RelOptInfo *) NULL;
|
||||
List *joinclausegroups = NIL;
|
||||
List *joinpaths = NIL;
|
||||
List *retval = NIL;
|
||||
|
@ -127,7 +117,10 @@ find_index_paths(Query *root,
|
|||
{
|
||||
index = (RelOptInfo *) lfirst(ilist);
|
||||
|
||||
/* If this is a partial index, return if it fails the predicate test */
|
||||
/*
|
||||
* If this is a partial index, return if it fails the predicate
|
||||
* test
|
||||
*/
|
||||
if (index->indpred != NIL)
|
||||
if (!pred_test(index->indpred, clauseinfo_list, joininfo_list))
|
||||
continue;
|
||||
|
@ -136,20 +129,20 @@ find_index_paths(Query *root,
|
|||
* 1. Try matching the index against subclauses of an 'or' clause.
|
||||
* The fields of the clauseinfo nodes are marked with lists of the
|
||||
* matching indices. No path are actually created. We currently
|
||||
* only look to match the first key. We don't find multi-key index
|
||||
* cases where an AND matches the first key, and the OR matches the
|
||||
* second key.
|
||||
* only look to match the first key. We don't find multi-key
|
||||
* index cases where an AND matches the first key, and the OR
|
||||
* matches the second key.
|
||||
*/
|
||||
match_index_orclauses(rel,
|
||||
index,
|
||||
index->indexkeys[0],
|
||||
index->classlist[0],
|
||||
clauseinfo_list);
|
||||
index,
|
||||
index->indexkeys[0],
|
||||
index->classlist[0],
|
||||
clauseinfo_list);
|
||||
|
||||
/*
|
||||
* 2. If the keys of this index match any of the available restriction
|
||||
* clauses, then create pathnodes corresponding to each group of
|
||||
* usable clauses.
|
||||
* 2. If the keys of this index match any of the available
|
||||
* restriction clauses, then create pathnodes corresponding to
|
||||
* each group of usable clauses.
|
||||
*/
|
||||
scanclausegroups = group_clauses_by_indexkey(rel,
|
||||
index,
|
||||
|
@ -167,10 +160,10 @@ find_index_paths(Query *root,
|
|||
|
||||
/*
|
||||
* 3. If this index can be used with any join clause, then create
|
||||
* pathnodes for each group of usable clauses. An index can be used
|
||||
* with a join clause if its ordering is useful for a mergejoin, or if
|
||||
* the index can possibly be used for scanning the inner relation of a
|
||||
* nestloop join.
|
||||
* pathnodes for each group of usable clauses. An index can be
|
||||
* used with a join clause if its ordering is useful for a
|
||||
* mergejoin, or if the index can possibly be used for scanning
|
||||
* the inner relation of a nestloop join.
|
||||
*/
|
||||
joinclausegroups = indexable_joinclauses(rel, index, joininfo_list, clauseinfo_list);
|
||||
joinpaths = NIL;
|
||||
|
@ -179,7 +172,7 @@ find_index_paths(Query *root,
|
|||
{
|
||||
List *new_join_paths = create_index_paths(root, rel,
|
||||
index,
|
||||
joinclausegroups,
|
||||
joinclausegroups,
|
||||
true);
|
||||
List *innerjoin_paths = index_innerjoin(root, rel, joinclausegroups, index);
|
||||
|
||||
|
@ -225,13 +218,13 @@ find_index_paths(Query *root,
|
|||
*
|
||||
*/
|
||||
static void
|
||||
match_index_orclauses(RelOptInfo *rel,
|
||||
RelOptInfo *index,
|
||||
match_index_orclauses(RelOptInfo * rel,
|
||||
RelOptInfo * index,
|
||||
int indexkey,
|
||||
int xclass,
|
||||
List *clauseinfo_list)
|
||||
{
|
||||
ClauseInfo *clauseinfo = (ClauseInfo *) NULL;
|
||||
ClauseInfo *clauseinfo = (ClauseInfo *) NULL;
|
||||
List *i = NIL;
|
||||
|
||||
foreach(i, clauseinfo_list)
|
||||
|
@ -262,10 +255,10 @@ match_index_orclauses(RelOptInfo *rel,
|
|||
static bool
|
||||
match_index_to_operand(int indexkey,
|
||||
Expr *operand,
|
||||
RelOptInfo *rel,
|
||||
RelOptInfo *index)
|
||||
RelOptInfo * rel,
|
||||
RelOptInfo * index)
|
||||
{
|
||||
bool result;
|
||||
bool result;
|
||||
|
||||
/*
|
||||
* Normal index.
|
||||
|
@ -305,8 +298,8 @@ match_index_to_operand(int indexkey,
|
|||
* match the third, g,h match the fourth, etc.
|
||||
*/
|
||||
static List *
|
||||
match_index_orclause(RelOptInfo *rel,
|
||||
RelOptInfo *index,
|
||||
match_index_orclause(RelOptInfo * rel,
|
||||
RelOptInfo * index,
|
||||
int indexkey,
|
||||
int xclass,
|
||||
List *or_clauses,
|
||||
|
@ -323,30 +316,29 @@ match_index_orclause(RelOptInfo *rel,
|
|||
foreach(clist, or_clauses)
|
||||
matching_indices = lcons(NIL, matching_indices);
|
||||
}
|
||||
else matching_indices = other_matching_indices;
|
||||
else
|
||||
matching_indices = other_matching_indices;
|
||||
|
||||
index_list = matching_indices;
|
||||
|
||||
foreach(clist, or_clauses)
|
||||
{
|
||||
clause = lfirst(clist);
|
||||
|
||||
|
||||
if (is_opclause(clause) &&
|
||||
op_class(((Oper *) ((Expr *) clause)->oper)->opno,
|
||||
xclass, index->relam) &&
|
||||
((match_index_to_operand(indexkey,
|
||||
(Expr *) get_leftop((Expr *) clause),
|
||||
rel,
|
||||
index) &&
|
||||
(Expr *) get_leftop((Expr *) clause),
|
||||
rel,
|
||||
index) &&
|
||||
IsA(get_rightop((Expr *) clause), Const)) ||
|
||||
(match_index_to_operand(indexkey,
|
||||
(Expr *) get_rightop((Expr *) clause),
|
||||
rel,
|
||||
index) &&
|
||||
IsA(get_leftop((Expr *) clause), Const))))
|
||||
{
|
||||
rel,
|
||||
index) &&
|
||||
IsA(get_leftop((Expr *) clause), Const))))
|
||||
lfirst(matching_indices) = lcons(index, lfirst(matching_indices));
|
||||
}
|
||||
|
||||
matching_indices = lnext(matching_indices);
|
||||
}
|
||||
|
@ -396,14 +388,14 @@ match_index_orclause(RelOptInfo *rel,
|
|||
*
|
||||
*/
|
||||
static List *
|
||||
group_clauses_by_indexkey(RelOptInfo *rel,
|
||||
RelOptInfo *index,
|
||||
group_clauses_by_indexkey(RelOptInfo * rel,
|
||||
RelOptInfo * index,
|
||||
int *indexkeys,
|
||||
Oid *classes,
|
||||
List *clauseinfo_list)
|
||||
{
|
||||
List *curCinfo = NIL;
|
||||
ClauseInfo *matched_clause = (ClauseInfo *) NULL;
|
||||
ClauseInfo *matched_clause = (ClauseInfo *) NULL;
|
||||
List *clausegroup = NIL;
|
||||
int curIndxKey;
|
||||
Oid curClass;
|
||||
|
@ -420,7 +412,7 @@ group_clauses_by_indexkey(RelOptInfo *rel,
|
|||
|
||||
foreach(curCinfo, clauseinfo_list)
|
||||
{
|
||||
ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
|
||||
ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
|
||||
|
||||
matched_clause = match_clause_to_indexkey(rel,
|
||||
index,
|
||||
|
@ -458,15 +450,15 @@ group_clauses_by_indexkey(RelOptInfo *rel,
|
|||
*
|
||||
*/
|
||||
static List *
|
||||
group_clauses_by_ikey_for_joins(RelOptInfo *rel,
|
||||
RelOptInfo *index,
|
||||
group_clauses_by_ikey_for_joins(RelOptInfo * rel,
|
||||
RelOptInfo * index,
|
||||
int *indexkeys,
|
||||
Oid *classes,
|
||||
List *join_cinfo_list,
|
||||
List *restr_cinfo_list)
|
||||
{
|
||||
List *curCinfo = NIL;
|
||||
ClauseInfo *matched_clause = (ClauseInfo *) NULL;
|
||||
ClauseInfo *matched_clause = (ClauseInfo *) NULL;
|
||||
List *clausegroup = NIL;
|
||||
int curIndxKey;
|
||||
Oid curClass;
|
||||
|
@ -484,7 +476,7 @@ group_clauses_by_ikey_for_joins(RelOptInfo *rel,
|
|||
|
||||
foreach(curCinfo, join_cinfo_list)
|
||||
{
|
||||
ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
|
||||
ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
|
||||
|
||||
matched_clause = match_clause_to_indexkey(rel,
|
||||
index,
|
||||
|
@ -500,7 +492,7 @@ group_clauses_by_ikey_for_joins(RelOptInfo *rel,
|
|||
}
|
||||
foreach(curCinfo, restr_cinfo_list)
|
||||
{
|
||||
ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
|
||||
ClauseInfo *temp = (ClauseInfo *) lfirst(curCinfo);
|
||||
|
||||
matched_clause = match_clause_to_indexkey(rel,
|
||||
index,
|
||||
|
@ -580,11 +572,11 @@ group_clauses_by_ikey_for_joins(RelOptInfo *rel,
|
|||
*
|
||||
*/
|
||||
static ClauseInfo *
|
||||
match_clause_to_indexkey(RelOptInfo *rel,
|
||||
RelOptInfo *index,
|
||||
match_clause_to_indexkey(RelOptInfo * rel,
|
||||
RelOptInfo * index,
|
||||
int indexkey,
|
||||
int xclass,
|
||||
ClauseInfo *clauseInfo,
|
||||
ClauseInfo * clauseInfo,
|
||||
bool join)
|
||||
{
|
||||
Expr *clause = clauseInfo->clause;
|
||||
|
@ -607,6 +599,7 @@ match_clause_to_indexkey(RelOptInfo *rel,
|
|||
*/
|
||||
if (!join)
|
||||
{
|
||||
|
||||
/*
|
||||
* Check for standard s-argable clause
|
||||
*/
|
||||
|
@ -622,24 +615,28 @@ match_clause_to_indexkey(RelOptInfo *rel,
|
|||
index));
|
||||
|
||||
#ifndef IGNORE_BINARY_COMPATIBLE_INDICES
|
||||
/* Didn't find an index?
|
||||
* Then maybe we can find another binary-compatible index instead...
|
||||
* thomas 1998-08-14
|
||||
|
||||
/*
|
||||
* Didn't find an index? Then maybe we can find another
|
||||
* binary-compatible index instead... thomas 1998-08-14
|
||||
*/
|
||||
if (! isIndexable)
|
||||
if (!isIndexable)
|
||||
{
|
||||
Oid ltype;
|
||||
Oid rtype;
|
||||
Oid ltype;
|
||||
Oid rtype;
|
||||
|
||||
ltype = exprType((Node *)leftop);
|
||||
rtype = exprType((Node *)rightop);
|
||||
ltype = exprType((Node *) leftop);
|
||||
rtype = exprType((Node *) rightop);
|
||||
|
||||
/* make sure we have two different binary-compatible types... */
|
||||
/*
|
||||
* make sure we have two different binary-compatible
|
||||
* types...
|
||||
*/
|
||||
if ((ltype != rtype)
|
||||
&& IS_BINARY_COMPATIBLE(ltype, rtype))
|
||||
&& IS_BINARY_COMPATIBLE(ltype, rtype))
|
||||
{
|
||||
char *opname;
|
||||
Operator newop;
|
||||
char *opname;
|
||||
Operator newop;
|
||||
|
||||
opname = get_opname(restrict_op);
|
||||
if (opname != NULL)
|
||||
|
@ -660,9 +657,7 @@ match_clause_to_indexkey(RelOptInfo *rel,
|
|||
index));
|
||||
|
||||
if (isIndexable)
|
||||
{
|
||||
((Oper *) ((Expr *) clause)->oper)->opno = restrict_op;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -679,24 +674,24 @@ match_clause_to_indexkey(RelOptInfo *rel,
|
|||
get_commutator(((Oper *) ((Expr *) clause)->oper)->opno);
|
||||
|
||||
isIndexable = ((restrict_op != InvalidOid) &&
|
||||
op_class(restrict_op, xclass, index->relam) &&
|
||||
IndexScanableOperand(rightop,
|
||||
indexkey, rel, index));
|
||||
op_class(restrict_op, xclass, index->relam) &&
|
||||
IndexScanableOperand(rightop,
|
||||
indexkey, rel, index));
|
||||
|
||||
#ifndef IGNORE_BINARY_COMPATIBLE_INDICES
|
||||
if (! isIndexable)
|
||||
if (!isIndexable)
|
||||
{
|
||||
Oid ltype;
|
||||
Oid rtype;
|
||||
Oid ltype;
|
||||
Oid rtype;
|
||||
|
||||
ltype = exprType((Node *)leftop);
|
||||
rtype = exprType((Node *)rightop);
|
||||
ltype = exprType((Node *) leftop);
|
||||
rtype = exprType((Node *) rightop);
|
||||
|
||||
if ((ltype != rtype)
|
||||
&& IS_BINARY_COMPATIBLE(ltype, rtype))
|
||||
&& IS_BINARY_COMPATIBLE(ltype, rtype))
|
||||
{
|
||||
char *opname;
|
||||
Operator newop;
|
||||
char *opname;
|
||||
Operator newop;
|
||||
|
||||
restrict_op = ((Oper *) ((Expr *) clause)->oper)->opno;
|
||||
|
||||
|
@ -712,16 +707,14 @@ match_clause_to_indexkey(RelOptInfo *rel,
|
|||
get_commutator(oprid(newop));
|
||||
|
||||
isIndexable = ((restrict_op != InvalidOid) &&
|
||||
op_class(restrict_op, xclass, index->relam) &&
|
||||
IndexScanableOperand(rightop,
|
||||
indexkey,
|
||||
rel,
|
||||
index));
|
||||
op_class(restrict_op, xclass, index->relam) &&
|
||||
IndexScanableOperand(rightop,
|
||||
indexkey,
|
||||
rel,
|
||||
index));
|
||||
|
||||
if (isIndexable)
|
||||
{
|
||||
((Oper *) ((Expr *) clause)->oper)->opno = oprid(newop);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -729,6 +722,7 @@ match_clause_to_indexkey(RelOptInfo *rel,
|
|||
|
||||
if (isIndexable)
|
||||
{
|
||||
|
||||
/*
|
||||
* In place list modification. (op const var/func) -> (op
|
||||
* var/func const)
|
||||
|
@ -848,7 +842,7 @@ pred_test(List *predicate_list, List *clauseinfo_list, List *joininfo_list)
|
|||
static bool
|
||||
one_pred_test(Expr *predicate, List *clauseinfo_list)
|
||||
{
|
||||
ClauseInfo *clauseinfo;
|
||||
ClauseInfo *clauseinfo;
|
||||
List *item;
|
||||
|
||||
Assert(predicate != NULL);
|
||||
|
@ -1152,7 +1146,7 @@ clause_pred_clause_test(Expr *predicate, Node *clause)
|
|||
*/
|
||||
test_oper = makeOper(test_op, /* opno */
|
||||
InvalidOid, /* opid */
|
||||
BOOLOID, /* opresulttype */
|
||||
BOOLOID, /* opresulttype */
|
||||
0, /* opsize */
|
||||
NULL); /* op_fcache */
|
||||
replace_opid(test_oper);
|
||||
|
@ -1163,7 +1157,7 @@ clause_pred_clause_test(Expr *predicate, Node *clause)
|
|||
|
||||
#ifndef OMIT_PARTIAL_INDEX
|
||||
test_result = ExecEvalExpr((Node *) test_expr, NULL, &isNull, NULL);
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
#endif /* OMIT_PARTIAL_INDEX */
|
||||
if (isNull)
|
||||
{
|
||||
elog(DEBUG, "clause_pred_clause_test: null test result");
|
||||
|
@ -1193,10 +1187,10 @@ clause_pred_clause_test(Expr *predicate, Node *clause)
|
|||
*
|
||||
*/
|
||||
static List *
|
||||
indexable_joinclauses(RelOptInfo *rel, RelOptInfo *index,
|
||||
indexable_joinclauses(RelOptInfo * rel, RelOptInfo * index,
|
||||
List *joininfo_list, List *clauseinfo_list)
|
||||
{
|
||||
JoinInfo *joininfo = (JoinInfo *) NULL;
|
||||
JoinInfo *joininfo = (JoinInfo *) NULL;
|
||||
List *cg_list = NIL;
|
||||
List *i = NIL;
|
||||
List *clausegroups = NIL;
|
||||
|
@ -1245,7 +1239,7 @@ extract_restrict_clauses(List *clausegroup)
|
|||
|
||||
foreach(l, clausegroup)
|
||||
{
|
||||
ClauseInfo *cinfo = lfirst(l);
|
||||
ClauseInfo *cinfo = lfirst(l);
|
||||
|
||||
if (!is_joinable((Node *) cinfo->clause))
|
||||
restrict_cls = lappend(restrict_cls, cinfo);
|
||||
|
@ -1267,8 +1261,8 @@ extract_restrict_clauses(List *clausegroup)
|
|||
*
|
||||
*/
|
||||
static List *
|
||||
index_innerjoin(Query *root, RelOptInfo *rel, List *clausegroup_list,
|
||||
RelOptInfo *index)
|
||||
index_innerjoin(Query *root, RelOptInfo * rel, List *clausegroup_list,
|
||||
RelOptInfo * index)
|
||||
{
|
||||
List *clausegroup = NIL;
|
||||
List *cg_list = NIL;
|
||||
|
@ -1354,8 +1348,8 @@ index_innerjoin(Query *root, RelOptInfo *rel, List *clausegroup_list,
|
|||
*/
|
||||
static List *
|
||||
create_index_paths(Query *root,
|
||||
RelOptInfo *rel,
|
||||
RelOptInfo *index,
|
||||
RelOptInfo * rel,
|
||||
RelOptInfo * index,
|
||||
List *clausegroup_list,
|
||||
bool join)
|
||||
{
|
||||
|
@ -1367,7 +1361,7 @@ create_index_paths(Query *root,
|
|||
|
||||
foreach(i, clausegroup_list)
|
||||
{
|
||||
ClauseInfo *clauseinfo;
|
||||
ClauseInfo *clauseinfo;
|
||||
List *temp_node = NIL;
|
||||
bool temp = true;
|
||||
|
||||
|
@ -1399,7 +1393,7 @@ add_index_paths(List *indexpaths, List *new_indexpaths)
|
|||
}
|
||||
|
||||
static bool
|
||||
function_index_operand(Expr *funcOpnd, RelOptInfo *rel, RelOptInfo *index)
|
||||
function_index_operand(Expr *funcOpnd, RelOptInfo * rel, RelOptInfo * index)
|
||||
{
|
||||
Oid heapRelid = (Oid) lfirsti(rel->relids);
|
||||
Func *function;
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.9 1998/09/01 03:23:24 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinpath.c,v 1.10 1998/09/01 04:29:35 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -30,19 +30,15 @@
|
|||
* _enable_mergejoin} */
|
||||
|
||||
static Path *best_innerjoin(List *join_paths, List *outer_relid);
|
||||
static List *
|
||||
sort_inner_and_outer(RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
static List *sort_inner_and_outer(RelOptInfo * joinrel, RelOptInfo * outerrel, RelOptInfo * innerrel,
|
||||
List *mergeinfo_list);
|
||||
static List *
|
||||
match_unsorted_outer(RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
static List *match_unsorted_outer(RelOptInfo * joinrel, RelOptInfo * outerrel, RelOptInfo * innerrel,
|
||||
List *outerpath_list, Path *cheapest_inner, Path *best_innerjoin,
|
||||
List *mergeinfo_list);
|
||||
static List *
|
||||
match_unsorted_inner(RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
static List *match_unsorted_inner(RelOptInfo * joinrel, RelOptInfo * outerrel, RelOptInfo * innerrel,
|
||||
List *innerpath_list, List *mergeinfo_list);
|
||||
static bool EnoughMemoryForHashjoin(RelOptInfo *hashrel);
|
||||
static List *
|
||||
hash_inner_and_outer(RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel,
|
||||
static bool EnoughMemoryForHashjoin(RelOptInfo * hashrel);
|
||||
static List *hash_inner_and_outer(RelOptInfo * joinrel, RelOptInfo * outerrel, RelOptInfo * innerrel,
|
||||
List *hashinfo_list);
|
||||
|
||||
/*
|
||||
|
@ -76,11 +72,11 @@ find_all_join_paths(Query *root, List *joinrels)
|
|||
|
||||
while (joinrels != NIL)
|
||||
{
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(joinrels);
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(joinrels);
|
||||
List *innerrelids;
|
||||
List *outerrelids;
|
||||
RelOptInfo *innerrel;
|
||||
RelOptInfo *outerrel;
|
||||
RelOptInfo *innerrel;
|
||||
RelOptInfo *outerrel;
|
||||
Path *bestinnerjoin;
|
||||
List *pathlist = NIL;
|
||||
|
||||
|
@ -238,9 +234,9 @@ best_innerjoin(List *join_paths, List *outer_relids)
|
|||
* Returns a list of mergejoin paths.
|
||||
*/
|
||||
static List *
|
||||
sort_inner_and_outer(RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
sort_inner_and_outer(RelOptInfo * joinrel,
|
||||
RelOptInfo * outerrel,
|
||||
RelOptInfo * innerrel,
|
||||
List *mergeinfo_list)
|
||||
{
|
||||
List *ms_list = NIL;
|
||||
|
@ -316,9 +312,9 @@ sort_inner_and_outer(RelOptInfo *joinrel,
|
|||
* Returns a list of possible join path nodes.
|
||||
*/
|
||||
static List *
|
||||
match_unsorted_outer(RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
match_unsorted_outer(RelOptInfo * joinrel,
|
||||
RelOptInfo * outerrel,
|
||||
RelOptInfo * innerrel,
|
||||
List *outerpath_list,
|
||||
Path *cheapest_inner,
|
||||
Path *best_innerjoin,
|
||||
|
@ -469,9 +465,9 @@ match_unsorted_outer(RelOptInfo *joinrel,
|
|||
* Returns a list of possible merge paths.
|
||||
*/
|
||||
static List *
|
||||
match_unsorted_inner(RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
match_unsorted_inner(RelOptInfo * joinrel,
|
||||
RelOptInfo * outerrel,
|
||||
RelOptInfo * innerrel,
|
||||
List *innerpath_list,
|
||||
List *mergeinfo_list)
|
||||
{
|
||||
|
@ -565,7 +561,7 @@ match_unsorted_inner(RelOptInfo *joinrel,
|
|||
}
|
||||
|
||||
static bool
|
||||
EnoughMemoryForHashjoin(RelOptInfo *hashrel)
|
||||
EnoughMemoryForHashjoin(RelOptInfo * hashrel)
|
||||
{
|
||||
int ntuples;
|
||||
int tupsize;
|
||||
|
@ -599,9 +595,9 @@ EnoughMemoryForHashjoin(RelOptInfo *hashrel)
|
|||
* Returns a list of hashjoin paths.
|
||||
*/
|
||||
static List *
|
||||
hash_inner_and_outer(RelOptInfo *joinrel,
|
||||
RelOptInfo *outerrel,
|
||||
RelOptInfo *innerrel,
|
||||
hash_inner_and_outer(RelOptInfo * joinrel,
|
||||
RelOptInfo * outerrel,
|
||||
RelOptInfo * innerrel,
|
||||
List *hashinfo_list)
|
||||
{
|
||||
HInfo *xhashinfo = (HInfo *) NULL;
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.14 1998/09/01 03:23:25 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.15 1998/09/01 04:29:37 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -31,19 +31,17 @@ bool _use_right_sided_plans_ = false;
|
|||
|
||||
#endif
|
||||
|
||||
static List *find_clause_joins(Query *root, RelOptInfo *outer_rel, List *joininfo_list);
|
||||
static List *find_clauseless_joins(RelOptInfo *outer_rel, List *inner_rels);
|
||||
static RelOptInfo *init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo);
|
||||
static List *
|
||||
new_join_tlist(List *tlist, List *other_relids,
|
||||
static List *find_clause_joins(Query *root, RelOptInfo * outer_rel, List *joininfo_list);
|
||||
static List *find_clauseless_joins(RelOptInfo * outer_rel, List *inner_rels);
|
||||
static RelOptInfo *init_join_rel(RelOptInfo * outer_rel, RelOptInfo * inner_rel, JoinInfo * joininfo);
|
||||
static List *new_join_tlist(List *tlist, List *other_relids,
|
||||
int first_resdomno);
|
||||
static List *new_joininfo_list(List *joininfo_list, List *join_relids);
|
||||
static void add_superrels(RelOptInfo *rel, RelOptInfo *super_rel);
|
||||
static bool nonoverlap_rels(RelOptInfo *rel1, RelOptInfo *rel2);
|
||||
static void add_superrels(RelOptInfo * rel, RelOptInfo * super_rel);
|
||||
static bool nonoverlap_rels(RelOptInfo * rel1, RelOptInfo * rel2);
|
||||
static bool nonoverlap_sets(List *s1, List *s2);
|
||||
static void
|
||||
set_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel,
|
||||
JoinInfo *jinfo);
|
||||
static void set_joinrel_size(RelOptInfo * joinrel, RelOptInfo * outer_rel, RelOptInfo * inner_rel,
|
||||
JoinInfo * jinfo);
|
||||
|
||||
/*
|
||||
* find-join-rels--
|
||||
|
@ -67,7 +65,7 @@ find_join_rels(Query *root, List *outer_rels)
|
|||
|
||||
foreach(r, outer_rels)
|
||||
{
|
||||
RelOptInfo *outer_rel = (RelOptInfo *) lfirst(r);
|
||||
RelOptInfo *outer_rel = (RelOptInfo *) lfirst(r);
|
||||
|
||||
if (!(joins = find_clause_joins(root, outer_rel, outer_rel->joininfo)))
|
||||
{
|
||||
|
@ -99,15 +97,15 @@ find_join_rels(Query *root, List *outer_rels)
|
|||
* Returns a list of new join relations.
|
||||
*/
|
||||
static List *
|
||||
find_clause_joins(Query *root, RelOptInfo *outer_rel, List *joininfo_list)
|
||||
find_clause_joins(Query *root, RelOptInfo * outer_rel, List *joininfo_list)
|
||||
{
|
||||
List *join_list = NIL;
|
||||
List *i = NIL;
|
||||
|
||||
foreach(i, joininfo_list)
|
||||
{
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(i);
|
||||
RelOptInfo *rel;
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(i);
|
||||
RelOptInfo *rel;
|
||||
|
||||
if (!joininfo->inactive)
|
||||
{
|
||||
|
@ -158,9 +156,9 @@ find_clause_joins(Query *root, RelOptInfo *outer_rel, List *joininfo_list)
|
|||
* Returns a list of new join relations.
|
||||
*/
|
||||
static List *
|
||||
find_clauseless_joins(RelOptInfo *outer_rel, List *inner_rels)
|
||||
find_clauseless_joins(RelOptInfo * outer_rel, List *inner_rels)
|
||||
{
|
||||
RelOptInfo *inner_rel;
|
||||
RelOptInfo *inner_rel;
|
||||
List *t_list = NIL;
|
||||
List *temp_node = NIL;
|
||||
List *i = NIL;
|
||||
|
@ -193,9 +191,9 @@ find_clauseless_joins(RelOptInfo *outer_rel, List *inner_rels)
|
|||
* Returns the new join relation node.
|
||||
*/
|
||||
static RelOptInfo *
|
||||
init_join_rel(RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *joininfo)
|
||||
init_join_rel(RelOptInfo * outer_rel, RelOptInfo * inner_rel, JoinInfo * joininfo)
|
||||
{
|
||||
RelOptInfo *joinrel = makeNode(RelOptInfo);
|
||||
RelOptInfo *joinrel = makeNode(RelOptInfo);
|
||||
List *joinrel_joininfo_list = NIL;
|
||||
List *new_outer_tlist;
|
||||
List *new_inner_tlist;
|
||||
|
@ -327,13 +325,13 @@ new_joininfo_list(List *joininfo_list, List *join_relids)
|
|||
{
|
||||
List *current_joininfo_list = NIL;
|
||||
List *new_otherrels = NIL;
|
||||
JoinInfo *other_joininfo = (JoinInfo *) NULL;
|
||||
JoinInfo *other_joininfo = (JoinInfo *) NULL;
|
||||
List *xjoininfo = NIL;
|
||||
|
||||
foreach(xjoininfo, joininfo_list)
|
||||
{
|
||||
List *or;
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
new_otherrels = joininfo->otherrels;
|
||||
foreach(or, new_otherrels)
|
||||
|
@ -396,23 +394,23 @@ add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
|
||||
foreach(xjoinrel, joinrels)
|
||||
{
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
|
||||
|
||||
foreach(xrelid, joinrel->relids)
|
||||
{
|
||||
Relid relid = (Relid) lfirst(xrelid);
|
||||
RelOptInfo *rel = get_join_rel(root, relid);
|
||||
RelOptInfo *rel = get_join_rel(root, relid);
|
||||
|
||||
add_superrels(rel, joinrel);
|
||||
}
|
||||
}
|
||||
foreach(xjoinrel, joinrels)
|
||||
{
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
|
||||
RelOptInfo *joinrel = (RelOptInfo *) lfirst(xjoinrel);
|
||||
|
||||
foreach(xjoininfo, joinrel->joininfo)
|
||||
{
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
List *other_rels = joininfo->otherrels;
|
||||
List *clause_info = joininfo->jinfoclauseinfo;
|
||||
bool mergejoinable = joininfo->mergejoinable;
|
||||
|
@ -421,10 +419,10 @@ add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
foreach(xrelid, other_rels)
|
||||
{
|
||||
Relid relid = (Relid) lfirst(xrelid);
|
||||
RelOptInfo *rel = get_join_rel(root, relid);
|
||||
RelOptInfo *rel = get_join_rel(root, relid);
|
||||
List *super_rels = rel->superrels;
|
||||
List *xsuper_rel = NIL;
|
||||
JoinInfo *new_joininfo = makeNode(JoinInfo);
|
||||
JoinInfo *new_joininfo = makeNode(JoinInfo);
|
||||
|
||||
new_joininfo->otherrels = joinrel->relids;
|
||||
new_joininfo->jinfoclauseinfo = clause_info;
|
||||
|
@ -436,12 +434,12 @@ add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
|
||||
foreach(xsuper_rel, super_rels)
|
||||
{
|
||||
RelOptInfo *super_rel = (RelOptInfo *) lfirst(xsuper_rel);
|
||||
RelOptInfo *super_rel = (RelOptInfo *) lfirst(xsuper_rel);
|
||||
|
||||
if (nonoverlap_rels(super_rel, joinrel))
|
||||
{
|
||||
List *new_relids = super_rel->relids;
|
||||
JoinInfo *other_joininfo =
|
||||
JoinInfo *other_joininfo =
|
||||
joininfo_member(new_relids,
|
||||
joinrel->joininfo);
|
||||
|
||||
|
@ -453,7 +451,7 @@ add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
}
|
||||
else
|
||||
{
|
||||
JoinInfo *new_joininfo = makeNode(JoinInfo);
|
||||
JoinInfo *new_joininfo = makeNode(JoinInfo);
|
||||
|
||||
new_joininfo->otherrels = new_relids;
|
||||
new_joininfo->jinfoclauseinfo = clause_info;
|
||||
|
@ -471,7 +469,7 @@ add_new_joininfos(Query *root, List *joinrels, List *outerrels)
|
|||
}
|
||||
foreach(xrel, outerrels)
|
||||
{
|
||||
RelOptInfo *rel = (RelOptInfo *) lfirst(xrel);
|
||||
RelOptInfo *rel = (RelOptInfo *) lfirst(xrel);
|
||||
|
||||
rel->superrels = NIL;
|
||||
}
|
||||
|
@ -499,13 +497,13 @@ final_join_rels(List *join_rel_list)
|
|||
*/
|
||||
foreach(xrel, join_rel_list)
|
||||
{
|
||||
RelOptInfo *rel = (RelOptInfo *) lfirst(xrel);
|
||||
RelOptInfo *rel = (RelOptInfo *) lfirst(xrel);
|
||||
List *xjoininfo = NIL;
|
||||
bool final = true;
|
||||
|
||||
foreach(xjoininfo, rel->joininfo)
|
||||
{
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
JoinInfo *joininfo = (JoinInfo *) lfirst(xjoininfo);
|
||||
|
||||
if (joininfo->otherrels != NIL)
|
||||
{
|
||||
|
@ -533,7 +531,7 @@ final_join_rels(List *join_rel_list)
|
|||
* Modifies the superrels field of rel
|
||||
*/
|
||||
static void
|
||||
add_superrels(RelOptInfo *rel, RelOptInfo *super_rel)
|
||||
add_superrels(RelOptInfo * rel, RelOptInfo * super_rel)
|
||||
{
|
||||
rel->superrels = lappend(rel->superrels, super_rel);
|
||||
}
|
||||
|
@ -548,7 +546,7 @@ add_superrels(RelOptInfo *rel, RelOptInfo *super_rel)
|
|||
* Returns non-nil if rel1 and rel2 do not overlap.
|
||||
*/
|
||||
static bool
|
||||
nonoverlap_rels(RelOptInfo *rel1, RelOptInfo *rel2)
|
||||
nonoverlap_rels(RelOptInfo * rel1, RelOptInfo * rel2)
|
||||
{
|
||||
return nonoverlap_sets(rel1->relids, rel2->relids);
|
||||
}
|
||||
|
@ -569,7 +567,7 @@ nonoverlap_sets(List *s1, List *s2)
|
|||
}
|
||||
|
||||
static void
|
||||
set_joinrel_size(RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel, JoinInfo *jinfo)
|
||||
set_joinrel_size(RelOptInfo * joinrel, RelOptInfo * outer_rel, RelOptInfo * inner_rel, JoinInfo * jinfo)
|
||||
{
|
||||
int ntuples;
|
||||
float selec;
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/joinutils.c,v 1.7 1998/09/01 03:23:27 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/joinutils.c,v 1.8 1998/09/01 04:29:38 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
@ -26,18 +26,14 @@
|
|||
#include "optimizer/ordering.h"
|
||||
|
||||
|
||||
static int
|
||||
match_pathkey_joinkeys(List *pathkey, List *joinkeys,
|
||||
static int match_pathkey_joinkeys(List *pathkey, List *joinkeys,
|
||||
int which_subkey);
|
||||
static bool
|
||||
every_func(List *joinkeys, List *pathkey,
|
||||
static bool every_func(List *joinkeys, List *pathkey,
|
||||
int which_subkey);
|
||||
static List *
|
||||
new_join_pathkey(List *subkeys,
|
||||
static List *new_join_pathkey(List *subkeys,
|
||||
List *considered_subkeys, List *join_rel_tlist,
|
||||
List *joinclauses);
|
||||
static List *
|
||||
new_matching_subkeys(Var *subkey, List *considered_subkeys,
|
||||
static List *new_matching_subkeys(Var *subkey, List *considered_subkeys,
|
||||
List *join_rel_tlist, List *joinclauses);
|
||||
|
||||
/****************************************************************************
|
||||
|
@ -146,7 +142,7 @@ match_pathkey_joinkeys(List *pathkey,
|
|||
pos++;
|
||||
}
|
||||
}
|
||||
return -1; /* no index found */
|
||||
return -1; /* no index found */
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue