database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-07 19:06:32 +03:00
Code Activity

pgindent run on all C files. Java run to follow. initdb/regression

Browse Source 
tests pass.
This commit is contained in:
Bruce Momjian
2001-10-25 05:50:21 +00:00
parent 59da2105d8
commit b81844b173
818 changed files with 21684 additions and 20491 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/backend/commands/_deadcode/recipe.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/recipe.c,v 1.13 2001/03/22 06:16:12 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/recipe.c,v 1.14 2001/10/25 05:49:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -431,7 +431,6 @@ tg_replaceNumberedParam(Node *expression,
{
case T_Param:
{
/*
* the node is a parameter, substitute the entry from the
* target list of the child that corresponds to the
@@ -445,7 +444,6 @@ tg_replaceNumberedParam(Node *expression,
if (p->param_tlist)
{
/*
* we have a parameter with an attribute like
* $N.foo so replace it with a new var node
@@ -506,7 +504,6 @@ tg_replaceNumberedParam(Node *expression,
break;
case T_Expr:
{
/*
* the node is an expression, we need to recursively call
* ourselves until we find parameter nodes
@@ -578,7 +575,6 @@ tg_rewriteParamsInExpr(Node *expression, QueryTreeList * inputQlist)
{
case T_Param:
{
/*
* the node is a parameter, substitute the entry from the
* target list of the child that corresponds to the
@@ -594,7 +590,6 @@ tg_rewriteParamsInExpr(Node *expression, QueryTreeList * inputQlist)
if (p->param_tlist)
{
/*
* we have a parameter with an attribute like
* $N.foo so match the resname "foo" against the
@@ -634,7 +629,6 @@ tg_rewriteParamsInExpr(Node *expression, QueryTreeList * inputQlist)
break;
case T_Expr:
{
/*
* the node is an expression, we need to recursively call
* ourselves until we find parameter nodes
@@ -834,7 +828,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
{
case TG_SQL:
{
/*
* for SQL ingredients, the SQL query is contained in
* the 'src' field
@@ -940,7 +933,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
}
else if (n->nodeType == TG_EYE_NODE)
{
/*
* if we hit an eye, we need to stop and make what we have into a
* subrecipe query block
@@ -949,7 +941,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
}
else if (n->nodeType == TG_TEE_NODE)
{
/*
* if we hit a tee, check to see if the parsing has been done for
* this tee already by the other parent
@@ -958,7 +949,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
rel = RelationNameGetRelation(n->nodeName);
if (RelationIsValid(rel))
{
/*
* this tee has already been visited, no need to do any
* further processing
@@ -1014,7 +1004,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
if (RelationIsValid(rel))
{
/*
* for complex types, create new relation with the same
* tuple descriptor as the output table type
@@ -1028,7 +1017,6 @@ tg_parseSubQuery(TgRecipe * r, TgNode * n, TeeInfo * teeInfo)
}
else
{
/*
* we have to create a relation with one attribute of the
* simple base type. That attribute will have an attr
@@ -1197,7 +1185,6 @@ replaceSeqScan(Plan *plan, Plan *parent,
snode = (Scan *) plan;
if (snode->scanrelid == rt_ind)
{
/*
* found the sequential scan that should be replaced with the
* tplan.
@@ -1328,5 +1315,4 @@ replaceTeeScans(Plan *plan, Query *parsetree, TeeInfo * teeInfo)
}
#endif /* TIOGA */

3
src/backend/commands/_deadcode/recipe.h
View File

@@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: recipe.h,v 1.3 2001/01/24 19:42:53 momjian Exp $
* $Id: recipe.h,v 1.4 2001/10/25 05:49:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -16,5 +16,4 @@
#include "nodes/parsenodes.h"
extern void beginRecipe(RecipeStmt *stmt);
#endif /* RECIPE_H */

10
src/backend/commands/_deadcode/version.c
View File

@@ -10,7 +10,7 @@
* doesn't work! - jolly 8/19/95
*
*
* $Id: version.c,v 1.26 2001/03/23 04:49:52 momjian Exp $
* $Id: version.c,v 1.27 2001/10/25 05:49:27 momjian Exp $
*
* NOTES
* At the point the version is defined, 2 physical relations are created
@@ -87,7 +87,6 @@ eval_as_new_xact(char *query)
CommandCounterIncrement();
pg_exec_query(query);
}
#endif
/*
* Define a version.
@@ -129,7 +128,6 @@ DefineVersion(char *name, char *fromRelname, char *date)
VersionReplace(name, saved_basename, saved_snapshot);
VersionRetrieve(name, saved_basename, saved_snapshot);
}
#endif
/*
@@ -162,7 +160,6 @@ VersionCreate(char *vname, char *bname)
sprintf(query_buf, "CREATE TABLE %s_del (DOID oid)", vname);
eval_as_new_xact(query_buf);
}
#endif
@@ -210,7 +207,6 @@ setAttrList(char *bname)
return;
}
#endif
/*
@@ -228,7 +224,6 @@ VersionAppend(char *vname, char *bname)
eval_as_new_xact(rule_buf);
}
#endif
/*
@@ -257,7 +252,6 @@ where _%s.oid !!= '%s_del.DOID'",
/* printf("%s\n",rule_buf); */
}
#endif
/*
@@ -295,7 +289,6 @@ VersionDelete(char *vname, char *bname, char *snapshot)
eval_as_new_xact(rule_buf);
#endif /* OLD_REWRITE */
}
#endif
/*
@@ -349,5 +342,4 @@ VersionReplace(char *vname, char *bname, char *snapshot)
/* printf("%s\n",rule_buf); */
}
#endif

471
src/backend/commands/analyze.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.22 2001/07/05 19:33:35 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.23 2001/10/25 05:49:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -37,9 +37,11 @@
/*
* Analysis algorithms supported
*/
typedef enum {
typedef enum
{
ALG_MINIMAL = 1, /* Compute only most-common-values */
ALG_SCALAR /* Compute MCV, histogram, sort correlation */
ALG_SCALAR /* Compute MCV, histogram, sort
* correlation */
} AlgCode;
/*
@@ -70,7 +72,10 @@ typedef struct
Oid eqfunc; /* and associated function */
Oid ltopr; /* '<' operator for datatype, if any */
/* These fields are filled in by the actual statistics-gathering routine */
/*
* These fields are filled in by the actual statistics-gathering
* routine
*/
bool stats_valid;
float4 stanullfrac; /* fraction of entries that are NULL */
int4 stawidth; /* average width */
@@ -101,7 +106,7 @@ typedef struct
#define swapDatum(a,b) do {Datum _tmp; _tmp=a; a=b; b=_tmp;} while(0)
static int MESSAGE_LEVEL;
static int MESSAGE_LEVEL;
/* context information for compare_scalars() */
static FmgrInfo *datumCmpFn;
@@ -111,19 +116,19 @@ static int *datumCmpTupnoLink;
static VacAttrStats *examine_attribute(Relation onerel, int attnum);
static int acquire_sample_rows(Relation onerel, HeapTuple *rows,
int targrows, double *totalrows);
int targrows, double *totalrows);
static double random_fract(void);
static double init_selection_state(int n);
static double select_next_random_record(double t, int n, double *stateptr);
static int compare_rows(const void *a, const void *b);
static int compare_scalars(const void *a, const void *b);
static int compare_mcvs(const void *a, const void *b);
static int compare_rows(const void *a, const void *b);
static int compare_scalars(const void *a, const void *b);
static int compare_mcvs(const void *a, const void *b);
static void compute_minimal_stats(VacAttrStats *stats,
TupleDesc tupDesc, double totalrows,
HeapTuple *rows, int numrows);
TupleDesc tupDesc, double totalrows,
HeapTuple *rows, int numrows);
static void compute_scalar_stats(VacAttrStats *stats,
TupleDesc tupDesc, double totalrows,
HeapTuple *rows, int numrows);
TupleDesc tupDesc, double totalrows,
HeapTuple *rows, int numrows);
static void update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats);
@@ -154,8 +159,8 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt)
* Begin a transaction for analyzing this relation.
*
* Note: All memory allocated during ANALYZE will live in
* TransactionCommandContext or a subcontext thereof, so it will
* all be released by transaction commit at the end of this routine.
* TransactionCommandContext or a subcontext thereof, so it will all
* be released by transaction commit at the end of this routine.
*/
StartTransactionCommand();
@@ -191,14 +196,14 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt)
ReleaseSysCache(tuple);
/*
* Open the class, getting only a read lock on it, and check permissions.
* Permissions check should match vacuum's check!
* Open the class, getting only a read lock on it, and check
* permissions. Permissions check should match vacuum's check!
*/
onerel = heap_open(relid, AccessShareLock);
if (! (pg_ownercheck(GetUserId(), RelationGetRelationName(onerel),
RELNAME) ||
(is_dbadmin(MyDatabaseId) && !onerel->rd_rel->relisshared)))
if (!(pg_ownercheck(GetUserId(), RelationGetRelationName(onerel),
RELNAME) ||
(is_dbadmin(MyDatabaseId) && !onerel->rd_rel->relisshared)))
{
/* No need for a notice if we already complained during VACUUM */
if (!vacstmt->vacuum)
@@ -238,7 +243,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt)
if (i >= attr_cnt)
elog(ERROR, "ANALYZE: there is no attribute %s in %s",
col, RelationGetRelationName(onerel));
vacattrstats[tcnt] = examine_attribute(onerel, i+1);
vacattrstats[tcnt] = examine_attribute(onerel, i + 1);
if (vacattrstats[tcnt] != NULL)
tcnt++;
}
@@ -251,7 +256,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt)
tcnt = 0;
for (i = 0; i < attr_cnt; i++)
{
vacattrstats[tcnt] = examine_attribute(onerel, i+1);
vacattrstats[tcnt] = examine_attribute(onerel, i + 1);
if (vacattrstats[tcnt] != NULL)
tcnt++;
}
@@ -270,8 +275,8 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt)
/*
* Determine how many rows we need to sample, using the worst case
* from all analyzable columns. We use a lower bound of 100 rows
* to avoid possible overflow in Vitter's algorithm.
* from all analyzable columns. We use a lower bound of 100 rows to
* avoid possible overflow in Vitter's algorithm.
*/
targrows = 100;
for (i = 0; i < attr_cnt; i++)
@@ -289,8 +294,8 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt)
/*
* If we are running a standalone ANALYZE, update pages/tuples stats
* in pg_class. We have the accurate page count from heap_beginscan,
* but only an approximate number of tuples; therefore, if we are
* part of VACUUM ANALYZE do *not* overwrite the accurate count already
* but only an approximate number of tuples; therefore, if we are part
* of VACUUM ANALYZE do *not* overwrite the accurate count already
* inserted by VACUUM.
*/
if (!vacstmt->vacuum)
@@ -300,7 +305,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt)
RelationGetForm(onerel)->relhasindex);
/*
* Compute the statistics. Temporary results during the calculations
* Compute the statistics. Temporary results during the calculations
* for each column are stored in a child context. The calc routines
* are responsible to make sure that whatever they store into the
* VacAttrStats structure is allocated in TransactionCommandContext.
@@ -338,8 +343,9 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt)
/*
* Emit the completed stats rows into pg_statistic, replacing any
* previous statistics for the target columns. (If there are stats
* in pg_statistic for columns we didn't process, we leave them alone.)
* previous statistics for the target columns. (If there are
* stats in pg_statistic for columns we didn't process, we leave
* them alone.)
*/
update_attstats(relid, attr_cnt, vacattrstats);
}
@@ -364,7 +370,7 @@ analyze_rel(Oid relid, VacuumStmt *vacstmt)
static VacAttrStats *
examine_attribute(Relation onerel, int attnum)
{
Form_pg_attribute attr = onerel->rd_att->attrs[attnum-1];
Form_pg_attribute attr = onerel->rd_att->attrs[attnum - 1];
Operator func_operator;
Oid oprrest;
HeapTuple typtuple;
@@ -396,8 +402,8 @@ examine_attribute(Relation onerel, int attnum)
return NULL;
/*
* If we have "=" then we're at least able to do the minimal algorithm,
* so start filling in a VacAttrStats struct.
* If we have "=" then we're at least able to do the minimal
* algorithm, so start filling in a VacAttrStats struct.
*/
stats = (VacAttrStats *) palloc(sizeof(VacAttrStats));
MemSet(stats, 0, sizeof(VacAttrStats));
@@ -424,15 +430,14 @@ examine_attribute(Relation onerel, int attnum)
{
oprrest = ((Form_pg_operator) GETSTRUCT(func_operator))->oprrest;
if (oprrest == F_SCALARLTSEL)
{
ltopr = oprid(func_operator);
}
ReleaseSysCache(func_operator);
}
stats->ltopr = ltopr;
/*
* Determine the algorithm to use (this will get more complicated later)
* Determine the algorithm to use (this will get more complicated
* later)
*/
if (OidIsValid(ltopr))
{
@@ -474,7 +479,7 @@ examine_attribute(Relation onerel, int attnum)
* acquire_sample_rows -- acquire a random sample of rows from the table
*
* Up to targrows rows are collected (if there are fewer than that many
* rows in the table, all rows are collected). When the table is larger
* rows in the table, all rows are collected). When the table is larger
* than targrows, a truly random sample is collected: every row has an
* equal chance of ending up in the final sample.
*
@@ -491,8 +496,8 @@ acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
int numrows = 0;
HeapScanDesc scan;
HeapTuple tuple;
ItemPointer lasttuple;
BlockNumber lastblock,
ItemPointer lasttuple;
BlockNumber lastblock,
estblock;
OffsetNumber lastoffset;
int numest;
@@ -501,6 +506,7 @@ acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
double rstate;
Assert(targrows > 1);
/*
* Do a simple linear scan until we reach the target number of rows.
*/
@@ -512,8 +518,9 @@ acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
break;
}
heap_endscan(scan);
/*
* If we ran out of tuples then we're done, no matter how few we
* If we ran out of tuples then we're done, no matter how few we
* collected. No sort is needed, since they're already in order.
*/
if (!HeapTupleIsValid(tuple))
@@ -521,35 +528,40 @@ acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
*totalrows = (double) numrows;
return numrows;
}
/*
* Otherwise, start replacing tuples in the sample until we reach the
* end of the relation. This algorithm is from Jeff Vitter's paper
* (see full citation below). It works by repeatedly computing the number
* of the next tuple we want to fetch, which will replace a randomly
* chosen element of the reservoir (current set of tuples). At all times
* the reservoir is a true random sample of the tuples we've passed over
* so far, so when we fall off the end of the relation we're done.
* (see full citation below). It works by repeatedly computing the
* number of the next tuple we want to fetch, which will replace a
* randomly chosen element of the reservoir (current set of tuples).
* At all times the reservoir is a true random sample of the tuples
* we've passed over so far, so when we fall off the end of the
* relation we're done.
*
* A slight difficulty is that since we don't want to fetch tuples or even
* pages that we skip over, it's not possible to fetch *exactly* the N'th
* tuple at each step --- we don't know how many valid tuples are on
* the skipped pages. We handle this by assuming that the average number
* of valid tuples/page on the pages already scanned over holds good for
* the rest of the relation as well; this lets us estimate which page
* the next tuple should be on and its position in the page. Then we
* fetch the first valid tuple at or after that position, being careful
* not to use the same tuple twice. This approach should still give a
* good random sample, although it's not perfect.
* A slight difficulty is that since we don't want to fetch tuples or
* even pages that we skip over, it's not possible to fetch *exactly*
* the N'th tuple at each step --- we don't know how many valid tuples
* are on the skipped pages. We handle this by assuming that the
* average number of valid tuples/page on the pages already scanned
* over holds good for the rest of the relation as well; this lets us
* estimate which page the next tuple should be on and its position in
* the page. Then we fetch the first valid tuple at or after that
* position, being careful not to use the same tuple twice. This
* approach should still give a good random sample, although it's not
* perfect.
*/
lasttuple = &(rows[numrows-1]->t_self);
lasttuple = &(rows[numrows - 1]->t_self);
lastblock = ItemPointerGetBlockNumber(lasttuple);
lastoffset = ItemPointerGetOffsetNumber(lasttuple);
/*
* If possible, estimate tuples/page using only completely-scanned pages.
* If possible, estimate tuples/page using only completely-scanned
* pages.
*/
for (numest = numrows; numest > 0; numest--)
{
if (ItemPointerGetBlockNumber(&(rows[numest-1]->t_self)) != lastblock)
if (ItemPointerGetBlockNumber(&(rows[numest - 1]->t_self)) != lastblock)
break;
}
if (numest == 0)
@@ -558,27 +570,25 @@ acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
estblock = lastblock + 1;
}
else
{
estblock = lastblock;
}
tuplesperpage = (double) numest / (double) estblock;
t = (double) numrows; /* t is the # of records processed so far */
rstate = init_selection_state(targrows);
for (;;)
{
double targpos;
BlockNumber targblock;
Buffer targbuffer;
Page targpage;
OffsetNumber targoffset,
maxoffset;
double targpos;
BlockNumber targblock;
Buffer targbuffer;
Page targpage;
OffsetNumber targoffset,
maxoffset;
t = select_next_random_record(t, targrows, &rstate);
/* Try to read the t'th record in the table */
targpos = t / tuplesperpage;
targblock = (BlockNumber) targpos;
targoffset = ((int) ((targpos - targblock) * tuplesperpage)) +
targoffset = ((int) ((targpos - targblock) * tuplesperpage)) +
FirstOffsetNumber;
/* Make sure we are past the last selected record */
if (targblock <= lastblock)
@@ -588,19 +598,22 @@ acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
targoffset = lastoffset + 1;
}
/* Loop to find first valid record at or after given position */
pageloop:;
pageloop:;
/*
* Have we fallen off the end of the relation? (We rely on
* Have we fallen off the end of the relation? (We rely on
* heap_beginscan to have updated rd_nblocks.)
*/
if (targblock >= onerel->rd_nblocks)
break;
/*
* We must maintain a pin on the target page's buffer to ensure that
* the maxoffset value stays good (else concurrent VACUUM might
* delete tuples out from under us). Hence, pin the page until we
* are done looking at it. We don't maintain a lock on the page,
* so tuples could get added to it, but we ignore such tuples.
* We must maintain a pin on the target page's buffer to ensure
* that the maxoffset value stays good (else concurrent VACUUM
* might delete tuples out from under us). Hence, pin the page
* until we are done looking at it. We don't maintain a lock on
* the page, so tuples could get added to it, but we ignore such
* tuples.
*/
targbuffer = ReadBuffer(onerel, targblock);
if (!BufferIsValid(targbuffer))
@@ -632,7 +645,7 @@ acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
* Found a suitable tuple, so save it, replacing one old
* tuple at random
*/
int k = (int) (targrows * random_fract());
int k = (int) (targrows * random_fract());
Assert(k >= 0 && k < targrows);
heap_freetuple(rows[k]);
@@ -667,13 +680,13 @@ acquire_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
static double
random_fract(void)
{
long z;
long z;
/* random() can produce endpoint values, try again if so */
do
{
z = random();
} while (! (z > 0 && z < MAX_RANDOM_VALUE));
} while (!(z > 0 && z < MAX_RANDOM_VALUE));
return (double) z / (double) MAX_RANDOM_VALUE;
}
@@ -702,7 +715,7 @@ static double
init_selection_state(int n)
{
/* Initial value of W (for use when Algorithm Z is first applied) */
return exp(- log(random_fract())/n);
return exp(-log(random_fract()) / n);
}
static double
@@ -712,8 +725,8 @@ select_next_random_record(double t, int n, double *stateptr)
if (t <= (22.0 * n))
{
/* Process records using Algorithm X until t is large enough */
double V,
quot;
double V,
quot;
V = random_fract(); /* Generate V */
t += 1;
@@ -728,21 +741,21 @@ select_next_random_record(double t, int n, double *stateptr)
else
{
/* Now apply Algorithm Z */
double W = *stateptr;
double term = t - (double) n + 1;
double S;
double W = *stateptr;
double term = t - (double) n + 1;
double S;
for (;;)
{
double numer,
numer_lim,
denom;
double U,
X,
lhs,
rhs,
y,
tmp;
double numer,
numer_lim,
denom;
double U,
X,
lhs,
rhs,
y,
tmp;
/* Generate U and X */
U = random_fract();
@@ -750,15 +763,15 @@ select_next_random_record(double t, int n, double *stateptr)
S = floor(X); /* S is tentatively set to floor(X) */
/* Test if U <= h(S)/cg(X) in the manner of (6.3) */
tmp = (t + 1) / term;
lhs = exp(log(((U * tmp * tmp) * (term + S))/(t + X))/n);
rhs = (((t + X)/(term + S)) * term)/t;
lhs = exp(log(((U * tmp * tmp) * (term + S)) / (t + X)) / n);
rhs = (((t + X) / (term + S)) * term) / t;
if (lhs <= rhs)
{
W = rhs/lhs;
W = rhs / lhs;
break;
}
/* Test if U <= f(S)/cg(X) */
y = (((U * (t + 1))/term) * (t + S + 1))/(t + X);
y = (((U * (t + 1)) / term) * (t + S + 1)) / (t + X);
if ((double) n < S)
{
denom = t;
@@ -774,8 +787,8 @@ select_next_random_record(double t, int n, double *stateptr)
y *= numer / denom;
denom -= 1;
}
W = exp(- log(random_fract())/n); /* Generate W in advance */
if (exp(log(y)/n) <= (t + X)/t)
W = exp(-log(random_fract()) / n); /* Generate W in advance */
if (exp(log(y) / n) <= (t + X) / t)
break;
}
t += S + 1;
@@ -790,11 +803,11 @@ select_next_random_record(double t, int n, double *stateptr)
static int
compare_rows(const void *a, const void *b)
{
HeapTuple ha = * (HeapTuple *) a;
HeapTuple hb = * (HeapTuple *) b;
BlockNumber ba = ItemPointerGetBlockNumber(&ha->t_self);
HeapTuple ha = *(HeapTuple *) a;
HeapTuple hb = *(HeapTuple *) b;
BlockNumber ba = ItemPointerGetBlockNumber(&ha->t_self);
OffsetNumber oa = ItemPointerGetOffsetNumber(&ha->t_self);
BlockNumber bb = ItemPointerGetBlockNumber(&hb->t_self);
BlockNumber bb = ItemPointerGetBlockNumber(&hb->t_self);
OffsetNumber ob = ItemPointerGetOffsetNumber(&hb->t_self);
if (ba < bb)
@@ -839,15 +852,18 @@ compute_minimal_stats(VacAttrStats *stats,
FmgrInfo f_cmpeq;
typedef struct
{
Datum value;
int count;
Datum value;
int count;
} TrackItem;
TrackItem *track;
int track_cnt,
track_max;
int num_mcv = stats->attr->attstattarget;
/* We track up to 2*n values for an n-element MCV list; but at least 10 */
/*
* We track up to 2*n values for an n-element MCV list; but at least
* 10
*/
track_max = 2 * num_mcv;
if (track_max < 10)
track_max = 10;
@@ -877,19 +893,20 @@ compute_minimal_stats(VacAttrStats *stats,
/*
* If it's a varlena field, add up widths for average width
* calculation. Note that if the value is toasted, we
* use the toasted width. We don't bother with this calculation
* if it's a fixed-width type.
* calculation. Note that if the value is toasted, we use the
* toasted width. We don't bother with this calculation if it's a
* fixed-width type.
*/
if (is_varlena)
{
total_width += VARSIZE(DatumGetPointer(value));
/*
* If the value is toasted, we want to detoast it just once to
* avoid repeated detoastings and resultant excess memory usage
* during the comparisons. Also, check to see if the value is
* excessively wide, and if so don't detoast at all --- just
* ignore the value.
* avoid repeated detoastings and resultant excess memory
* usage during the comparisons. Also, check to see if the
* value is excessively wide, and if so don't detoast at all
* --- just ignore the value.
*/
if (toast_raw_datum_size(value) > WIDTH_THRESHOLD)
{
@@ -920,10 +937,10 @@ compute_minimal_stats(VacAttrStats *stats,
/* Found a match */
track[j].count++;
/* This value may now need to "bubble up" in the track list */
while (j > 0 && track[j].count > track[j-1].count)
while (j > 0 && track[j].count > track[j - 1].count)
{
swapDatum(track[j].value, track[j-1].value);
swapInt(track[j].count, track[j-1].count);
swapDatum(track[j].value, track[j - 1].value);
swapInt(track[j].count, track[j - 1].count);
j--;
}
}
@@ -932,10 +949,10 @@ compute_minimal_stats(VacAttrStats *stats,
/* No match. Insert at head of count-1 list */
if (track_cnt < track_max)
track_cnt++;
for (j = track_cnt-1; j > firstcount1; j--)
for (j = track_cnt - 1; j > firstcount1; j--)
{
track[j].value = track[j-1].value;
track[j].count = track[j-1].count;
track[j].value = track[j - 1].value;
track[j].count = track[j - 1].count;
}
if (firstcount1 < track_cnt)
{
@@ -948,8 +965,8 @@ compute_minimal_stats(VacAttrStats *stats,
/* We can only compute valid stats if we found some non-null values. */
if (nonnull_cnt > 0)
{
int nmultiple,
summultiple;
int nmultiple,
summultiple;
stats->stats_valid = true;
/* Do the simple null-frac and width stats */
@@ -977,9 +994,9 @@ compute_minimal_stats(VacAttrStats *stats,
nmultiple == track_cnt)
{
/*
* Our track list includes every value in the sample, and every
* value appeared more than once. Assume the column has just
* these values.
* Our track list includes every value in the sample, and
* every value appeared more than once. Assume the column has
* just these values.
*/
stats->stadistinct = track_cnt;
}
@@ -994,12 +1011,12 @@ compute_minimal_stats(VacAttrStats *stats,
* We assume (not very reliably!) that all the multiply-occurring
* values are reflected in the final track[] list, and the other
* nonnull values all appeared but once. (XXX this usually
* results in a drastic overestimate of ndistinct. Can we do
* results in a drastic overestimate of ndistinct. Can we do
* any better?)
*----------
*/
int f1 = nonnull_cnt - summultiple;
double term1;
int f1 = nonnull_cnt - summultiple;
double term1;
if (f1 < 1)
f1 = 1;
@@ -1014,16 +1031,16 @@ compute_minimal_stats(VacAttrStats *stats,
* a fixed value.
*/
if (stats->stadistinct > 0.1 * totalrows)
stats->stadistinct = - (stats->stadistinct / totalrows);
stats->stadistinct = -(stats->stadistinct / totalrows);
/*
* Decide how many values are worth storing as most-common values.
* If we are able to generate a complete MCV list (all the values
* in the sample will fit, and we think these are all the ones in
* the table), then do so. Otherwise, store only those values
* that are significantly more common than the (estimated) average.
* We set the threshold rather arbitrarily at 25% more than average,
* with at least 2 instances in the sample.
* the table), then do so. Otherwise, store only those values
* that are significantly more common than the (estimated)
* average. We set the threshold rather arbitrarily at 25% more
* than average, with at least 2 instances in the sample.
*/
if (track_cnt < track_max && toowide_cnt == 0 &&
stats->stadistinct > 0 &&
@@ -1034,12 +1051,12 @@ compute_minimal_stats(VacAttrStats *stats,
}
else
{
double ndistinct = stats->stadistinct;
double avgcount,
mincount;
double ndistinct = stats->stadistinct;
double avgcount,
mincount;
if (ndistinct < 0)
ndistinct = - ndistinct * totalrows;
ndistinct = -ndistinct * totalrows;
/* estimate # of occurrences in sample of a typical value */
avgcount = (double) numrows / ndistinct;
/* set minimum threshold count to store a value */
@@ -1062,8 +1079,8 @@ compute_minimal_stats(VacAttrStats *stats,
if (num_mcv > 0)
{
MemoryContext old_context;
Datum *mcv_values;
float4 *mcv_freqs;
Datum *mcv_values;
float4 *mcv_freqs;
/* Must copy the target values into TransactionCommandContext */
old_context = MemoryContextSwitchTo(TransactionCommandContext);
@@ -1153,19 +1170,20 @@ compute_scalar_stats(VacAttrStats *stats,
/*
* If it's a varlena field, add up widths for average width
* calculation. Note that if the value is toasted, we
* use the toasted width. We don't bother with this calculation
* if it's a fixed-width type.
* calculation. Note that if the value is toasted, we use the
* toasted width. We don't bother with this calculation if it's a
* fixed-width type.
*/
if (is_varlena)
{
total_width += VARSIZE(DatumGetPointer(value));
/*
* If the value is toasted, we want to detoast it just once to
* avoid repeated detoastings and resultant excess memory usage
* during the comparisons. Also, check to see if the value is
* excessively wide, and if so don't detoast at all --- just
* ignore the value.
* avoid repeated detoastings and resultant excess memory
* usage during the comparisons. Also, check to see if the
* value is excessively wide, and if so don't detoast at all
* --- just ignore the value.
*/
if (toast_raw_datum_size(value) > WIDTH_THRESHOLD)
{
@@ -1185,11 +1203,11 @@ compute_scalar_stats(VacAttrStats *stats,
/* We can only compute valid stats if we found some sortable values. */
if (values_cnt > 0)
{
int ndistinct, /* # distinct values in sample */
nmultiple, /* # that appear multiple times */
num_hist,
dups_cnt;
int slot_idx = 0;
int ndistinct, /* # distinct values in sample */
nmultiple, /* # that appear multiple times */
num_hist,
dups_cnt;
int slot_idx = 0;
/* Sort the collected values */
datumCmpFn = &f_cmpfn;
@@ -1199,23 +1217,24 @@ compute_scalar_stats(VacAttrStats *stats,
sizeof(ScalarItem), compare_scalars);
/*
* Now scan the values in order, find the most common ones,
* and also accumulate ordering-correlation statistics.
* Now scan the values in order, find the most common ones, and
* also accumulate ordering-correlation statistics.
*
* To determine which are most common, we first have to count the
* number of duplicates of each value. The duplicates are adjacent
* in the sorted list, so a brute-force approach is to compare
* successive datum values until we find two that are not equal.
* However, that requires N-1 invocations of the datum comparison
* routine, which are completely redundant with work that was done
* during the sort. (The sort algorithm must at some point have
* compared each pair of items that are adjacent in the sorted order;
* otherwise it could not know that it's ordered the pair correctly.)
* We exploit this by having compare_scalars remember the highest
* tupno index that each ScalarItem has been found equal to. At the
* end of the sort, a ScalarItem's tupnoLink will still point to
* itself if and only if it is the last item of its group of
* duplicates (since the group will be ordered by tupno).
* number of duplicates of each value. The duplicates are
* adjacent in the sorted list, so a brute-force approach is to
* compare successive datum values until we find two that are not
* equal. However, that requires N-1 invocations of the datum
* comparison routine, which are completely redundant with work
* that was done during the sort. (The sort algorithm must at
* some point have compared each pair of items that are adjacent
* in the sorted order; otherwise it could not know that it's
* ordered the pair correctly.) We exploit this by having
* compare_scalars remember the highest tupno index that each
* ScalarItem has been found equal to. At the end of the sort, a
* ScalarItem's tupnoLink will still point to itself if and only
* if it is the last item of its group of duplicates (since the
* group will be ordered by tupno).
*/
corr_xysum = 0;
ndistinct = 0;
@@ -1225,7 +1244,8 @@ compute_scalar_stats(VacAttrStats *stats,
{
int tupno = values[i].tupno;
corr_xysum += (double) i * (double) tupno;
corr_xysum += (double) i *(double) tupno;
dups_cnt++;
if (tupnoLink[tupno] == tupno)
{
@@ -1235,7 +1255,7 @@ compute_scalar_stats(VacAttrStats *stats,
{
nmultiple++;
if (track_cnt < num_mcv ||
dups_cnt > track[track_cnt-1].count)
dups_cnt > track[track_cnt - 1].count)
{
/*
* Found a new item for the mcv list; find its
@@ -1243,16 +1263,16 @@ compute_scalar_stats(VacAttrStats *stats,
* Loop invariant is that j points at an empty/
* replaceable slot.
*/
int j;
int j;
if (track_cnt < num_mcv)
track_cnt++;
for (j = track_cnt-1; j > 0; j--)
for (j = track_cnt - 1; j > 0; j--)
{
if (dups_cnt <= track[j-1].count)
if (dups_cnt <= track[j - 1].count)
break;
track[j].count = track[j-1].count;
track[j].first = track[j-1].first;
track[j].count = track[j - 1].count;
track[j].first = track[j - 1].first;
}
track[j].count = dups_cnt;
track[j].first = i + 1 - dups_cnt;
@@ -1278,8 +1298,8 @@ compute_scalar_stats(VacAttrStats *stats,
else if (toowide_cnt == 0 && nmultiple == ndistinct)
{
/*
* Every value in the sample appeared more than once. Assume the
* column has just these values.
* Every value in the sample appeared more than once. Assume
* the column has just these values.
*/
stats->stadistinct = ndistinct;
}
@@ -1294,8 +1314,8 @@ compute_scalar_stats(VacAttrStats *stats,
* Overwidth values are assumed to have been distinct.
*----------
*/
int f1 = ndistinct - nmultiple + toowide_cnt;
double term1;
int f1 = ndistinct - nmultiple + toowide_cnt;
double term1;
if (f1 < 1)
f1 = 1;
@@ -1310,19 +1330,20 @@ compute_scalar_stats(VacAttrStats *stats,
* a fixed value.
*/
if (stats->stadistinct > 0.1 * totalrows)
stats->stadistinct = - (stats->stadistinct / totalrows);
stats->stadistinct = -(stats->stadistinct / totalrows);
/*
* Decide how many values are worth storing as most-common values.
* If we are able to generate a complete MCV list (all the values
* in the sample will fit, and we think these are all the ones in
* the table), then do so. Otherwise, store only those values
* that are significantly more common than the (estimated) average.
* We set the threshold rather arbitrarily at 25% more than average,
* with at least 2 instances in the sample. Also, we won't suppress
* values that have a frequency of at least 1/K where K is the
* intended number of histogram bins; such values might otherwise
* cause us to emit duplicate histogram bin boundaries.
* the table), then do so. Otherwise, store only those values
* that are significantly more common than the (estimated)
* average. We set the threshold rather arbitrarily at 25% more
* than average, with at least 2 instances in the sample. Also,
* we won't suppress values that have a frequency of at least 1/K
* where K is the intended number of histogram bins; such values
* might otherwise cause us to emit duplicate histogram bin
* boundaries.
*/
if (track_cnt == ndistinct && toowide_cnt == 0 &&
stats->stadistinct > 0 &&
@@ -1333,13 +1354,13 @@ compute_scalar_stats(VacAttrStats *stats,
}
else
{
double ndistinct = stats->stadistinct;
double avgcount,
mincount,
maxmincount;
double ndistinct = stats->stadistinct;
double avgcount,
mincount,
maxmincount;
if (ndistinct < 0)
ndistinct = - ndistinct * totalrows;
ndistinct = -ndistinct * totalrows;
/* estimate # of occurrences in sample of a typical value */
avgcount = (double) numrows / ndistinct;
/* set minimum threshold count to store a value */
@@ -1366,8 +1387,8 @@ compute_scalar_stats(VacAttrStats *stats,
if (num_mcv > 0)
{
MemoryContext old_context;
Datum *mcv_values;
float4 *mcv_freqs;
Datum *mcv_values;
float4 *mcv_freqs;
/* Must copy the target values into TransactionCommandContext */
old_context = MemoryContextSwitchTo(TransactionCommandContext);
@@ -1402,8 +1423,8 @@ compute_scalar_stats(VacAttrStats *stats,
if (num_hist >= 2)
{
MemoryContext old_context;
Datum *hist_values;
int nvals;
Datum *hist_values;
int nvals;
/* Sort the MCV items into position order to speed next loop */
qsort((void *) track, num_mcv,
@@ -1413,24 +1434,25 @@ compute_scalar_stats(VacAttrStats *stats,
* Collapse out the MCV items from the values[] array.
*
* Note we destroy the values[] array here... but we don't need
* it for anything more. We do, however, still need values_cnt.
* nvals will be the number of remaining entries in values[].
* it for anything more. We do, however, still need
* values_cnt. nvals will be the number of remaining entries
* in values[].
*/
if (num_mcv > 0)
{
int src,
dest;
int j;
int src,
dest;
int j;
src = dest = 0;
j = 0; /* index of next interesting MCV item */
while (src < values_cnt)
{
int ncopy;
int ncopy;
if (j < num_mcv)
{
int first = track[j].first;
int first = track[j].first;
if (src >= first)
{
@@ -1442,9 +1464,7 @@ compute_scalar_stats(VacAttrStats *stats,
ncopy = first - src;
}
else
{
ncopy = values_cnt - src;
}
memmove(&values[dest], &values[src],
ncopy * sizeof(ScalarItem));
src += ncopy;
@@ -1461,7 +1481,7 @@ compute_scalar_stats(VacAttrStats *stats,
hist_values = (Datum *) palloc(num_hist * sizeof(Datum));
for (i = 0; i < num_hist; i++)
{
int pos;
int pos;
pos = (i * (nvals - 1)) / (num_hist - 1);
hist_values[i] = datumCopy(values[pos].value,
@@ -1481,9 +1501,9 @@ compute_scalar_stats(VacAttrStats *stats,
if (values_cnt > 1)
{
MemoryContext old_context;
float4 *corrs;
double corr_xsum,
corr_x2sum;
float4 *corrs;
double corr_xsum,
corr_x2sum;
/* Must copy the target values into TransactionCommandContext */
old_context = MemoryContextSwitchTo(TransactionCommandContext);
@@ -1499,9 +1519,10 @@ compute_scalar_stats(VacAttrStats *stats,
* (values_cnt-1)*values_cnt*(2*values_cnt-1) / 6.
*----------
*/
corr_xsum = (double) (values_cnt-1) * (double) values_cnt / 2.0;
corr_x2sum = (double) (values_cnt-1) * (double) values_cnt *
(double) (2*values_cnt-1) / 6.0;
corr_xsum = (double) (values_cnt - 1) * (double) values_cnt / 2.0;
corr_x2sum = (double) (values_cnt - 1) * (double) values_cnt *
(double) (2 * values_cnt - 1) / 6.0;
/* And the correlation coefficient reduces to */
corrs[0] = (values_cnt * corr_xysum - corr_xsum * corr_xsum) /
(values_cnt * corr_x2sum - corr_xsum * corr_xsum);
@@ -1521,7 +1542,7 @@ compute_scalar_stats(VacAttrStats *stats,
* qsort comparator for sorting ScalarItems
*
* Aside from sorting the items, we update the datumCmpTupnoLink[] array
* whenever two ScalarItems are found to contain equal datums. The array
* whenever two ScalarItems are found to contain equal datums. The array
* is indexed by tupno; for each ScalarItem, it contains the highest
* tupno that that item's datum has been found to be equal to. This allows
* us to avoid additional comparisons in compute_scalar_stats().
@@ -1573,7 +1594,7 @@ compare_mcvs(const void *a, const void *b)
* Statistics are stored in several places: the pg_class row for the
* relation has stats about the whole relation, and there is a
* pg_statistic row for each (non-system) attribute that has ever
* been analyzed. The pg_class values are updated by VACUUM, not here.
* been analyzed. The pg_class values are updated by VACUUM, not here.
*
* pg_statistic rows are just added or updated normally. This means
* that pg_statistic will probably contain some deleted rows at the
@@ -1604,7 +1625,9 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
FmgrInfo out_function;
HeapTuple stup,
oldtup;
int i, k, n;
int i,
k,
n;
Datum values[Natts_pg_statistic];
char nulls[Natts_pg_statistic];
char replaces[Natts_pg_statistic];
@@ -1626,22 +1649,22 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
}
i = 0;
values[i++] = ObjectIdGetDatum(relid); /* starelid */
values[i++] = Int16GetDatum(stats->attnum); /* staattnum */
values[i++] = Float4GetDatum(stats->stanullfrac); /* stanullfrac */
values[i++] = Int32GetDatum(stats->stawidth); /* stawidth */
values[i++] = Float4GetDatum(stats->stadistinct); /* stadistinct */
values[i++] = ObjectIdGetDatum(relid); /* starelid */
values[i++] = Int16GetDatum(stats->attnum); /* staattnum */
values[i++] = Float4GetDatum(stats->stanullfrac); /* stanullfrac */
values[i++] = Int32GetDatum(stats->stawidth); /* stawidth */
values[i++] = Float4GetDatum(stats->stadistinct); /* stadistinct */
for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
{
values[i++] = Int16GetDatum(stats->stakind[k]); /* stakindN */
values[i++] = Int16GetDatum(stats->stakind[k]); /* stakindN */
}
for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
{
values[i++] = ObjectIdGetDatum(stats->staop[k]); /* staopN */
values[i++] = ObjectIdGetDatum(stats->staop[k]); /* staopN */
}
for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
{
int nnum = stats->numnumbers[k];
int nnum = stats->numnumbers[k];
if (nnum > 0)
{
@@ -1653,7 +1676,7 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
/* XXX knows more than it should about type float4: */
arry = construct_array(numdatums, nnum,
false, sizeof(float4), 'i');
values[i++] = PointerGetDatum(arry); /* stanumbersN */
values[i++] = PointerGetDatum(arry); /* stanumbersN */
}
else
{
@@ -1663,7 +1686,7 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
}
for (k = 0; k < STATISTIC_NUM_SLOTS; k++)
{
int ntxt = stats->numvalues[k];
int ntxt = stats->numvalues[k];
if (ntxt > 0)
{
@@ -1676,20 +1699,20 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
* Convert data values to a text string to be inserted
* into the text array.
*/
Datum stringdatum;
Datum stringdatum;
stringdatum =
FunctionCall3(&out_function,
stats->stavalues[k][n],
ObjectIdGetDatum(stats->attrtype->typelem),
Int32GetDatum(stats->attr->atttypmod));
ObjectIdGetDatum(stats->attrtype->typelem),
Int32GetDatum(stats->attr->atttypmod));
txtdatums[n] = DirectFunctionCall1(textin, stringdatum);
pfree(DatumGetPointer(stringdatum));
}
/* XXX knows more than it should about type text: */
arry = construct_array(txtdatums, ntxt,
false, -1, 'i');
values[i++] = PointerGetDatum(arry); /* stavaluesN */
values[i++] = PointerGetDatum(arry); /* stavaluesN */
}
else
{

65
src/backend/commands/async.c
View File

@@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.80 2001/09/08 01:10:20 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.81 2001/10/25 05:49:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -120,7 +120,7 @@ static volatile int notifyInterruptOccurred = 0;
/* True if we've registered an on_shmem_exit cleanup */
static bool unlistenExitRegistered = false;
bool Trace_notify = false;
bool Trace_notify = false;
static void Async_UnlistenAll(void);
@@ -153,13 +153,13 @@ Async_Notify(char *relname)
elog(DEBUG, "Async_Notify: %s", relname);
/* no point in making duplicate entries in the list ... */
if (! AsyncExistsPendingNotify(relname))
if (!AsyncExistsPendingNotify(relname))
{
/*
* The name list needs to live until end of transaction, so
* store it in the top transaction context.
* The name list needs to live until end of transaction, so store
* it in the top transaction context.
*/
MemoryContext oldcontext;
MemoryContext oldcontext;
oldcontext = MemoryContextSwitchTo(TopTransactionContext);
@@ -209,7 +209,7 @@ Async_Listen(char *relname, int pid)
Form_pg_listener listener = (Form_pg_listener) GETSTRUCT(tuple);
if (listener->listenerpid == pid &&
strncmp(NameStr(listener->relname), relname, NAMEDATALEN) == 0)
strncmp(NameStr(listener->relname), relname, NAMEDATALEN) == 0)
{
alreadyListener = true;
/* No need to scan the rest of the table */
@@ -310,13 +310,14 @@ Async_Unlisten(char *relname, int pid)
Form_pg_listener listener = (Form_pg_listener) GETSTRUCT(tuple);
if (listener->listenerpid == pid &&
strncmp(NameStr(listener->relname), relname, NAMEDATALEN) == 0)
strncmp(NameStr(listener->relname), relname, NAMEDATALEN) == 0)
{
/* Found the matching tuple, delete it */
simple_heap_delete(lRel, &tuple->t_self);
/*
* We assume there can be only one match, so no need
* to scan the rest of the table
* We assume there can be only one match, so no need to scan
* the rest of the table
*/
break;
}
@@ -478,16 +479,16 @@ AtCommit_Notify(void)
char *relname = NameStr(listener->relname);
int32 listenerPID = listener->listenerpid;
if (! AsyncExistsPendingNotify(relname))
if (!AsyncExistsPendingNotify(relname))
continue;
if (listenerPID == MyProcPid)
{
/*
* Self-notify: no need to bother with table update.
* Indeed, we *must not* clear the notification field in
* this path, or we could lose an outside notify, which'd
* be bad for applications that ignore self-notify messages.
* Self-notify: no need to bother with table update. Indeed,
* we *must not* clear the notification field in this path, or
* we could lose an outside notify, which'd be bad for
* applications that ignore self-notify messages.
*/
if (Trace_notify)
@@ -503,22 +504,20 @@ AtCommit_Notify(void)
/*
* If someone has already notified this listener, we don't
* bother modifying the table, but we do still send a
* SIGUSR2 signal, just in case that backend missed the
* earlier signal for some reason. It's OK to send the
* signal first, because the other guy can't read
* pg_listener until we unlock it.
* bother modifying the table, but we do still send a SIGUSR2
* signal, just in case that backend missed the earlier signal
* for some reason. It's OK to send the signal first, because
* the other guy can't read pg_listener until we unlock it.
*/
if (kill(listenerPID, SIGUSR2) < 0)
{
/*
* Get rid of pg_listener entry if it refers to a PID
* that no longer exists. Presumably, that backend
* crashed without deleting its pg_listener entries.
* This code used to only delete the entry if
* errno==ESRCH, but as far as I can see we should
* just do it for any failure (certainly at least for
* EPERM too...)
* Get rid of pg_listener entry if it refers to a PID that
* no longer exists. Presumably, that backend crashed
* without deleting its pg_listener entries. This code
* used to only delete the entry if errno==ESRCH, but as
* far as I can see we should just do it for any failure
* (certainly at least for EPERM too...)
*/
simple_heap_delete(lRel, &lTuple->t_self);
}
@@ -610,7 +609,6 @@ Async_NotifyHandler(SIGNAL_ARGS)
if (notifyInterruptEnabled)
{
/*
* I'm not sure whether some flavors of Unix might allow another
* SIGUSR2 occurrence to recursively interrupt this routine. To
@@ -641,7 +639,6 @@ Async_NotifyHandler(SIGNAL_ARGS)
}
else
{
/*
* In this path it is NOT SAFE to do much of anything, except
* this:
@@ -888,11 +885,11 @@ static void
ClearPendingNotifies(void)
{
/*
* We used to have to explicitly deallocate the list members and nodes,
* because they were malloc'd. Now, since we know they are palloc'd
* in TopTransactionContext, we need not do that --- they'll go away
* automatically at transaction exit. We need only reset the list head
* pointer.
* We used to have to explicitly deallocate the list members and
* nodes, because they were malloc'd. Now, since we know they are
* palloc'd in TopTransactionContext, we need not do that --- they'll
* go away automatically at transaction exit. We need only reset the
* list head pointer.
*/
pendingNotifies = NIL;
}

5
src/backend/commands/cluster.c
View File

@@ -15,7 +15,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.69 2001/08/21 16:36:01 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.70 2001/10/25 05:49:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -267,10 +267,9 @@ rebuildheap(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex)
LocalHeapTuple.t_datamcxt = NULL;
LocalHeapTuple.t_data = NULL;
heap_fetch(LocalOldHeap, SnapshotNow, &LocalHeapTuple, &LocalBuffer,
ScanDesc);
ScanDesc);
if (LocalHeapTuple.t_data != NULL)
{
/*
* We must copy the tuple because heap_insert() will overwrite
* the commit-status fields of the tuple it's handed, and the

836
src/backend/commands/command.c
View File

File diff suppressed because it is too large Load Diff

9
src/backend/commands/comment.c
View File

@@ -7,7 +7,7 @@
* Copyright (c) 1999-2001, PostgreSQL Global Development Group
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/comment.c,v 1.33 2001/10/03 20:54:20 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/comment.c,v 1.34 2001/10/25 05:49:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -332,9 +332,10 @@ CommentRelation(int reltype, char *relname, char *comment)
elog(ERROR, "you are not permitted to comment on class '%s'", relname);
/*
* Open the relation. We do this mainly to acquire a lock that ensures
* no one else drops the relation before we commit. (If they did, they'd
* fail to remove the entry we are about to make in pg_description.)
* Open the relation. We do this mainly to acquire a lock that
* ensures no one else drops the relation before we commit. (If they
* did, they'd fail to remove the entry we are about to make in
* pg_description.)
*
* heap_openr will complain if it's an index, so we must do this:
*/

12
src/backend/commands/copy.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.141 2001/08/10 18:57:34 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.142 2001/10/25 05:49:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -76,7 +76,6 @@ static StringInfoData attribute_buf;
#ifdef MULTIBYTE
static int client_encoding;
static int server_encoding;
#endif
@@ -209,7 +208,6 @@ CopyDonePeek(FILE *fp, int c, int pickup)
{
if (pickup)
{
/*
* We want to pick it up - just receive again into dummy
* buffer
@@ -240,8 +238,8 @@ CopyDonePeek(FILE *fp, int c, int pickup)
* (<from> = TRUE means we are inserting into the table.)
*
* If <pipe> is false, transfer is between the table and the file named
* <filename>. Otherwise, transfer is between the table and our regular
* input/output stream. The latter could be either stdin/stdout or a
* <filename>. Otherwise, transfer is between the table and our regular
* input/output stream. The latter could be either stdin/stdout or a
* socket, depending on whether we're running under Postmaster control.
*
* Iff <binary>, unload or reload in the binary format, as opposed to the
@@ -257,7 +255,7 @@ CopyDonePeek(FILE *fp, int c, int pickup)
* NULL values as <null_print>.
*
* When loading in the text format from an input stream (as opposed to
* a file), recognize a "." on a line by itself as EOF. Also recognize
* a file), recognize a "." on a line by itself as EOF. Also recognize
* a stream EOF. When unloading in the text format to an output stream,
* write a "." on a line by itself at the end of the data.
*
@@ -534,7 +532,6 @@ CopyTo(Relation rel, bool binary, bool oids, FILE *fp,
}
else
{
/*
* If we have a toasted datum, forcibly detoast it to
* avoid memory leakage inside the type's output routine
@@ -1197,7 +1194,6 @@ CopyAttributeOut(FILE *fp, char *server_string, char *delim)
char *string_start;
int mblen;
int i;
#endif
#ifdef MULTIBYTE

46
src/backend/commands/creatinh.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.80 2001/08/16 20:38:53 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.81 2001/10/25 05:49:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -37,7 +37,7 @@ static List *MergeAttributes(List *schema, List *supers, bool istemp,
List **supOids, List **supconstr, bool *supHasOids);
static bool change_varattnos_of_a_node(Node *node, const AttrNumber *newattno);
static void StoreCatalogInheritance(Oid relationId, List *supers);
static int findAttrByName(const char *attributeName, List *schema);
static int findAttrByName(const char *attributeName, List *schema);
static void setRelhassubclassInRelation(Oid relationId, bool relhassubclass);
@@ -74,7 +74,7 @@ DefineRelation(CreateStmt *stmt, char relkind)
* including inherited attributes.
*/
schema = MergeAttributes(schema, stmt->inhRelnames, stmt->istemp,
&inheritOids, &old_constraints, &parentHasOids);
&inheritOids, &old_constraints, &parentHasOids);
numberOfAttributes = length(schema);
if (numberOfAttributes <= 0)
@@ -305,7 +305,8 @@ MergeAttributes(List *schema, List *supers, bool istemp,
List *constraints = NIL;
bool parentHasOids = false;
bool have_bogus_defaults = false;
char *bogus_marker = "Bogus!"; /* marks conflicting defaults */
char *bogus_marker = "Bogus!"; /* marks conflicting
* defaults */
int child_attno;
/*
@@ -329,6 +330,7 @@ MergeAttributes(List *schema, List *supers, bool istemp,
coldef->colname);
}
}
/*
* Reject duplicate names in the list of parents, too.
*/
@@ -346,7 +348,7 @@ MergeAttributes(List *schema, List *supers, bool istemp,
/*
* Scan the parents left-to-right, and merge their attributes to form
* a list of inherited attributes (inhSchema). Also check to see if
* a list of inherited attributes (inhSchema). Also check to see if
* we need to inherit an OID column.
*/
child_attno = 0;
@@ -387,7 +389,7 @@ MergeAttributes(List *schema, List *supers, bool istemp,
* the attributes of this parent table. (They are not the same
* for parents after the first one.)
*/
newattno = (AttrNumber *) palloc(tupleDesc->natts*sizeof(AttrNumber));
newattno = (AttrNumber *) palloc(tupleDesc->natts * sizeof(AttrNumber));
for (parent_attno = 1; parent_attno <= tupleDesc->natts;
parent_attno++)
@@ -420,8 +422,8 @@ MergeAttributes(List *schema, List *supers, bool istemp,
if (exist_attno > 0)
{
/*
* Yes, try to merge the two column definitions.
* They must have the same type and typmod.
* Yes, try to merge the two column definitions. They must
* have the same type and typmod.
*/
elog(NOTICE, "CREATE TABLE: merging multiple inherited definitions of attribute \"%s\"",
attributeName);
@@ -429,7 +431,7 @@ MergeAttributes(List *schema, List *supers, bool istemp,
if (strcmp(def->typename->name, attributeType) != 0 ||
def->typename->typmod != attribute->atttypmod)
elog(ERROR, "CREATE TABLE: inherited attribute \"%s\" type conflict (%s and %s)",
attributeName, def->typename->name, attributeType);
attributeName, def->typename->name, attributeType);
/* Merge of NOT NULL constraints = OR 'em together */
def->is_not_null |= attribute->attnotnull;
/* Default and other constraints are handled below */
@@ -453,6 +455,7 @@ MergeAttributes(List *schema, List *supers, bool istemp,
inhSchema = lappend(inhSchema, def);
newattno[parent_attno - 1] = ++child_attno;
}
/*
* Copy default if any
*/
@@ -474,15 +477,17 @@ MergeAttributes(List *schema, List *supers, bool istemp,
}
}
Assert(this_default != NULL);
/*
* If default expr could contain any vars, we'd need to fix
* 'em, but it can't; so default is ready to apply to child.
* If default expr could contain any vars, we'd need to
* fix 'em, but it can't; so default is ready to apply to
* child.
*
* If we already had a default from some prior parent,
* check to see if they are the same. If so, no problem;
* if not, mark the column as having a bogus default.
* Below, we will complain if the bogus default isn't
* overridden by the child schema.
* If we already had a default from some prior parent, check
* to see if they are the same. If so, no problem; if
* not, mark the column as having a bogus default. Below,
* we will complain if the bogus default isn't overridden
* by the child schema.
*/
Assert(def->raw_default == NULL);
if (def->cooked_default == NULL)
@@ -494,6 +499,7 @@ MergeAttributes(List *schema, List *supers, bool istemp,
}
}
}
/*
* Now copy the constraints of this parent, adjusting attnos using
* the completed newattno[] map
@@ -555,8 +561,8 @@ MergeAttributes(List *schema, List *supers, bool istemp,
ColumnDef *def;
/*
* Yes, try to merge the two column definitions.
* They must have the same type and typmod.
* Yes, try to merge the two column definitions. They must
* have the same type and typmod.
*/
elog(NOTICE, "CREATE TABLE: merging attribute \"%s\" with inherited definition",
attributeName);
@@ -564,7 +570,7 @@ MergeAttributes(List *schema, List *supers, bool istemp,
if (strcmp(def->typename->name, attributeType) != 0 ||
def->typename->typmod != newdef->typename->typmod)
elog(ERROR, "CREATE TABLE: attribute \"%s\" type conflict (%s and %s)",
attributeName, def->typename->name, attributeType);
attributeName, def->typename->name, attributeType);
/* Merge of NOT NULL constraints = OR 'em together */
def->is_not_null |= newdef->is_not_null;
/* If new def has a default, override previous default */
@@ -630,7 +636,6 @@ change_varattnos_walker(Node *node, const AttrNumber *newattno)
if (var->varlevelsup == 0 && var->varno == 1 &&
var->varattno > 0)
{
/*
* ??? the following may be a problem when the node is
* multiply referenced though stringToNode() doesn't create
@@ -783,7 +788,6 @@ again:
}
if (found)
{
/*
* found a later duplicate, so remove this entry.
*/

7
src/backend/commands/dbcommands.c
View File

@@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.80 2001/09/06 04:57:28 ishii Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.81 2001/10/25 05:49:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -37,7 +37,7 @@
#include "utils/syscache.h"
#ifdef MULTIBYTE
#include "mb/pg_wchar.h" /* encoding check */
#include "mb/pg_wchar.h" /* encoding check */
#endif
@@ -148,11 +148,12 @@ createdb(const char *dbname, const char *dbpath,
#ifdef MULTIBYTE
/* Some encodings are client only */
if (!PG_VALID_BE_ENCODING( encoding ))
if (!PG_VALID_BE_ENCODING(encoding))
elog(ERROR, "CREATE DATABASE: invalid backend encoding");
#else
Assert(encoding == 0); /* zero is PG_SQL_ASCII */
#endif
/*
* Preassign OID for pg_database tuple, so that we can compute db
* path.

55
src/backend/commands/define.c
View File

@@ -10,7 +10,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.62 2001/10/13 01:35:25 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.63 2001/10/25 05:49:25 momjian Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the
@@ -64,7 +64,7 @@ static void
case_translate_language_name(const char *input, char *output)
{
/*
* Translate the input language name to lower case, except if it's "C",
* Translate the input language name to lower case, except if it's "C",
* translate to upper case.
*/
int i;
@@ -85,8 +85,8 @@ compute_return_type(TypeName *returnType,
char **prorettype_p, bool *returnsSet_p)
{
/*
* Examine the "returns" clause returnType of the CREATE FUNCTION statement
* and return information about it as *prorettype_p and *returnsSet.
* Examine the "returns" clause returnType of the CREATE FUNCTION statement
* and return information about it as *prorettype_p and *returnsSet.
*/
*prorettype_p = TypeNameToInternalName(returnType);
*returnsSet_p = returnType->setof;
@@ -100,26 +100,26 @@ compute_full_attributes(List *parameters,
bool *canCache_p, bool *isStrict_p)
{
/*-------------
* Interpret the parameters *parameters and return their contents as
* *byte_pct_p, etc.
* Interpret the parameters *parameters and return their contents as
* *byte_pct_p, etc.
*
* These parameters supply optional information about a function.
* All have defaults if not specified.
* These parameters supply optional information about a function.
* All have defaults if not specified.
*
* Note: currently, only two of these parameters actually do anything:
* Note: currently, only two of these parameters actually do anything:
*
* * canCache means the optimizer's constant-folder is allowed to
* pre-evaluate the function when all its inputs are constants.
* * canCache means the optimizer's constant-folder is allowed to
* pre-evaluate the function when all its inputs are constants.
*
* * isStrict means the function should not be called when any NULL
* inputs are present; instead a NULL result value should be assumed.
* * isStrict means the function should not be called when any NULL
* inputs are present; instead a NULL result value should be assumed.
*
* The other four parameters are not used anywhere. They used to be
* used in the "expensive functions" optimizer, but that's been dead code
* for a long time.
* The other four parameters are not used anywhere. They used to be
* used in the "expensive functions" optimizer, but that's been dead code
* for a long time.
*
* Since canCache and isStrict are useful for any function, we now allow
* attributes to be supplied for all functions regardless of language.
* Since canCache and isStrict are useful for any function, we now allow
* attributes to be supplied for all functions regardless of language.
*------------
*/
List *pl;
@@ -142,7 +142,6 @@ compute_full_attributes(List *parameters,
*isStrict_p = true;
else if (strcasecmp(param->defname, "trusted") == 0)
{
/*
* we don't have untrusted functions any more. The 4.2
* implementation is lousy anyway so I took it out. -ay 10/94
@@ -183,7 +182,6 @@ interpret_AS_clause(const char *languageName, const List *as,
if (strcmp(languageName, "C") == 0)
{
/*
* For "C" language, store the file name in probin and, when
* given, the link symbol name in prosrc.
@@ -358,7 +356,7 @@ DefineOperator(char *oprName,
List *parameters)
{
uint16 precedence = 0; /* operator precedence */
bool canHash = false;/* operator hashes */
bool canHash = false; /* operator hashes */
bool isLeftAssociative = true; /* operator is left
* associative */
char *functionName = NULL; /* function for operator */
@@ -369,7 +367,7 @@ DefineOperator(char *oprName,
char *negatorName = NULL; /* optional negator operator name */
char *restrictionName = NULL; /* optional restrict. sel.
* procedure */
char *joinName = NULL;/* optional join sel. procedure name */
char *joinName = NULL; /* optional join sel. procedure name */
char *sortName1 = NULL; /* optional first sort operator */
char *sortName2 = NULL; /* optional second sort operator */
List *pl;
@@ -534,8 +532,8 @@ DefineAggregate(char *aggName, List *parameters)
void
DefineType(char *typeName, List *parameters)
{
int16 internalLength = -1; /* int2 */
int16 externalLength = -1; /* int2 */
int16 internalLength = -1; /* int2 */
int16 externalLength = -1; /* int2 */
char *elemName = NULL;
char *inputName = NULL;
char *outputName = NULL;
@@ -546,7 +544,7 @@ DefineType(char *typeName, List *parameters)
char delimiter = DEFAULT_TYPDELIM;
char *shadow_type;
List *pl;
char alignment = 'i'; /* default alignment */
char alignment = 'i'; /* default alignment */
char storage = 'p'; /* default TOAST storage method */
/*
@@ -591,9 +589,10 @@ DefineType(char *typeName, List *parameters)
char *a = defGetString(defel);
/*
* Note: if argument was an unquoted identifier, parser will have
* applied xlateSqlType() to it, so be prepared to recognize
* translated type names as well as the nominal form.
* Note: if argument was an unquoted identifier, parser will
* have applied xlateSqlType() to it, so be prepared to
* recognize translated type names as well as the nominal
* form.
*/
if (strcasecmp(a, "double") == 0)
alignment = 'd';

14
src/backend/commands/explain.c
View File

@@ -5,7 +5,7 @@
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994-5, Regents of the University of California
*
* $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.66 2001/09/18 01:59:06 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/explain.c,v 1.67 2001/10/25 05:49:25 momjian Exp $
*
*/
@@ -114,8 +114,8 @@ ExplainOneQuery(Query *query, bool verbose, bool analyze, CommandDest dest)
struct timeval endtime;
/*
* Set up the instrumentation for the top node.
* This will cascade during plan initialisation
* Set up the instrumentation for the top node. This will cascade
* during plan initialisation
*/
plan->instrument = InstrAlloc();
@@ -124,7 +124,7 @@ ExplainOneQuery(Query *query, bool verbose, bool analyze, CommandDest dest)
CommandCounterIncrement();
gettimeofday(&endtime, NULL);
endtime.tv_sec -= starttime.tv_sec;
endtime.tv_sec -= starttime.tv_sec;
endtime.tv_usec -= starttime.tv_usec;
while (endtime.tv_usec < 0)
{
@@ -328,9 +328,9 @@ explain_outNode(StringInfo str, Plan *plan, int indent, ExplainState *es)
plan->startup_cost, plan->total_cost,
plan->plan_rows, plan->plan_width);
if ( plan->instrument && plan->instrument->nloops > 0 )
if (plan->instrument && plan->instrument->nloops > 0)
{
double nloops = plan->instrument->nloops;
double nloops = plan->instrument->nloops;
appendStringInfo(str, " (actual time=%.2f..%.2f rows=%.0f loops=%.0f)",
1000.0 * plan->instrument->startup / nloops,
@@ -442,7 +442,7 @@ explain_outNode(StringInfo str, Plan *plan, int indent, ExplainState *es)
static StringInfo
Explain_PlanToString(Plan *plan, ExplainState *es)
{
StringInfo str = makeStringInfo();
StringInfo str = makeStringInfo();
if (plan != NULL)
explain_outNode(str, plan, 0, es);

40
src/backend/commands/indexcmds.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.59 2001/10/24 09:28:31 inoue Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.60 2001/10/25 05:49:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -49,7 +49,7 @@ static void NormIndexAttrs(IndexInfo *indexInfo, Oid *classOidP,
char *accessMethodName, Oid accessMethodId);
static Oid GetAttrOpClass(IndexElem *attribute, Oid attrType,
char *accessMethodName, Oid accessMethodId);
static Oid GetDefaultOpClass(Oid attrType, Oid accessMethodId);
static Oid GetDefaultOpClass(Oid attrType, Oid accessMethodId);
/*
* DefineIndex
@@ -97,7 +97,8 @@ DefineIndex(char *heapRelationName,
heapRelationName);
/*
* look up the access method, verify it can handle the requested features
* look up the access method, verify it can handle the requested
* features
*/
tuple = SearchSysCache(AMNAME,
PointerGetDatum(accessMethodName),
@@ -108,18 +109,18 @@ DefineIndex(char *heapRelationName,
accessMethodId = tuple->t_data->t_oid;
accessMethodForm = (Form_pg_am) GETSTRUCT(tuple);
if (unique && ! accessMethodForm->amcanunique)
if (unique && !accessMethodForm->amcanunique)
elog(ERROR, "DefineIndex: access method \"%s\" does not support UNIQUE indexes",
accessMethodName);
if (numberOfAttributes > 1 && ! accessMethodForm->amcanmulticol)
if (numberOfAttributes > 1 && !accessMethodForm->amcanmulticol)
elog(ERROR, "DefineIndex: access method \"%s\" does not support multi-column indexes",
accessMethodName);
ReleaseSysCache(tuple);
/*
* Convert the partial-index predicate from parsetree form to
* an implicit-AND qual expression, for easier evaluation at runtime.
* Convert the partial-index predicate from parsetree form to an
* implicit-AND qual expression, for easier evaluation at runtime.
* While we are at it, we reduce it to a canonical (CNF or DNF) form
* to simplify the task of proving implications.
*/
@@ -196,7 +197,7 @@ DefineIndex(char *heapRelationName,
* (via the given range table) only to the given base relation oid.
*
* This used to also constrain the form of the predicate to forms that
* indxpath.c could do something with. However, that seems overly
* indxpath.c could do something with. However, that seems overly
* restrictive. One useful application of partial indexes is to apply
* a UNIQUE constraint across a subset of a table, and in that scenario
* any evaluatable predicate will work. So accept any predicate here
@@ -208,11 +209,12 @@ CheckPredicate(List *predList, List *rangeTable, Oid baseRelOid)
{
if (length(rangeTable) != 1 || getrelid(1, rangeTable) != baseRelOid)
elog(ERROR,
"Partial-index predicates may refer only to the base relation");
"Partial-index predicates may refer only to the base relation");
/*
* We don't currently support generation of an actual query plan for a
* predicate, only simple scalar expressions; hence these restrictions.
* predicate, only simple scalar expressions; hence these
* restrictions.
*/
if (contain_subplans((Node *) predList))
elog(ERROR, "Cannot use subselect in index predicate");
@@ -240,7 +242,7 @@ FuncIndexArgs(IndexInfo *indexInfo,
List *arglist;
int nargs = 0;
int i;
FuncDetailCode fdresult;
FuncDetailCode fdresult;
Oid funcid;
Oid rettype;
bool retset;
@@ -309,9 +311,9 @@ FuncIndexArgs(IndexInfo *indexInfo,
/*
* Require that the function be marked cachable. Using a noncachable
* function for a functional index is highly questionable, since if you
* aren't going to get the same result for the same data every time,
* it's not clear what the index entries mean at all.
* function for a functional index is highly questionable, since if
* you aren't going to get the same result for the same data every
* time, it's not clear what the index entries mean at all.
*/
if (!func_iscachable(funcid))
elog(ERROR, "DefineIndex: index function must be marked iscachable");
@@ -431,11 +433,11 @@ GetDefaultOpClass(Oid attrType, Oid accessMethodId)
* (either exactly or binary-compatibly, but prefer an exact match).
*
* We could find more than one binary-compatible match, in which case we
* require the user to specify which one he wants. If we find more than
* one exact match, then someone put bogus entries in pg_opclass.
* require the user to specify which one he wants. If we find more
* than one exact match, then someone put bogus entries in pg_opclass.
*
* We could use an indexscan here, but since pg_opclass is small
* and a scan on opcamid won't be very selective, the indexscan would
* We could use an indexscan here, but since pg_opclass is small and a
* scan on opcamid won't be very selective, the indexscan would
* probably actually be slower than heapscan.
*/
ScanKeyEntryInitialize(&entry[0], 0x0,
@@ -612,7 +614,7 @@ ReindexDatabase(const char *dbname, bool force, bool all)
if (strcmp(dbname, DatabaseName) != 0)
elog(ERROR, "REINDEX DATABASE: Can be executed only on the currently open database.");
if (! (superuser() || is_dbadmin(MyDatabaseId)))
if (!(superuser() || is_dbadmin(MyDatabaseId)))
elog(ERROR, "REINDEX DATABASE: Permission denied.");
/*

3
src/backend/commands/remove.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.63 2001/10/03 20:54:20 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.64 2001/10/25 05:49:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -227,7 +227,6 @@ AttributeAndRelationRemove(Oid typeOid)
}
heap_close(rel, RowExclusiveLock);
}
#endif /* NOTYET */
/*

39
src/backend/commands/rename.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.58 2001/10/08 18:40:04 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.59 2001/10/25 05:49:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -167,7 +167,8 @@ renameatt(char *relname,
heap_freetuple(atttup);
/*
* Update column names of indexes that refer to the column being renamed.
* Update column names of indexes that refer to the column being
* renamed.
*/
indexoidlist = RelationGetIndexList(targetrelation);
@@ -177,9 +178,8 @@ renameatt(char *relname,
HeapTuple indextup;
/*
* First check to see if index is a functional index.
* If so, its column name is a function name and shouldn't
* be renamed here.
* First check to see if index is a functional index. If so, its
* column name is a function name and shouldn't be renamed here.
*/
indextup = SearchSysCache(INDEXRELID,
ObjectIdGetDatum(indexoid),
@@ -192,9 +192,10 @@ renameatt(char *relname,
continue;
}
ReleaseSysCache(indextup);
/*
* Okay, look to see if any column name of the index matches
* the old attribute name.
* Okay, look to see if any column name of the index matches the
* old attribute name.
*/
atttup = SearchSysCacheCopy(ATTNAME,
ObjectIdGetDatum(indexoid),
@@ -206,20 +207,20 @@ renameatt(char *relname,
/*
* Update the (copied) attribute tuple.
*/
StrNCpy(NameStr(((Form_pg_attribute) GETSTRUCT(atttup))->attname),
newattname, NAMEDATALEN);
StrNCpy(NameStr(((Form_pg_attribute) GETSTRUCT(atttup))->attname),
newattname, NAMEDATALEN);
simple_heap_update(attrelation, &atttup->t_self, atttup);
simple_heap_update(attrelation, &atttup->t_self, atttup);
/* keep system catalog indices current */
{
Relation irelations[Num_pg_attr_indices];
{
Relation irelations[Num_pg_attr_indices];
CatalogOpenIndices(Num_pg_attr_indices, Name_pg_attr_indices, irelations);
CatalogIndexInsert(irelations, Num_pg_attr_indices, attrelation, atttup);
CatalogCloseIndices(Num_pg_attr_indices, irelations);
}
heap_freetuple(atttup);
CatalogOpenIndices(Num_pg_attr_indices, Name_pg_attr_indices, irelations);
CatalogIndexInsert(irelations, Num_pg_attr_indices, attrelation, atttup);
CatalogCloseIndices(Num_pg_attr_indices, irelations);
}
heap_freetuple(atttup);
}
freeList(indexoidlist);
@@ -332,8 +333,8 @@ renamerel(const char *oldrelname, const char *newrelname)
*/
if (relkind == RELKIND_VIEW)
{
char *oldrulename,
*newrulename;
char *oldrulename,
*newrulename;
oldrulename = MakeRetrieveViewRuleName(oldrelname);
newrulename = MakeRetrieveViewRuleName(newrelname);

50
src/backend/commands/sequence.c
View File

@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.64 2001/09/19 09:48:42 petere Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/sequence.c,v 1.65 2001/10/25 05:49:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -36,9 +36,9 @@
#else
#define SEQ_MAXVALUE ((int64) 0x7FFFFFFFFFFFFFFF)
#endif
#else /* INT64_IS_BUSTED */
#else /* INT64_IS_BUSTED */
#define SEQ_MAXVALUE ((int64) 0x7FFFFFFF)
#endif /* INT64_IS_BUSTED */
#endif /* INT64_IS_BUSTED */
#define SEQ_MINVALUE (-SEQ_MAXVALUE)
@@ -204,17 +204,17 @@ DefineSequence(CreateSeqStmt *seq)
heap_insert(rel, tuple);
/*
* After crash REDO of heap_insert above would re-init page and
* our magic number would be lost. We have to log sequence creation.
* This means two log records instead of one -:(
* After crash REDO of heap_insert above would re-init page and our
* magic number would be lost. We have to log sequence creation. This
* means two log records instead of one -:(
*/
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
START_CRIT_SECTION();
{
xl_seq_rec xlrec;
XLogRecPtr recptr;
XLogRecData rdata[2];
Form_pg_sequence newseq = (Form_pg_sequence) GETSTRUCT(tuple);
xl_seq_rec xlrec;
XLogRecPtr recptr;
XLogRecData rdata[2];
Form_pg_sequence newseq = (Form_pg_sequence) GETSTRUCT(tuple);
/* We do not log first nextval call, so "advance" sequence here */
newseq->is_called = true;
@@ -582,12 +582,12 @@ get_seq_name(text *seqin)
if (strlen(seqname) >= NAMEDATALEN)
{
#ifdef MULTIBYTE
int len;
int len;
len = pg_mbcliplen(seqname, rawlen, NAMEDATALEN-1);
len = pg_mbcliplen(seqname, rawlen, NAMEDATALEN - 1);
seqname[len] = '\0';
#else
seqname[NAMEDATALEN-1] = '\0';
seqname[NAMEDATALEN - 1] = '\0';
#endif
}
@@ -658,7 +658,6 @@ init_sequence(char *caller, char *name)
if (elm != (SeqTable) NULL)
{
/*
* We are using a seqtable entry left over from a previous xact;
* must check for relid change.
@@ -674,7 +673,6 @@ init_sequence(char *caller, char *name)
}
else
{
/*
* Time to make a new seqtable entry. These entries live as long
* as the backend does, so we use plain malloc for them.
@@ -713,7 +711,7 @@ CloseSequences(void)
for (elm = seqtab; elm != (SeqTable) NULL; elm = elm->next)
{
rel = elm->rel;
if (rel != (Relation) NULL) /* opened in current xact */
if (rel != (Relation) NULL) /* opened in current xact */
{
elm->rel = (Relation) NULL;
heap_close(rel, AccessShareLock);
@@ -737,17 +735,17 @@ init_params(CreateSeqStmt *seq, Form_pg_sequence new)
{
DefElem *defel = (DefElem *) lfirst(option);
if (strcmp(defel->defname, "increment")==0)
if (strcmp(defel->defname, "increment") == 0)
increment_by = defel;
else if (strcmp(defel->defname, "start")==0)
else if (strcmp(defel->defname, "start") == 0)
last_value = defel;
else if (strcmp(defel->defname, "maxvalue")==0)
else if (strcmp(defel->defname, "maxvalue") == 0)
max_value = defel;
else if (strcmp(defel->defname, "minvalue")==0)
else if (strcmp(defel->defname, "minvalue") == 0)
min_value = defel;
else if (strcmp(defel->defname, "cache")==0)
else if (strcmp(defel->defname, "cache") == 0)
cache_value = defel;
else if (strcmp(defel->defname, "cycle")==0)
else if (strcmp(defel->defname, "cycle") == 0)
{
if (defel->arg != (Node *) NULL)
elog(ERROR, "DefineSequence: CYCLE ??");
@@ -768,7 +766,7 @@ init_params(CreateSeqStmt *seq, Form_pg_sequence new)
if (new->increment_by > 0)
new->max_value = SEQ_MAXVALUE; /* ascending seq */
else
new->max_value = -1; /* descending seq */
new->max_value = -1; /* descending seq */
}
else
new->max_value = get_param(max_value);
@@ -822,12 +820,12 @@ get_param(DefElem *def)
return (int64) intVal(def->arg);
/*
* Values too large for int4 will be represented as Float constants
* by the lexer. Accept these if they are valid int8 strings.
* Values too large for int4 will be represented as Float constants by
* the lexer. Accept these if they are valid int8 strings.
*/
if (IsA(def->arg, Float))
return DatumGetInt64(DirectFunctionCall1(int8in,
CStringGetDatum(strVal(def->arg))));
CStringGetDatum(strVal(def->arg))));
/* Shouldn't get here unless parser messed up */
elog(ERROR, "DefineSequence: \"%s\" value must be integer", def->defname);

61
src/backend/commands/trigger.c
View File

@@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.96 2001/08/23 23:06:37 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.97 2001/10/25 05:49:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -34,17 +34,17 @@
static void InsertTrigger(TriggerDesc *trigdesc, Trigger *trigger, int indx);
static HeapTuple GetTupleForTrigger(EState *estate,
ResultRelInfo *relinfo,
ItemPointer tid,
TupleTableSlot **newSlot);
ResultRelInfo *relinfo,
ItemPointer tid,
TupleTableSlot **newSlot);
static HeapTuple ExecCallTriggerFunc(TriggerData *trigdata,
FmgrInfo *finfo,
MemoryContext per_tuple_context);
FmgrInfo *finfo,
MemoryContext per_tuple_context);
static void DeferredTriggerSaveEvent(ResultRelInfo *relinfo, int event,
HeapTuple oldtup, HeapTuple newtup);
HeapTuple oldtup, HeapTuple newtup);
static void DeferredTriggerExecute(DeferredTriggerEvent event, int itemno,
Relation rel, FmgrInfo *finfo,
MemoryContext per_tuple_context);
Relation rel, FmgrInfo *finfo,
MemoryContext per_tuple_context);
void
@@ -93,7 +93,6 @@ CreateTrigger(CreateTrigStmt *stmt)
constrrelid = InvalidOid;
else
{
/*
* NoLock is probably sufficient here, since we're only
* interested in getting the relation's OID...
@@ -849,8 +848,8 @@ ExecCallTriggerFunc(TriggerData *trigdata,
MemoryContext oldContext;
/*
* We cache fmgr lookup info, to avoid making the lookup
* again on each call.
* We cache fmgr lookup info, to avoid making the lookup again on each
* call.
*/
if (finfo->fn_oid == InvalidOid)
fmgr_info(trigdata->tg_trigger->tgfoid, finfo);
@@ -915,14 +914,14 @@ ExecBRInsertTriggers(EState *estate, ResultRelInfo *relinfo,
LocTriggerData.tg_newtuple = NULL;
for (i = 0; i < ntrigs; i++)
{
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
if (!trigger->tgenabled)
continue;
LocTriggerData.tg_trigtuple = oldtuple = newtuple;
LocTriggerData.tg_trigger = trigger;
newtuple = ExecCallTriggerFunc(&LocTriggerData,
relinfo->ri_TrigFunctions + tgindx[i],
relinfo->ri_TrigFunctions + tgindx[i],
GetPerTupleMemoryContext(estate));
if (oldtuple != newtuple && oldtuple != trigtuple)
heap_freetuple(oldtuple);
@@ -978,14 +977,14 @@ ExecBRDeleteTriggers(EState *estate, ResultRelInfo *relinfo,
LocTriggerData.tg_newtuple = NULL;
for (i = 0; i < ntrigs; i++)
{
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
if (!trigger->tgenabled)
continue;
LocTriggerData.tg_trigtuple = trigtuple;
LocTriggerData.tg_trigger = trigger;
newtuple = ExecCallTriggerFunc(&LocTriggerData,
relinfo->ri_TrigFunctions + tgindx[i],
relinfo->ri_TrigFunctions + tgindx[i],
GetPerTupleMemoryContext(estate));
if (newtuple == NULL)
break;
@@ -1055,7 +1054,7 @@ ExecBRUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
LocTriggerData.tg_relation = relinfo->ri_RelationDesc;
for (i = 0; i < ntrigs; i++)
{
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
if (!trigger->tgenabled)
continue;
@@ -1063,7 +1062,7 @@ ExecBRUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
LocTriggerData.tg_newtuple = oldtuple = newtuple;
LocTriggerData.tg_trigger = trigger;
newtuple = ExecCallTriggerFunc(&LocTriggerData,
relinfo->ri_TrigFunctions + tgindx[i],
relinfo->ri_TrigFunctions + tgindx[i],
GetPerTupleMemoryContext(estate));
if (oldtuple != newtuple && oldtuple != intuple)
heap_freetuple(oldtuple);
@@ -1130,8 +1129,8 @@ ltrmark:;
else if (!(ItemPointerEquals(&(tuple.t_self), tid)))
{
TupleTableSlot *epqslot = EvalPlanQual(estate,
relinfo->ri_RangeTableIndex,
&(tuple.t_self));
relinfo->ri_RangeTableIndex,
&(tuple.t_self));
if (!(TupIsNull(epqslot)))
{
@@ -1293,7 +1292,6 @@ deferredTriggerCheckState(Oid tgoid, int32 itemstate)
static void
deferredTriggerAddEvent(DeferredTriggerEvent event)
{
/*
* Since the event list could grow quite long, we keep track of the
* list tail and append there, rather than just doing a stupid
@@ -1359,7 +1357,7 @@ deferredTriggerGetPreviousEvent(Oid relid, ItemPointer ctid)
* single trigger function.
*
* Frequently, this will be fired many times in a row for triggers of
* a single relation. Therefore, we cache the open relation and provide
* a single relation. Therefore, we cache the open relation and provide
* fmgr lookup cache space at the caller level.
*
* event: event currently being fired.
@@ -1535,8 +1533,8 @@ deferredTriggerInvokeEvents(bool immediate_only)
}
/*
* So let's fire it... but first, open the correct relation
* if this is not the same relation as before.
* So let's fire it... but first, open the correct relation if
* this is not the same relation as before.
*/
if (rel == NULL || rel->rd_id != event->dte_relid)
{
@@ -1544,11 +1542,13 @@ deferredTriggerInvokeEvents(bool immediate_only)
heap_close(rel, NoLock);
if (finfo)
pfree(finfo);
/*
* We assume that an appropriate lock is still held by the
* executor, so grab no new lock here.
*/
rel = heap_open(event->dte_relid, NoLock);
/*
* Allocate space to cache fmgr lookup info for triggers
* of this relation.
@@ -1667,7 +1667,6 @@ DeferredTriggerBeginXact(void)
void
DeferredTriggerEndQuery(void)
{
/*
* Ignore call if we aren't in a transaction.
*/
@@ -1688,7 +1687,6 @@ DeferredTriggerEndQuery(void)
void
DeferredTriggerEndXact(void)
{
/*
* Ignore call if we aren't in a transaction.
*/
@@ -1713,7 +1711,6 @@ DeferredTriggerEndXact(void)
void
DeferredTriggerAbortXact(void)
{
/*
* Ignore call if we aren't in a transaction.
*/
@@ -1751,7 +1748,6 @@ DeferredTriggerSetState(ConstraintsSetStmt *stmt)
{
if (!IsTransactionBlock())
{
/*
* ... outside of a transaction block
*
@@ -1779,7 +1775,6 @@ DeferredTriggerSetState(ConstraintsSetStmt *stmt)
}
else
{
/*
* ... inside of a transaction block
*
@@ -2050,7 +2045,7 @@ DeferredTriggerSaveEvent(ResultRelInfo *relinfo, int event,
new_event->dte_n_items = ntriggers;
for (i = 0; i < ntriggers; i++)
{
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
new_event->dte_item[i].dti_tgoid = trigger->tgoid;
new_event->dte_item[i].dti_state =
@@ -2090,7 +2085,7 @@ DeferredTriggerSaveEvent(ResultRelInfo *relinfo, int event,
*/
for (i = 0; i < ntriggers; i++)
{
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
Trigger *trigger = &trigdesc->triggers[tgindx[i]];
bool is_ri_trigger;
bool key_unchanged;
@@ -2125,7 +2120,6 @@ DeferredTriggerSaveEvent(ResultRelInfo *relinfo, int event,
if (key_unchanged)
{
/*
* The key hasn't changed, so no need later to invoke
* the trigger at all. But remember other states from
@@ -2138,7 +2132,6 @@ DeferredTriggerSaveEvent(ResultRelInfo *relinfo, int event,
if (prev_event->dte_event &
TRIGGER_DEFERRED_ROW_INSERTED)
{
/*
* This is a row inserted during our
* transaction. So any key value is considered
@@ -2153,7 +2146,6 @@ DeferredTriggerSaveEvent(ResultRelInfo *relinfo, int event,
}
else
{
/*
* This is a row, previously updated. So if
* this key has been changed before, we still
@@ -2172,7 +2164,6 @@ DeferredTriggerSaveEvent(ResultRelInfo *relinfo, int event,
}
else
{
/*
* Bomb out if this key has been changed before.
* Otherwise remember that we do so.

110
src/backend/commands/user.c
View File

@@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Header: /cvsroot/pgsql/src/backend/commands/user.c,v 1.84 2001/09/19 09:48:42 petere Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/user.c,v 1.85 2001/10/25 05:49:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -170,7 +170,7 @@ update_pg_pwd(PG_FUNCTION_ARGS)
{
/*
* ExclusiveLock ensures no one modifies pg_shadow while we read it,
* and that only one backend rewrites the flat file at a time. It's
* and that only one backend rewrites the flat file at a time. It's
* OK to allow normal reads of pg_shadow in parallel, however.
*/
Relation rel = heap_openr(ShadowRelationName, ExclusiveLock);
@@ -199,15 +199,17 @@ CreateUser(CreateUserStmt *stmt)
sysid_exists = false,
havesysid = false;
int max_id;
List *item, *option;
char *password = NULL; /* PostgreSQL user password */
bool encrypt_password = Password_encryption; /* encrypt password? */
char encrypted_password[MD5_PASSWD_LEN+1];
int sysid = 0; /* PgSQL system id (valid if havesysid) */
bool createdb = false; /* Can the user create databases? */
bool createuser = false; /* Can this user create users? */
List *groupElts = NIL; /* The groups the user is a member of */
char *validUntil = NULL; /* The time the login is valid until */
List *item,
*option;
char *password = NULL; /* PostgreSQL user password */
bool encrypt_password = Password_encryption; /* encrypt password? */
char encrypted_password[MD5_PASSWD_LEN + 1];
int sysid = 0; /* PgSQL system id (valid if havesysid) */
bool createdb = false; /* Can the user create databases? */
bool createuser = false; /* Can this user create users? */
List *groupElts = NIL; /* The groups the user is a member of */
char *validUntil = NULL; /* The time the login is valid
* until */
DefElem *dpassword = NULL;
DefElem *dsysid = NULL;
DefElem *dcreatedb = NULL;
@@ -218,11 +220,12 @@ CreateUser(CreateUserStmt *stmt)
/* Extract options from the statement node tree */
foreach(option, stmt->options)
{
DefElem *defel = (DefElem *) lfirst(option);
DefElem *defel = (DefElem *) lfirst(option);
if (strcmp(defel->defname, "password") == 0 ||
strcmp(defel->defname, "encryptedPassword") == 0 ||
strcmp(defel->defname, "unencryptedPassword") == 0) {
strcmp(defel->defname, "unencryptedPassword") == 0)
{
if (dpassword)
elog(ERROR, "CREATE USER: conflicting options");
dpassword = defel;
@@ -231,33 +234,38 @@ CreateUser(CreateUserStmt *stmt)
else if (strcmp(defel->defname, "unencryptedPassword") == 0)
encrypt_password = false;
}
else if (strcmp(defel->defname, "sysid") == 0) {
else if (strcmp(defel->defname, "sysid") == 0)
{
if (dsysid)
elog(ERROR, "CREATE USER: conflicting options");
dsysid = defel;
}
else if (strcmp(defel->defname, "createdb") == 0) {
else if (strcmp(defel->defname, "createdb") == 0)
{
if (dcreatedb)
elog(ERROR, "CREATE USER: conflicting options");
dcreatedb = defel;
}
else if (strcmp(defel->defname, "createuser") == 0) {
else if (strcmp(defel->defname, "createuser") == 0)
{
if (dcreateuser)
elog(ERROR, "CREATE USER: conflicting options");
dcreateuser = defel;
}
else if (strcmp(defel->defname, "groupElts") == 0) {
else if (strcmp(defel->defname, "groupElts") == 0)
{
if (dgroupElts)
elog(ERROR, "CREATE USER: conflicting options");
dgroupElts = defel;
}
else if (strcmp(defel->defname, "validUntil") == 0) {
else if (strcmp(defel->defname, "validUntil") == 0)
{
if (dvalidUntil)
elog(ERROR, "CREATE USER: conflicting options");
dvalidUntil = defel;
}
else
elog(ERROR,"CREATE USER: option \"%s\" not recognized",
elog(ERROR, "CREATE USER: option \"%s\" not recognized",
defel->defname);
}
@@ -329,7 +337,7 @@ CreateUser(CreateUserStmt *stmt)
elog(ERROR, "CREATE USER: sysid %d is already assigned", sysid);
/* If no sysid given, use max existing id + 1 */
if (! havesysid)
if (!havesysid)
sysid = max_id + 1;
/*
@@ -355,7 +363,7 @@ CreateUser(CreateUserStmt *stmt)
else
{
if (!EncryptMD5(password, stmt->user, strlen(stmt->user),
encrypted_password))
encrypted_password))
elog(ERROR, "CREATE USER: password encryption failed");
new_record[Anum_pg_shadow_passwd - 1] =
DirectFunctionCall1(textin, CStringGetDatum(encrypted_password));
@@ -438,26 +446,28 @@ AlterUser(AlterUserStmt *stmt)
HeapTuple tuple,
new_tuple;
bool null;
List *option;
char *password = NULL; /* PostgreSQL user password */
bool encrypt_password = Password_encryption; /* encrypt password? */
char encrypted_password[MD5_PASSWD_LEN+1];
int createdb = -1; /* Can the user create databases? */
int createuser = -1; /* Can this user create users? */
char *validUntil = NULL; /* The time the login is valid until */
List *option;
char *password = NULL; /* PostgreSQL user password */
bool encrypt_password = Password_encryption; /* encrypt password? */
char encrypted_password[MD5_PASSWD_LEN + 1];
int createdb = -1; /* Can the user create databases? */
int createuser = -1; /* Can this user create users? */
char *validUntil = NULL; /* The time the login is valid
* until */
DefElem *dpassword = NULL;
DefElem *dcreatedb = NULL;
DefElem *dcreateuser = NULL;
DefElem *dvalidUntil = NULL;
/* Extract options from the statement node tree */
foreach(option,stmt->options)
foreach(option, stmt->options)
{
DefElem *defel = (DefElem *) lfirst(option);
DefElem *defel = (DefElem *) lfirst(option);
if (strcmp(defel->defname, "password") == 0 ||
strcmp(defel->defname, "encryptedPassword") == 0 ||
strcmp(defel->defname, "unencryptedPassword") == 0) {
strcmp(defel->defname, "unencryptedPassword") == 0)
{
if (dpassword)
elog(ERROR, "ALTER USER: conflicting options");
dpassword = defel;
@@ -466,23 +476,26 @@ AlterUser(AlterUserStmt *stmt)
else if (strcmp(defel->defname, "unencryptedPassword") == 0)
encrypt_password = false;
}
else if (strcmp(defel->defname, "createdb") == 0) {
else if (strcmp(defel->defname, "createdb") == 0)
{
if (dcreatedb)
elog(ERROR, "ALTER USER: conflicting options");
dcreatedb = defel;
}
else if (strcmp(defel->defname, "createuser") == 0) {
else if (strcmp(defel->defname, "createuser") == 0)
{
if (dcreateuser)
elog(ERROR, "ALTER USER: conflicting options");
dcreateuser = defel;
}
else if (strcmp(defel->defname, "validUntil") == 0) {
else if (strcmp(defel->defname, "validUntil") == 0)
{
if (dvalidUntil)
elog(ERROR, "ALTER USER: conflicting options");
dvalidUntil = defel;
}
else
elog(ERROR,"ALTER USER: option \"%s\" not recognized",
elog(ERROR, "ALTER USER: option \"%s\" not recognized",
defel->defname);
}
@@ -556,10 +569,10 @@ AlterUser(AlterUserStmt *stmt)
/*
* createuser (superuser) and catupd
*
* XXX It's rather unclear how to handle catupd. It's probably
* best to keep it equal to the superuser status, otherwise you
* could end up with a situation where no existing superuser can
* alter the catalogs, including pg_shadow!
* XXX It's rather unclear how to handle catupd. It's probably best to
* keep it equal to the superuser status, otherwise you could end up
* with a situation where no existing superuser can alter the
* catalogs, including pg_shadow!
*/
if (createuser < 0)
{
@@ -588,7 +601,7 @@ AlterUser(AlterUserStmt *stmt)
else
{
if (!EncryptMD5(password, stmt->user, strlen(stmt->user),
encrypted_password))
encrypted_password))
elog(ERROR, "CREATE USER: password encryption failed");
new_record[Anum_pg_shadow_passwd - 1] =
DirectFunctionCall1(textin, CStringGetDatum(encrypted_password));
@@ -719,7 +732,7 @@ DropUser(DropUserStmt *stmt)
if (HeapTupleIsValid(tmp_tuple = heap_getnext(scan, 0)))
{
char *dbname;
char *dbname;
datum = heap_getattr(tmp_tuple, Anum_pg_database_datname,
pg_dsc, &null);
@@ -847,20 +860,22 @@ CreateGroup(CreateGroupStmt *stmt)
foreach(option, stmt->options)
{
DefElem *defel = (DefElem *) lfirst(option);
DefElem *defel = (DefElem *) lfirst(option);
if (strcmp(defel->defname, "sysid") == 0) {
if (strcmp(defel->defname, "sysid") == 0)
{
if (dsysid)
elog(ERROR, "CREATE GROUP: conflicting options");
dsysid = defel;
}
else if (strcmp(defel->defname, "userElts") == 0) {
else if (strcmp(defel->defname, "userElts") == 0)
{
if (duserElts)
elog(ERROR, "CREATE GROUP: conflicting options");
duserElts = defel;
}
else
elog(ERROR,"CREATE GROUP: option \"%s\" not recognized",
elog(ERROR, "CREATE GROUP: option \"%s\" not recognized",
defel->defname);
}
@@ -900,7 +915,7 @@ CreateGroup(CreateGroupStmt *stmt)
datum = heap_getattr(tuple, Anum_pg_group_grosysid,
pg_group_dsc, &null);
Assert(!null);
if (havesysid) /* customized id wanted */
if (havesysid) /* customized id wanted */
sysid_exists = (DatumGetInt32(datum) == sysid);
else
{
@@ -939,7 +954,7 @@ CreateGroup(CreateGroupStmt *stmt)
userarray = palloc(ARR_OVERHEAD(1) + length(newlist) * sizeof(int32));
userarray->size = ARR_OVERHEAD(1) + length(newlist) * sizeof(int32);
userarray->flags = 0;
ARR_NDIM(userarray) = 1;/* one dimensional array */
ARR_NDIM(userarray) = 1; /* one dimensional array */
ARR_LBOUND(userarray)[0] = 1; /* axis starts at one */
ARR_DIMS(userarray)[0] = length(newlist); /* axis is this long */
/* fill the array */
@@ -1088,6 +1103,7 @@ AlterGroup(AlterGroupStmt *stmt, const char *tag)
if (!member(v, newlist))
newlist = lappend(newlist, v);
else
/*
* we silently assume here that this error will only come
* up in a ALTER GROUP statement

253
src/backend/commands/vacuum.c
View File

@@ -4,7 +4,7 @@
* The postgres vacuum cleaner.
*
* This file includes the "full" version of VACUUM, as well as control code
* used by all three of full VACUUM, lazy VACUUM, and ANALYZE. See
* used by all three of full VACUUM, lazy VACUUM, and ANALYZE. See
* vacuumlazy.c and analyze.c for the rest of the code for the latter two.
*
*
@@ -13,7 +13,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.209 2001/09/04 19:12:05 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.210 2001/10/25 05:49:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -68,11 +68,11 @@ typedef VacPageData *VacPage;
typedef struct VacPageListData
{
BlockNumber empty_end_pages; /* Number of "empty" end-pages */
int num_pages; /* Number of pages in pagedesc */
BlockNumber empty_end_pages; /* Number of "empty" end-pages */
int num_pages; /* Number of pages in pagedesc */
int num_allocated_pages; /* Number of allocated pages in
* pagedesc */
VacPage *pagedesc; /* Descriptions of pages */
VacPage *pagedesc; /* Descriptions of pages */
} VacPageListData;
typedef VacPageListData *VacPageList;
@@ -96,7 +96,7 @@ typedef VTupleMoveData *VTupleMove;
typedef struct VRelStats
{
BlockNumber rel_pages;
BlockNumber rel_pages;
double rel_tuples;
Size min_tlen;
Size max_tlen;
@@ -122,32 +122,32 @@ static void vacuum_init(VacuumStmt *vacstmt);
static void vacuum_shutdown(VacuumStmt *vacstmt);
static VRelList getrels(Name VacRelP, const char *stmttype);
static void vac_update_dbstats(Oid dbid,
TransactionId vacuumXID,
TransactionId frozenXID);
TransactionId vacuumXID,
TransactionId frozenXID);
static void vac_truncate_clog(TransactionId vacuumXID,
TransactionId frozenXID);
TransactionId frozenXID);
static void vacuum_rel(Oid relid, VacuumStmt *vacstmt);
static void full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt);
static void scan_heap(VRelStats *vacrelstats, Relation onerel,
VacPageList vacuum_pages, VacPageList fraged_pages);
VacPageList vacuum_pages, VacPageList fraged_pages);
static void repair_frag(VRelStats *vacrelstats, Relation onerel,
VacPageList vacuum_pages, VacPageList fraged_pages,
int nindexes, Relation *Irel);
VacPageList vacuum_pages, VacPageList fraged_pages,
int nindexes, Relation *Irel);
static void vacuum_heap(VRelStats *vacrelstats, Relation onerel,
VacPageList vacpagelist);
VacPageList vacpagelist);
static void vacuum_page(Relation onerel, Buffer buffer, VacPage vacpage);
static void vacuum_index(VacPageList vacpagelist, Relation indrel,
double num_tuples, int keep_tuples);
double num_tuples, int keep_tuples);
static void scan_index(Relation indrel, double num_tuples);
static bool tid_reaped(ItemPointer itemptr, void *state);
static bool dummy_tid_reaped(ItemPointer itemptr, void *state);
static void vac_update_fsm(Relation onerel, VacPageList fraged_pages,
BlockNumber rel_pages);
BlockNumber rel_pages);
static VacPage copy_vac_page(VacPage vacpage);
static void vpage_insert(VacPageList vacpagelist, VacPage vpnew);
static void *vac_bsearch(const void *key, const void *base,
size_t nelem, size_t size,
int (*compar) (const void *, const void *));
size_t nelem, size_t size,
int (*compar) (const void *, const void *));
static int vac_cmp_blk(const void *left, const void *right);
static int vac_cmp_offno(const void *left, const void *right);
static int vac_cmp_vtlinks(const void *left, const void *right);
@@ -227,11 +227,11 @@ vacuum(VacuumStmt *vacstmt)
vacuum_init(vacstmt);
/*
* Process each selected relation. We are careful to process
* each relation in a separate transaction in order to avoid holding
* too many locks at one time. Also, if we are doing VACUUM ANALYZE,
* the ANALYZE part runs as a separate transaction from the VACUUM
* to further reduce locking.
* Process each selected relation. We are careful to process each
* relation in a separate transaction in order to avoid holding too
* many locks at one time. Also, if we are doing VACUUM ANALYZE, the
* ANALYZE part runs as a separate transaction from the VACUUM to
* further reduce locking.
*/
for (cur = vrl; cur != (VRelList) NULL; cur = cur->vrl_next)
{
@@ -271,21 +271,21 @@ vacuum_init(VacuumStmt *vacstmt)
if (vacstmt->vacuum && vacstmt->vacrel == NULL)
{
/*
* Compute the initially applicable OldestXmin and FreezeLimit XIDs,
* so that we can record these values at the end of the VACUUM.
* Note that individual tables may well be processed with newer values,
* but we can guarantee that no (non-shared) relations are processed
* with older ones.
* Compute the initially applicable OldestXmin and FreezeLimit
* XIDs, so that we can record these values at the end of the
* VACUUM. Note that individual tables may well be processed with
* newer values, but we can guarantee that no (non-shared)
* relations are processed with older ones.
*
* It is okay to record non-shared values in pg_database, even though
* we may vacuum shared relations with older cutoffs, because only
* the minimum of the values present in pg_database matters. We
* can be sure that shared relations have at some time been vacuumed
* with cutoffs no worse than the global minimum; for, if there is
* a backend in some other DB with xmin = OLDXMIN that's determining
* the cutoff with which we vacuum shared relations, it is not possible
* for that database to have a cutoff newer than OLDXMIN recorded in
* pg_database.
* can be sure that shared relations have at some time been
* vacuumed with cutoffs no worse than the global minimum; for, if
* there is a backend in some other DB with xmin = OLDXMIN that's
* determining the cutoff with which we vacuum shared relations,
* it is not possible for that database to have a cutoff newer
* than OLDXMIN recorded in pg_database.
*/
vacuum_set_xid_limits(vacstmt, false,
&initialOldestXmin, &initialFreezeLimit);
@@ -316,11 +316,12 @@ vacuum_shutdown(VacuumStmt *vacstmt)
}
/*
* If we did a complete vacuum or analyze, then flush the init file that
* relcache.c uses to save startup time. The next backend startup will
* rebuild the init file with up-to-date information from pg_class.
* This lets the optimizer see the stats that we've collected for certain
* critical system indexes. See relcache.c for more details.
* If we did a complete vacuum or analyze, then flush the init file
* that relcache.c uses to save startup time. The next backend startup
* will rebuild the init file with up-to-date information from
* pg_class. This lets the optimizer see the stats that we've
* collected for certain critical system indexes. See relcache.c for
* more details.
*
* Ignore any failure to unlink the file, since it might not be there if
* no backend has been started since the last vacuum.
@@ -526,9 +527,10 @@ vac_update_relstats(Oid relid, BlockNumber num_pages, double num_tuples,
pgcform->relpages = (int32) num_pages;
pgcform->reltuples = num_tuples;
pgcform->relhasindex = hasindex;
/*
* If we have discovered that there are no indexes, then there's
* no primary key either. This could be done more thoroughly...
* If we have discovered that there are no indexes, then there's no
* primary key either. This could be done more thoroughly...
*/
if (!hasindex)
pgcform->relhaspkey = false;
@@ -606,7 +608,7 @@ vac_update_dbstats(Oid dbid,
* seems to be in danger of wrapping around.
*
* The passed XIDs are simply the ones I just wrote into my pg_database
* entry. They're used to initialize the "min" calculations.
* entry. They're used to initialize the "min" calculations.
*
* This routine is shared by full and lazy VACUUM. Note that it is only
* applied after a database-wide VACUUM operation.
@@ -708,26 +710,27 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt)
/*
* Determine the type of lock we want --- hard exclusive lock for a
* FULL vacuum, but just ShareUpdateExclusiveLock for concurrent
* vacuum. Either way, we can be sure that no other backend is vacuuming
* the same table.
* vacuum. Either way, we can be sure that no other backend is
* vacuuming the same table.
*/
lmode = vacstmt->full ? AccessExclusiveLock : ShareUpdateExclusiveLock;
/*
* Open the class, get an appropriate lock on it, and check permissions.
* Open the class, get an appropriate lock on it, and check
* permissions.
*
* We allow the user to vacuum a table if he is superuser, the table
* owner, or the database owner (but in the latter case, only if it's
* not a shared relation). pg_ownercheck includes the superuser case.
* not a shared relation). pg_ownercheck includes the superuser case.
*
* Note we choose to treat permissions failure as a NOTICE and keep
* trying to vacuum the rest of the DB --- is this appropriate?
*/
onerel = heap_open(relid, lmode);
if (! (pg_ownercheck(GetUserId(), RelationGetRelationName(onerel),
RELNAME) ||
(is_dbadmin(MyDatabaseId) && !onerel->rd_rel->relisshared)))
if (!(pg_ownercheck(GetUserId(), RelationGetRelationName(onerel),
RELNAME) ||
(is_dbadmin(MyDatabaseId) && !onerel->rd_rel->relisshared)))
{
elog(NOTICE, "Skipping \"%s\" --- only table or database owner can VACUUM it",
RelationGetRelationName(onerel));
@@ -773,9 +776,9 @@ vacuum_rel(Oid relid, VacuumStmt *vacstmt)
/*
* If the relation has a secondary toast rel, vacuum that too while we
* still hold the session lock on the master table. Note however that
* "analyze" will not get done on the toast table. This is good,
* because the toaster always uses hardcoded index access and statistics
* are totally unimportant for toast relations.
* "analyze" will not get done on the toast table. This is good,
* because the toaster always uses hardcoded index access and
* statistics are totally unimportant for toast relations.
*/
if (toast_relid != InvalidOid)
vacuum_rel(toast_relid, vacstmt);
@@ -846,6 +849,7 @@ full_vacuum_rel(Relation onerel, VacuumStmt *vacstmt)
vacrelstats->hasindex = true;
#ifdef NOT_USED
/*
* reindex in VACUUM is dangerous under WAL. ifdef out until it
* becomes safe.
@@ -945,7 +949,7 @@ scan_heap(VRelStats *vacrelstats, Relation onerel,
char *relname;
VacPage vacpage,
vacpagecopy;
BlockNumber empty_pages,
BlockNumber empty_pages,
new_pages,
changed_pages,
empty_end_pages;
@@ -1057,12 +1061,13 @@ scan_heap(VRelStats *vacrelstats, Relation onerel,
switch (HeapTupleSatisfiesVacuum(tuple.t_data, OldestXmin))
{
case HEAPTUPLE_DEAD:
tupgone = true; /* we can delete the tuple */
tupgone = true; /* we can delete the tuple */
break;
case HEAPTUPLE_LIVE:
/*
* Tuple is good. Consider whether to replace its xmin
* value with FrozenTransactionId.
* Tuple is good. Consider whether to replace its
* xmin value with FrozenTransactionId.
*/
if (TransactionIdIsNormal(tuple.t_data->t_xmin) &&
TransactionIdPrecedes(tuple.t_data->t_xmin,
@@ -1075,11 +1080,13 @@ scan_heap(VRelStats *vacrelstats, Relation onerel,
}
break;
case HEAPTUPLE_RECENTLY_DEAD:
/*
* If tuple is recently deleted then we must not remove
* it from relation.
* If tuple is recently deleted then we must not
* remove it from relation.
*/
nkeep += 1;
/*
* If we do shrinking and this tuple is updated one
* then remember it to construct updated tuple
@@ -1103,18 +1110,20 @@ scan_heap(VRelStats *vacrelstats, Relation onerel,
}
break;
case HEAPTUPLE_INSERT_IN_PROGRESS:
/*
* This should not happen, since we hold exclusive lock
* on the relation; shouldn't we raise an error?
* This should not happen, since we hold exclusive
* lock on the relation; shouldn't we raise an error?
*/
elog(NOTICE, "Rel %s: TID %u/%u: InsertTransactionInProgress %u - can't shrink relation",
relname, blkno, offnum, tuple.t_data->t_xmin);
do_shrinking = false;
break;
case HEAPTUPLE_DELETE_IN_PROGRESS:
/*
* This should not happen, since we hold exclusive lock
* on the relation; shouldn't we raise an error?
* This should not happen, since we hold exclusive
* lock on the relation; shouldn't we raise an error?
*/
elog(NOTICE, "Rel %s: TID %u/%u: DeleteTransactionInProgress %u - can't shrink relation",
relname, blkno, offnum, tuple.t_data->t_xmax);
@@ -1174,7 +1183,7 @@ scan_heap(VRelStats *vacrelstats, Relation onerel,
if (tuple.t_len > max_tlen)
max_tlen = tuple.t_len;
}
} /* scan along page */
} /* scan along page */
if (tempPage != (Page) NULL)
{
@@ -1193,13 +1202,14 @@ scan_heap(VRelStats *vacrelstats, Relation onerel,
}
free_size += vacpage->free;
/*
* Add the page to fraged_pages if it has a useful amount of free
* space. "Useful" means enough for a minimal-sized tuple.
* But we don't know that accurately near the start of the relation,
* so add pages unconditionally if they have >= BLCKSZ/10 free space.
* space. "Useful" means enough for a minimal-sized tuple. But we
* don't know that accurately near the start of the relation, so
* add pages unconditionally if they have >= BLCKSZ/10 free space.
*/
do_frag = (vacpage->free >= min_tlen || vacpage->free >= BLCKSZ/10);
do_frag = (vacpage->free >= min_tlen || vacpage->free >= BLCKSZ / 10);
if (do_reap || do_frag)
{
@@ -1238,9 +1248,9 @@ scan_heap(VRelStats *vacrelstats, Relation onerel,
fraged_pages->empty_end_pages = empty_end_pages;
/*
* Clear the fraged_pages list if we found we couldn't shrink.
* Else, remove any "empty" end-pages from the list, and compute
* usable free space = free space in remaining pages.
* Clear the fraged_pages list if we found we couldn't shrink. Else,
* remove any "empty" end-pages from the list, and compute usable free
* space = free space in remaining pages.
*/
if (do_shrinking)
{
@@ -1303,9 +1313,9 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
CommandId myCID;
Buffer buf,
cur_buffer;
BlockNumber nblocks,
BlockNumber nblocks,
blkno;
BlockNumber last_move_dest_block = 0,
BlockNumber last_move_dest_block = 0,
last_vacuum_block;
Page page,
ToPage = NULL;
@@ -1355,7 +1365,7 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
resultRelInfo = makeNode(ResultRelInfo);
resultRelInfo->ri_RangeTableIndex = 1; /* dummy */
resultRelInfo->ri_RelationDesc = onerel;
resultRelInfo->ri_TrigDesc = NULL; /* we don't fire triggers */
resultRelInfo->ri_TrigDesc = NULL; /* we don't fire triggers */
ExecOpenIndices(resultRelInfo);
@@ -1393,9 +1403,9 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
/*
* Scan pages backwards from the last nonempty page, trying to move
* tuples down to lower pages. Quit when we reach a page that we have
* moved any tuples onto, or the first page if we haven't moved anything,
* or when we find a page we cannot completely empty (this last condition
* is handled by "break" statements within the loop).
* moved any tuples onto, or the first page if we haven't moved
* anything, or when we find a page we cannot completely empty (this
* last condition is handled by "break" statements within the loop).
*
* NB: this code depends on the vacuum_pages and fraged_pages lists being
* in order by blkno.
@@ -1406,19 +1416,20 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
blkno--)
{
/*
* Forget fraged_pages pages at or after this one; they're no longer
* useful as move targets, since we only want to move down. Note
* that since we stop the outer loop at last_move_dest_block, pages
* removed here cannot have had anything moved onto them already.
* Forget fraged_pages pages at or after this one; they're no
* longer useful as move targets, since we only want to move down.
* Note that since we stop the outer loop at last_move_dest_block,
* pages removed here cannot have had anything moved onto them
* already.
*
* Also note that we don't change the stored fraged_pages list,
* only our local variable num_fraged_pages; so the forgotten pages
* are still available to be loaded into the free space map later.
* Also note that we don't change the stored fraged_pages list, only
* our local variable num_fraged_pages; so the forgotten pages are
* still available to be loaded into the free space map later.
*/
while (num_fraged_pages > 0 &&
fraged_pages->pagedesc[num_fraged_pages-1]->blkno >= blkno)
fraged_pages->pagedesc[num_fraged_pages - 1]->blkno >= blkno)
{
Assert(fraged_pages->pagedesc[num_fraged_pages-1]->offsets_used == 0);
Assert(fraged_pages->pagedesc[num_fraged_pages - 1]->offsets_used == 0);
--num_fraged_pages;
}
@@ -1534,7 +1545,7 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
* tuples to another places.
*/
if ((tuple.t_data->t_infomask & HEAP_UPDATED &&
!TransactionIdPrecedes(tuple.t_data->t_xmin, OldestXmin)) ||
!TransactionIdPrecedes(tuple.t_data->t_xmin, OldestXmin)) ||
(!(tuple.t_data->t_infomask & HEAP_XMAX_INVALID) &&
!(ItemPointerEquals(&(tuple.t_self),
&(tuple.t_data->t_ctid)))))
@@ -1581,7 +1592,6 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
ItemPointerGetOffsetNumber(&Ctid));
if (!ItemIdIsUsed(Citemid))
{
/*
* This means that in the middle of chain there
* was tuple updated by older (than OldestXmin)
@@ -1652,7 +1662,7 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
/* All done ? */
if (!(tp.t_data->t_infomask & HEAP_UPDATED) ||
TransactionIdPrecedes(tp.t_data->t_xmin, OldestXmin))
TransactionIdPrecedes(tp.t_data->t_xmin, OldestXmin))
break;
/* Well, try to find tuple with old row version */
@@ -2109,9 +2119,9 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
/*
* We are not going to move any more tuples across pages, but we still
* need to apply vacuum_page to compact free space in the remaining
* pages in vacuum_pages list. Note that some of these pages may also
* be in the fraged_pages list, and may have had tuples moved onto them;
* if so, we already did vacuum_page and needn't do it again.
* pages in vacuum_pages list. Note that some of these pages may also
* be in the fraged_pages list, and may have had tuples moved onto
* them; if so, we already did vacuum_page and needn't do it again.
*/
for (i = 0, curpage = vacuum_pages->pagedesc;
i < vacuumed_pages;
@@ -2132,15 +2142,15 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
}
/*
* Now scan all the pages that we moved tuples onto and update
* tuple status bits. This is not really necessary, but will save time
* for future transactions examining these tuples.
* Now scan all the pages that we moved tuples onto and update tuple
* status bits. This is not really necessary, but will save time for
* future transactions examining these tuples.
*
* XXX Notice that this code fails to clear HEAP_MOVED_OFF tuples from
* pages that were move source pages but not move dest pages. One also
* wonders whether it wouldn't be better to skip this step and let the
* tuple status updates happen someplace that's not holding an exclusive
* lock on the relation.
* pages that were move source pages but not move dest pages. One
* also wonders whether it wouldn't be better to skip this step and
* let the tuple status updates happen someplace that's not holding an
* exclusive lock on the relation.
*/
checked_moved = 0;
for (i = 0, curpage = fraged_pages->pagedesc;
@@ -2226,7 +2236,7 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
if (vacpage->blkno == (blkno - 1) &&
vacpage->offsets_free > 0)
{
OffsetNumber unbuf[BLCKSZ/sizeof(OffsetNumber)];
OffsetNumber unbuf[BLCKSZ / sizeof(OffsetNumber)];
OffsetNumber *unused = unbuf;
int uncnt;
@@ -2297,7 +2307,7 @@ repair_frag(VRelStats *vacrelstats, Relation onerel,
if (blkno < nblocks)
{
blkno = smgrtruncate(DEFAULT_SMGR, onerel, blkno);
onerel->rd_nblocks = blkno; /* update relcache immediately */
onerel->rd_nblocks = blkno; /* update relcache immediately */
onerel->rd_targblock = InvalidBlockNumber;
vacrelstats->rel_pages = blkno; /* set new number of blocks */
}
@@ -2323,7 +2333,7 @@ vacuum_heap(VRelStats *vacrelstats, Relation onerel, VacPageList vacuum_pages)
{
Buffer buf;
VacPage *vacpage;
BlockNumber relblocks;
BlockNumber relblocks;
int nblocks;
int i;
@@ -2363,7 +2373,7 @@ vacuum_heap(VRelStats *vacrelstats, Relation onerel, VacPageList vacuum_pages)
RelationGetRelationName(onerel),
vacrelstats->rel_pages, relblocks);
relblocks = smgrtruncate(DEFAULT_SMGR, onerel, relblocks);
onerel->rd_nblocks = relblocks; /* update relcache immediately */
onerel->rd_nblocks = relblocks; /* update relcache immediately */
onerel->rd_targblock = InvalidBlockNumber;
vacrelstats->rel_pages = relblocks; /* set new number of
* blocks */
@@ -2377,7 +2387,7 @@ vacuum_heap(VRelStats *vacrelstats, Relation onerel, VacPageList vacuum_pages)
static void
vacuum_page(Relation onerel, Buffer buffer, VacPage vacpage)
{
OffsetNumber unbuf[BLCKSZ/sizeof(OffsetNumber)];
OffsetNumber unbuf[BLCKSZ / sizeof(OffsetNumber)];
OffsetNumber *unused = unbuf;
int uncnt;
Page page = BufferGetPage(buffer);
@@ -2420,8 +2430,8 @@ scan_index(Relation indrel, double num_tuples)
/*
* Even though we're not planning to delete anything, use the
* ambulkdelete call, so that the scan happens within the index AM
* for more speed.
* ambulkdelete call, so that the scan happens within the index AM for
* more speed.
*/
stats = index_bulk_delete(indrel, dummy_tid_reaped, NULL);
@@ -2439,13 +2449,13 @@ scan_index(Relation indrel, double num_tuples)
vac_show_rusage(&ru0));
/*
* Check for tuple count mismatch. If the index is partial, then
* it's OK for it to have fewer tuples than the heap; else we got trouble.
* Check for tuple count mismatch. If the index is partial, then it's
* OK for it to have fewer tuples than the heap; else we got trouble.
*/
if (stats->num_index_tuples != num_tuples)
{
if (stats->num_index_tuples > num_tuples ||
! vac_is_partial_index(indrel))
!vac_is_partial_index(indrel))
elog(NOTICE, "Index %s: NUMBER OF INDEX' TUPLES (%.0f) IS NOT THE SAME AS HEAP' (%.0f).\
\n\tRecreate the index.",
RelationGetRelationName(indrel),
@@ -2493,13 +2503,13 @@ vacuum_index(VacPageList vacpagelist, Relation indrel,
vac_show_rusage(&ru0));
/*
* Check for tuple count mismatch. If the index is partial, then
* it's OK for it to have fewer tuples than the heap; else we got trouble.
* Check for tuple count mismatch. If the index is partial, then it's
* OK for it to have fewer tuples than the heap; else we got trouble.
*/
if (stats->num_index_tuples != num_tuples + keep_tuples)
{
if (stats->num_index_tuples > num_tuples + keep_tuples ||
! vac_is_partial_index(indrel))
!vac_is_partial_index(indrel))
elog(NOTICE, "Index %s: NUMBER OF INDEX' TUPLES (%.0f) IS NOT THE SAME AS HEAP' (%.0f).\
\n\tRecreate the index.",
RelationGetRelationName(indrel),
@@ -2519,7 +2529,7 @@ vacuum_index(VacPageList vacpagelist, Relation indrel,
static bool
tid_reaped(ItemPointer itemptr, void *state)
{
VacPageList vacpagelist = (VacPageList) state;
VacPageList vacpagelist = (VacPageList) state;
OffsetNumber ioffno;
OffsetNumber *voff;
VacPage vp,
@@ -2591,9 +2601,11 @@ vac_update_fsm(Relation onerel, VacPageList fraged_pages,
{
pages[i] = fraged_pages->pagedesc[i]->blkno;
spaceAvail[i] = fraged_pages->pagedesc[i]->free;
/*
* fraged_pages may contain entries for pages that we later decided
* to truncate from the relation; don't enter them into the map!
* fraged_pages may contain entries for pages that we later
* decided to truncate from the relation; don't enter them into
* the map!
*/
if (pages[i] >= rel_pages)
{
@@ -2617,7 +2629,7 @@ copy_vac_page(VacPage vacpage)
/* allocate a VacPageData entry */
newvacpage = (VacPage) palloc(sizeof(VacPageData) +
vacpage->offsets_free * sizeof(OffsetNumber));
vacpage->offsets_free * sizeof(OffsetNumber));
/* fill it in */
if (vacpage->offsets_free > 0)
@@ -2661,7 +2673,7 @@ vpage_insert(VacPageList vacpagelist, VacPage vpnew)
/*
* vac_bsearch: just like standard C library routine bsearch(),
* except that we first test to see whether the target key is outside
* the range of the table entries. This case is handled relatively slowly
* the range of the table entries. This case is handled relatively slowly
* by the normal binary search algorithm (ie, no faster than any other key)
* but it occurs often enough in VACUUM to be worth optimizing.
*/
@@ -2802,14 +2814,15 @@ vac_is_partial_index(Relation indrel)
Form_pg_index indexStruct;
/*
* If the index's AM doesn't support nulls, it's partial for our purposes
* If the index's AM doesn't support nulls, it's partial for our
* purposes
*/
if (! indrel->rd_am->amindexnulls)
if (!indrel->rd_am->amindexnulls)
return true;
/* Otherwise, look to see if there's a partial-index predicate */
cachetuple = SearchSysCache(INDEXRELID,
ObjectIdGetDatum(RelationGetRelid(indrel)),
ObjectIdGetDatum(RelationGetRelid(indrel)),
0, 0, 0);
if (!HeapTupleIsValid(cachetuple))
elog(ERROR, "vac_is_partial_index: index %u not found",
@@ -2888,9 +2901,9 @@ vac_show_rusage(VacRUsage *ru0)
snprintf(result, sizeof(result),
"CPU %d.%02ds/%d.%02du sec elapsed %d.%02d sec.",
(int) (ru1.ru.ru_stime.tv_sec - ru0->ru.ru_stime.tv_sec),
(int) (ru1.ru.ru_stime.tv_usec - ru0->ru.ru_stime.tv_usec) / 10000,
(int) (ru1.ru.ru_stime.tv_usec - ru0->ru.ru_stime.tv_usec) / 10000,
(int) (ru1.ru.ru_utime.tv_sec - ru0->ru.ru_utime.tv_sec),
(int) (ru1.ru.ru_utime.tv_usec - ru0->ru.ru_utime.tv_usec) / 10000,
(int) (ru1.ru.ru_utime.tv_usec - ru0->ru.ru_utime.tv_usec) / 10000,
(int) (ru1.tv.tv_sec - ru0->tv.tv_sec),
(int) (ru1.tv.tv_usec - ru0->tv.tv_usec) / 10000);

192
src/backend/commands/vacuumlazy.c
View File

@@ -18,8 +18,8 @@
*
* We can limit the storage for page free space to MaxFSMPages entries,
* since that's the most the free space map will be willing to remember
* anyway. If the relation has fewer than that many pages with free space,
* life is easy: just build an array of per-page info. If it has more,
* anyway. If the relation has fewer than that many pages with free space,
* life is easy: just build an array of per-page info. If it has more,
* we store the free space info as a heap ordered by amount of free space,
* so that we can discard the pages with least free space to ensure we never
* have more than MaxFSMPages entries in all. The surviving page entries
@@ -31,7 +31,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/vacuumlazy.c,v 1.8 2001/09/29 04:02:22 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/vacuumlazy.c,v 1.9 2001/10/25 05:49:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -51,7 +51,7 @@
* Space/time tradeoff parameters: do these need to be user-tunable?
*
* A page with less than PAGE_SPACE_THRESHOLD free space will be forgotten
* immediately, and not even passed to the free space map. Removing the
* immediately, and not even passed to the free space map. Removing the
* uselessly small entries early saves cycles, and in particular reduces
* the amount of time we spend holding the FSM lock when we finally call
* MultiRecordFreeSpace. Since the FSM will ignore pages below its own
@@ -74,21 +74,21 @@
typedef struct LVRelStats
{
/* Overall statistics about rel */
BlockNumber rel_pages;
BlockNumber rel_pages;
double rel_tuples;
BlockNumber nonempty_pages; /* actually, last nonempty page + 1 */
BlockNumber nonempty_pages; /* actually, last nonempty page + 1 */
/* List of TIDs of tuples we intend to delete */
/* NB: this list is ordered by TID address */
int num_dead_tuples; /* current # of entries */
int max_dead_tuples; /* # slots allocated in array */
ItemPointer dead_tuples; /* array of ItemPointerData */
int num_dead_tuples; /* current # of entries */
int max_dead_tuples; /* # slots allocated in array */
ItemPointer dead_tuples; /* array of ItemPointerData */
/* Array or heap of per-page info about free space */
/* We use a simple array until it fills up, then convert to heap */
bool fs_is_heap; /* are we using heap organization? */
int num_free_pages; /* current # of entries */
int max_free_pages; /* # slots allocated in arrays */
BlockNumber *free_pages; /* array or heap of block numbers */
Size *free_spaceavail; /* array or heap of available space */
bool fs_is_heap; /* are we using heap organization? */
int num_free_pages; /* current # of entries */
int max_free_pages; /* # slots allocated in arrays */
BlockNumber *free_pages; /* array or heap of block numbers */
Size *free_spaceavail; /* array or heap of available space */
} LVRelStats;
@@ -100,20 +100,20 @@ static TransactionId FreezeLimit;
/* non-export function prototypes */
static void lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
Relation *Irel, int nindexes);
Relation *Irel, int nindexes);
static void lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats);
static void lazy_scan_index(Relation indrel, LVRelStats *vacrelstats);
static void lazy_vacuum_index(Relation indrel, LVRelStats *vacrelstats);
static int lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
int tupindex, LVRelStats *vacrelstats);
static int lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
int tupindex, LVRelStats *vacrelstats);
static void lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats);
static BlockNumber count_nondeletable_pages(Relation onerel,
LVRelStats *vacrelstats);
LVRelStats *vacrelstats);
static void lazy_space_alloc(LVRelStats *vacrelstats, BlockNumber relblocks);
static void lazy_record_dead_tuple(LVRelStats *vacrelstats,
ItemPointer itemptr);
ItemPointer itemptr);
static void lazy_record_free_space(LVRelStats *vacrelstats,
BlockNumber page, Size avail);
BlockNumber page, Size avail);
static bool lazy_tid_reaped(ItemPointer itemptr, void *state);
static bool dummy_tid_reaped(ItemPointer itemptr, void *state);
static void lazy_update_fsm(Relation onerel, LVRelStats *vacrelstats);
@@ -136,7 +136,7 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt)
Relation *Irel;
int nindexes;
bool hasindex;
BlockNumber possibly_freeable;
BlockNumber possibly_freeable;
/* initialize */
if (vacstmt->verbose)
@@ -163,8 +163,8 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt)
/*
* Optionally truncate the relation.
*
* Don't even think about it unless we have a shot at releasing a
* goodly number of pages. Otherwise, the time taken isn't worth it.
* Don't even think about it unless we have a shot at releasing a goodly
* number of pages. Otherwise, the time taken isn't worth it.
*/
possibly_freeable = vacrelstats->rel_pages - vacrelstats->nonempty_pages;
if (possibly_freeable > vacrelstats->rel_pages / REL_TRUNCATE_FRACTION)
@@ -195,7 +195,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
blkno;
HeapTupleData tuple;
char *relname;
BlockNumber empty_pages,
BlockNumber empty_pages,
changed_pages;
double num_tuples,
tups_vacuumed,
@@ -231,8 +231,9 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
int prev_dead_count;
/*
* If we are close to overrunning the available space for dead-tuple
* TIDs, pause and do a cycle of vacuuming before we tackle this page.
* If we are close to overrunning the available space for
* dead-tuple TIDs, pause and do a cycle of vacuuming before we
* tackle this page.
*/
if ((vacrelstats->max_dead_tuples - vacrelstats->num_dead_tuples) < MAX_TUPLES_PER_PAGE &&
vacrelstats->num_dead_tuples > 0)
@@ -312,17 +313,18 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
switch (HeapTupleSatisfiesVacuum(tuple.t_data, OldestXmin))
{
case HEAPTUPLE_DEAD:
tupgone = true; /* we can delete the tuple */
tupgone = true; /* we can delete the tuple */
break;
case HEAPTUPLE_LIVE:
/*
* Tuple is good. Consider whether to replace its xmin
* value with FrozenTransactionId.
* Tuple is good. Consider whether to replace its
* xmin value with FrozenTransactionId.
*
* NB: Since we hold only a shared buffer lock here,
* we are assuming that TransactionId read/write
* is atomic. This is not the only place that makes
* such an assumption. It'd be possible to avoid the
* NB: Since we hold only a shared buffer lock here, we
* are assuming that TransactionId read/write is
* atomic. This is not the only place that makes such
* an assumption. It'd be possible to avoid the
* assumption by momentarily acquiring exclusive lock,
* but for the moment I see no need to.
*/
@@ -337,9 +339,10 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
}
break;
case HEAPTUPLE_RECENTLY_DEAD:
/*
* If tuple is recently deleted then we must not remove
* it from relation.
* If tuple is recently deleted then we must not
* remove it from relation.
*/
nkeep += 1;
break;
@@ -376,11 +379,11 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
num_tuples += 1;
hastup = true;
}
} /* scan along page */
} /* scan along page */
/*
* If we remembered any tuples for deletion, then the page will
* be visited again by lazy_vacuum_heap, which will compute and
* If we remembered any tuples for deletion, then the page will be
* visited again by lazy_vacuum_heap, which will compute and
* record its post-compaction free space. If not, then we're done
* with this page, so remember its free space as-is.
*/
@@ -418,7 +421,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
/* Remove tuples from heap */
lazy_vacuum_heap(onerel, vacrelstats);
}
else if (! did_vacuum_index)
else if (!did_vacuum_index)
{
/* Scan indexes just to update pg_class statistics about them */
for (i = 0; i < nindexes; i++)
@@ -457,7 +460,7 @@ lazy_vacuum_heap(Relation onerel, LVRelStats *vacrelstats)
tupindex = 0;
while (tupindex < vacrelstats->num_dead_tuples)
{
BlockNumber tblk;
BlockNumber tblk;
Buffer buf;
Page page;
@@ -493,7 +496,7 @@ static int
lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
int tupindex, LVRelStats *vacrelstats)
{
OffsetNumber unbuf[BLCKSZ/sizeof(OffsetNumber)];
OffsetNumber unbuf[BLCKSZ / sizeof(OffsetNumber)];
OffsetNumber *unused = unbuf;
int uncnt;
Page page = BufferGetPage(buffer);
@@ -502,8 +505,8 @@ lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
START_CRIT_SECTION();
for (; tupindex < vacrelstats->num_dead_tuples; tupindex++)
{
BlockNumber tblk;
OffsetNumber toff;
BlockNumber tblk;
OffsetNumber toff;
tblk = ItemPointerGetBlockNumber(&vacrelstats->dead_tuples[tupindex]);
if (tblk != blkno)
@@ -542,10 +545,10 @@ lazy_scan_index(Relation indrel, LVRelStats *vacrelstats)
vac_init_rusage(&ru0);
/*
* If the index is not partial, skip the scan, and just assume it
* has the same number of tuples as the heap.
* If the index is not partial, skip the scan, and just assume it has
* the same number of tuples as the heap.
*/
if (! vac_is_partial_index(indrel))
if (!vac_is_partial_index(indrel))
{
vac_update_relstats(RelationGetRelid(indrel),
RelationGetNumberOfBlocks(indrel),
@@ -555,23 +558,23 @@ lazy_scan_index(Relation indrel, LVRelStats *vacrelstats)
}
/*
* If index is unsafe for concurrent access, must lock it;
* but a shared lock should be sufficient.
* If index is unsafe for concurrent access, must lock it; but a
* shared lock should be sufficient.
*/
if (! indrel->rd_am->amconcurrent)
if (!indrel->rd_am->amconcurrent)
LockRelation(indrel, AccessShareLock);
/*
* Even though we're not planning to delete anything, use the
* ambulkdelete call, so that the scan happens within the index AM
* for more speed.
* ambulkdelete call, so that the scan happens within the index AM for
* more speed.
*/
stats = index_bulk_delete(indrel, dummy_tid_reaped, NULL);
/*
* Release lock acquired above.
*/
if (! indrel->rd_am->amconcurrent)
if (!indrel->rd_am->amconcurrent)
UnlockRelation(indrel, AccessShareLock);
if (!stats)
@@ -610,7 +613,7 @@ lazy_vacuum_index(Relation indrel, LVRelStats *vacrelstats)
/*
* If index is unsafe for concurrent access, must lock it.
*/
if (! indrel->rd_am->amconcurrent)
if (!indrel->rd_am->amconcurrent)
LockRelation(indrel, AccessExclusiveLock);
/* Do bulk deletion */
@@ -619,7 +622,7 @@ lazy_vacuum_index(Relation indrel, LVRelStats *vacrelstats)
/*
* Release lock acquired above.
*/
if (! indrel->rd_am->amconcurrent)
if (!indrel->rd_am->amconcurrent)
UnlockRelation(indrel, AccessExclusiveLock);
/* now update statistics in pg_class */
@@ -644,8 +647,8 @@ lazy_vacuum_index(Relation indrel, LVRelStats *vacrelstats)
static void
lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
{
BlockNumber old_rel_pages = vacrelstats->rel_pages;
BlockNumber new_rel_pages;
BlockNumber old_rel_pages = vacrelstats->rel_pages;
BlockNumber new_rel_pages;
BlockNumber *pages;
Size *spaceavail;
int n;
@@ -656,12 +659,13 @@ lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
vac_init_rusage(&ru0);
/*
* We need full exclusive lock on the relation in order to do truncation.
* If we can't get it, give up rather than waiting --- we don't want
* to block other backends, and we don't want to deadlock (which is
* quite possible considering we already hold a lower-grade lock).
* We need full exclusive lock on the relation in order to do
* truncation. If we can't get it, give up rather than waiting --- we
* don't want to block other backends, and we don't want to deadlock
* (which is quite possible considering we already hold a lower-grade
* lock).
*/
if (! ConditionalLockRelation(onerel, AccessExclusiveLock))
if (!ConditionalLockRelation(onerel, AccessExclusiveLock))
return;
/*
@@ -680,9 +684,9 @@ lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
/*
* Scan backwards from the end to verify that the end pages actually
* contain nothing we need to keep. This is *necessary*, not optional,
* because other backends could have added tuples to these pages whilst
* we were vacuuming.
* contain nothing we need to keep. This is *necessary*, not
* optional, because other backends could have added tuples to these
* pages whilst we were vacuuming.
*/
new_rel_pages = count_nondeletable_pages(onerel, vacrelstats);
@@ -710,9 +714,10 @@ lazy_truncate_heap(Relation onerel, LVRelStats *vacrelstats)
* Do the physical truncation.
*/
new_rel_pages = smgrtruncate(DEFAULT_SMGR, onerel, new_rel_pages);
onerel->rd_nblocks = new_rel_pages; /* update relcache immediately */
onerel->rd_nblocks = new_rel_pages; /* update relcache immediately */
onerel->rd_targblock = InvalidBlockNumber;
vacrelstats->rel_pages = new_rel_pages; /* save new number of blocks */
vacrelstats->rel_pages = new_rel_pages; /* save new number of
* blocks */
/*
* Drop free-space info for removed blocks; these must not get entered
@@ -808,15 +813,16 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
switch (HeapTupleSatisfiesVacuum(tuple.t_data, OldestXmin))
{
case HEAPTUPLE_DEAD:
tupgone = true; /* we can delete the tuple */
tupgone = true; /* we can delete the tuple */
break;
case HEAPTUPLE_LIVE:
/* Shouldn't be necessary to re-freeze anything */
break;
case HEAPTUPLE_RECENTLY_DEAD:
/*
* If tuple is recently deleted then we must not remove
* it from relation.
* If tuple is recently deleted then we must not
* remove it from relation.
*/
break;
case HEAPTUPLE_INSERT_IN_PROGRESS:
@@ -839,7 +845,7 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
hastup = true;
break; /* can stop scanning */
}
} /* scan along page */
} /* scan along page */
LockBuffer(buf, BUFFER_LOCK_UNLOCK);
@@ -855,8 +861,8 @@ count_nondeletable_pages(Relation onerel, LVRelStats *vacrelstats)
/*
* If we fall out of the loop, all the previously-thought-to-be-empty
* pages really are; we need not bother to look at the last known-nonempty
* page.
* pages really are; we need not bother to look at the last
* known-nonempty page.
*/
return vacrelstats->nonempty_pages;
}
@@ -907,9 +913,9 @@ lazy_record_dead_tuple(LVRelStats *vacrelstats,
ItemPointer itemptr)
{
/*
* The array shouldn't overflow under normal behavior,
* but perhaps it could if we are given a really small VacuumMem.
* In that case, just forget the last few tuples.
* The array shouldn't overflow under normal behavior, but perhaps it
* could if we are given a really small VacuumMem. In that case, just
* forget the last few tuples.
*/
if (vacrelstats->num_dead_tuples < vacrelstats->max_dead_tuples)
{
@@ -960,29 +966,29 @@ lazy_record_free_space(LVRelStats *vacrelstats,
*/
/* If we haven't yet converted the array to heap organization, do it */
if (! vacrelstats->fs_is_heap)
if (!vacrelstats->fs_is_heap)
{
/*
* Scan backwards through the array, "sift-up" each value into its
* correct position. We can start the scan at n/2-1 since each entry
* above that position has no children to worry about.
* correct position. We can start the scan at n/2-1 since each
* entry above that position has no children to worry about.
*/
int l = n / 2;
int l = n / 2;
while (--l >= 0)
{
BlockNumber R = pages[l];
BlockNumber R = pages[l];
Size K = spaceavail[l];
int i; /* i is where the "hole" is */
i = l;
for (;;)
{
int j = 2*i + 1;
int j = 2 * i + 1;
if (j >= n)
break;
if (j+1 < n && spaceavail[j] > spaceavail[j+1])
if (j + 1 < n && spaceavail[j] > spaceavail[j + 1])
j++;
if (K <= spaceavail[j])
break;
@@ -1001,20 +1007,20 @@ lazy_record_free_space(LVRelStats *vacrelstats,
if (avail > spaceavail[0])
{
/*
* Notionally, we replace the zero'th entry with the new data,
* and then sift-up to maintain the heap property. Physically,
* the new data doesn't get stored into the arrays until we find
* the right location for it.
* Notionally, we replace the zero'th entry with the new data, and
* then sift-up to maintain the heap property. Physically, the
* new data doesn't get stored into the arrays until we find the
* right location for it.
*/
int i = 0; /* i is where the "hole" is */
int i = 0; /* i is where the "hole" is */
for (;;)
{
int j = 2*i + 1;
int j = 2 * i + 1;
if (j >= n)
break;
if (j+1 < n && spaceavail[j] > spaceavail[j+1])
if (j + 1 < n && spaceavail[j] > spaceavail[j + 1])
j++;
if (avail <= spaceavail[j])
break;
@@ -1038,7 +1044,7 @@ static bool
lazy_tid_reaped(ItemPointer itemptr, void *state)
{
LVRelStats *vacrelstats = (LVRelStats *) state;
ItemPointer res;
ItemPointer res;
res = (ItemPointer) bsearch((void *) itemptr,
(void *) vacrelstats->dead_tuples,
@@ -1066,9 +1072,9 @@ static void
lazy_update_fsm(Relation onerel, LVRelStats *vacrelstats)
{
/*
* Since MultiRecordFreeSpace doesn't currently impose any restrictions
* on the ordering of the input, we can just pass it the arrays as-is,
* whether they are in heap or linear order.
* Since MultiRecordFreeSpace doesn't currently impose any
* restrictions on the ordering of the input, we can just pass it the
* arrays as-is, whether they are in heap or linear order.
*/
MultiRecordFreeSpace(&onerel->rd_node,
0, MaxBlockNumber,

58
src/backend/commands/variable.c
View File

@@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/variable.c,v 1.54 2001/10/18 17:30:14 thomas Exp $
* $Header: /cvsroot/pgsql/src/backend/commands/variable.c,v 1.55 2001/10/25 05:49:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -334,9 +334,10 @@ set_default_datestyle(void)
*/
DBDate = strdup(DBDate);
/* Parse desired setting into DateStyle/EuroDates
* Use parse_datestyle_internal() to avoid any palloc() issues per above
* - thomas 2001-10-15
/*
* Parse desired setting into DateStyle/EuroDates Use
* parse_datestyle_internal() to avoid any palloc() issues per above -
* thomas 2001-10-15
*/
parse_datestyle_internal(DBDate);
@@ -380,7 +381,7 @@ parse_timezone(List *args)
foreach(arg, args)
{
A_Const *p;
A_Const *p;
Assert(IsA(arg, List));
p = lfirst(arg);
@@ -394,24 +395,28 @@ parse_timezone(List *args)
Interval *interval;
interval = DatumGetIntervalP(DirectFunctionCall3(interval_in,
CStringGetDatum(p->val.val.str),
ObjectIdGetDatum(InvalidOid),
Int32GetDatum(-1)));
CStringGetDatum(p->val.val.str),
ObjectIdGetDatum(InvalidOid),
Int32GetDatum(-1)));
if (interval->month != 0)
elog(ERROR, "SET TIME ZONE illegal INTERVAL; month not allowed");
CTimeZone = interval->time;
}
else if (strcmp(type->name, "float8") == 0)
{
float8 time;
float8 time;
time = DatumGetFloat8(DirectFunctionCall1(float8in, CStringGetDatum(p->val.val.str)));
CTimeZone = time * 3600;
}
/* We do not actually generate an integer constant in gram.y so this is not used... */
/*
* We do not actually generate an integer constant in gram.y
* so this is not used...
*/
else if (strcmp(type->name, "int4") == 0)
{
int32 time;
int32 time;
time = p->val.val.ival;
CTimeZone = time * 3600;
@@ -462,11 +467,11 @@ parse_timezone(List *args)
static bool
show_timezone(void)
{
char *tzn;
char *tzn;
if (HasCTZSet)
{
Interval interval;
Interval interval;
interval.month = 0;
interval.time = CTimeZone;
@@ -474,9 +479,7 @@ show_timezone(void)
tzn = DatumGetCString(DirectFunctionCall1(interval_out, IntervalPGetDatum(&interval)));
}
else
{
tzn = getenv("TZ");
}
if (tzn != NULL)
elog(NOTICE, "Time zone is '%s'", tzn);
@@ -500,9 +503,7 @@ static bool
reset_timezone(void)
{
if (HasCTZSet)
{
HasCTZSet = false;
}
/* no time zone has been set in this session? */
else if (defaultTZ == NULL)
@@ -545,7 +546,7 @@ reset_timezone(void)
static bool
parse_XactIsoLevel(List *args)
{
char *value;
char *value;
if (args == NULL)
return reset_XactIsoLevel();
@@ -603,8 +604,8 @@ reset_XactIsoLevel(void)
static bool
parse_random_seed(List *args)
{
char *value;
double seed = 0;
char *value;
double seed = 0;
if (args == NULL)
return reset_random_seed();
@@ -648,9 +649,10 @@ reset_random_seed(void)
static bool
parse_client_encoding(List *args)
{
char *value;
char *value;
#ifdef MULTIBYTE
int encoding;
int encoding;
#endif
if (args == NULL)
@@ -679,7 +681,7 @@ parse_client_encoding(List *args)
}
#else
if (value &&
strcasecmp(value, pg_get_client_encoding_name()) != 0)
strcasecmp(value, pg_get_client_encoding_name()) != 0)
elog(ERROR, "Client encoding %s is not supported", value);
#endif
return TRUE;
@@ -766,14 +768,14 @@ SetPGVariable(const char *name, List *args)
parse_random_seed(args);
else
{
/* For routines defined somewhere else,
* go ahead and extract the string argument
* to match the original interface definition.
/*
* For routines defined somewhere else, go ahead and extract the
* string argument to match the original interface definition.
* Later, we can change this code too...
*/
char *value;
char *value;
value = ((args != NULL)? ((A_Const *) lfirst(args))->val.val.str: NULL);
value = ((args != NULL) ? ((A_Const *) lfirst(args))->val.val.str : NULL);
if (strcasecmp(name, "session_authorization") == 0)
SetSessionAuthorization(value);

6
src/backend/commands/view.c
View File

@@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: view.c,v 1.57 2001/08/16 20:38:53 tgl Exp $
* $Id: view.c,v 1.58 2001/10/25 05:49:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -131,7 +131,6 @@ DefineViewRules(char *viewName, Query *viewParse)
RuleStmt *replace_rule;
RuleStmt *append_rule;
RuleStmt *delete_rule;
#endif
retrieve_rule = FormViewRetrieveRule(viewName, viewParse);
@@ -141,7 +140,6 @@ DefineViewRules(char *viewName, Query *viewParse)
replace_rule = FormViewReplaceRule(viewName, viewParse);
append_rule = FormViewAppendRule(viewName, viewParse);
delete_rule = FormViewDeleteRule(viewName, viewParse);
#endif
DefineQueryRewrite(retrieve_rule);
@@ -229,7 +227,6 @@ UpdateRangeTableOfViewParse(char *viewName, Query *viewParse)
void
DefineView(char *viewName, Query *viewParse)
{
/*
* Create the "view" relation NOTE: if it already exists, the xact
* will be aborted.
@@ -264,7 +261,6 @@ DefineView(char *viewName, Query *viewParse)
void
RemoveView(char *viewName)
{
/*
* We just have to drop the relation; the associated rules will be
* cleaned up automatically.